# OpenMetadata

> Open data catalog and metadata graph that gives agents governed context about your data

- Category: Evaluation & Production Ops / Governance & Compliance
- Language: TypeScript
- Licence: Apache-2.0
- Repository: https://github.com/open-metadata/OpenMetadata
- Website: https://open-metadata.org
- Canonical page: https://ai-tldr.dev/tools/openmetadata/

## In short

OpenMetadata is an open-source platform for cataloguing data and the context around it. It sits in the Governance & Compliance category of the Evaluation & Production Ops tools and is open-source, written in TypeScript and licensed Apache-2.0. To get started: try the sandbox first.

## Overview

OpenMetadata is an open-source platform for cataloguing data and the context around it. It connects technical metadata — databases, schemas, tables, columns, topics, dashboards, pipelines, ML models — to the things that decide whether that data can be trusted or used: ownership, usage, column-level lineage, quality tests and freshness checks, glossaries, classifications, domains, policies, data contracts and data products. The result is a single metadata knowledge graph rather than a list of tables.

The AI angle is what the project leads with now. A raw warehouse connector tells an assistant what columns exist; it does not say what a metric means, whether a dataset is certified, who owns it, which policy applies or what breaks downstream if a column changes. OpenMetadata exposes exactly that through an MCP server at `/mcp`, semantic search that matches by meaning rather than exact names, and AI SDKs for Python, TypeScript and Java — so an agent queries governed context instead of guessing from schema names.

It ships 130+ connectors for warehouses, BI tools, pipeline systems, quality tools and lineage sources, supports open standards including DCAT, DPROD, PROV-O, OpenLineage, ODCS and RDF/OWL, and keeps a layer of organisational memory — conversations, decisions, assumptions, runbooks and remediation notes attached to assets. The project is released under Apache 2.0 and runs self-hosted; a public sandbox is available for a first look.

## What it does

- 130+ connectors across databases, warehouses, BI tools, pipelines, quality tools and lineage sources
- Table-level and column-level lineage with downstream impact analysis
- Data quality and trust signals: test cases and suites, freshness, volume, null, uniqueness and distribution checks, profiling history
- Business semantics — glossaries, metrics, classifications, domains, policies, data products and data contracts
- MCP server plus semantic search and AI SDKs (Python, TypeScript, Java) so agents get governed context
- Open standards support: DCAT, DPROD, PROV-O, OpenLineage, ODCS, RDF/OWL, JSON-LD, SHACL, JSON Schema

## Getting started

Start on the hosted sandbox to see the model, then self-host and point it at your first source. All packages and snippets below come from the project README.

1. Try the sandbox first

   The public sandbox has a populated catalogue, so you can explore lineage, glossaries and quality before installing anything.

```text
https://sandbox.open-metadata.org
```

2. Install the server

   The quickstart guide covers the self-hosted deployment; the server's API lives at `/api` on port 8585 by default.

```text
https://docs.open-metadata.org/latest/quick-start
```

3. Install the SDK you need

   One package reads and writes metadata; the other gives an LLM or agent governed access over MCP and LangChain.

```bash
pip install "openmetadata-ingestion"
pip install data-ai-sdk
```

4. Connect from Python and read an entity

   Match the SDK version to your server version. Entities are hierarchical and reference their parent by fully-qualified name.

```python
from metadata.generated.schema.entity.data.table import Table
from metadata.generated.schema.entity.services.connections.metadata.openMetadataConnection import (
    OpenMetadataConnection, AuthProvider,
)
from metadata.generated.schema.security.client.openMetadataJWTClientConfig import (
    OpenMetadataJWTClientConfig,
)
from metadata.ingestion.ometa.ometa_api import OpenMetadata

metadata = OpenMetadata(OpenMetadataConnection(
    hostPort="http://localhost:8585/api",
    authProvider=AuthProvider.openmetadata,
    securityConfig=OpenMetadataJWTClientConfig(jwtToken="<your-token>"),
))
assert metadata.health_check()

table = metadata.get_by_name(entity=Table, fqn="sample_data.ecommerce_db.shopify.raw_product_catalog")
print(table.description, [c.name.root for c in table.columns])
```

5. Point an agent at it over MCP

   The MCP server exposes semantic search, lineage traversal, glossary and classification lookups and metadata mutations as tools any MCP client can call.

```text
https://docs.open-metadata.org/latest/how-to-guides/mcp
```

## When to use it

- Reach for it when an AI assistant needs to know what a dataset means and whether it can be trusted, not just its schema
- Reach for it to answer impact questions — which dashboards, pipelines or models break if this column changes
- Reach for it when governance needs owners, policies, classifications and data contracts in one place
- Reach for it to give agents governed, policy-aware access to enterprise data context through MCP