OpenMetadata MCP Server for Metadata Management

Overview

The OpenMetadata MCP Server implements a lightweight Model Context Protocol (MCP) integration layer that connects models and applications to an OpenMetadata-backed metadata catalog. It centralizes metadata access, providing a single API surface for registering, querying, and resolving contextual data — schemas, descriptors, lineage, and business glossary — so downstream models and services can make reliable, auditable decisions based on current metadata.

By acting as a mediator between models and the OpenMetadata platform, the MCP server helps teams govern metadata use across applications, scale metadata-driven pipelines, and reduce direct coupling to the catalog. It is particularly useful when you want to surface curated metadata to LLMs or other model runtimes, derive context for prompts, or add metadata validation and access controls into model-serving workflows.

Features

• REST API to register, query, and resolve model context from OpenMetadata
• Lightweight adapter layer that maps OpenMetadata entities to MCP-compatible context objects
• Configurable connection to OpenMetadata (host, API key, TLS)
• Simple Docker and CLI-friendly deployment options
• Pluggable transformation hooks to compute derived context (e.g., sample rows, column stats)
• Logging and configurable verbosity for observability
• Suitable for embedding into ML serving stacks or as a standalone gateway for metadata-driven applications

Installation / Configuration

Prerequisites: Docker (recommended) or a machine with a supported runtime (e.g., Python/Node/Java depending on the build). You must have access credentials for an OpenMetadata instance.

1. Clone the repository:

git clone https://github.com/yangkyeongmo/mcp-server-openmetadata.git
cd mcp-server-openmetadata

2. Build and run with Docker:

# Build image (if project includes a Dockerfile)
docker build -t mcp-server-openmetadata .

# Run container with basic environment variables
docker run -d \
  -e OPENMETADATA_HOST=https://openmetadata.example.com \
  -e OPENMETADATA_API_KEY=your_api_key_here \
  -e MCP_PORT=8080 \
  --name mcp-server \
  -p 8080:8080 \
  mcp-server-openmetadata

3. Or use docker-compose (example):

version: "3.7"
services:
  mcp:
    image: mcp-server-openmetadata:latest
    environment:
      OPENMETADATA_HOST: "https://openmetadata.example.com"
      OPENMETADATA_API_KEY: "your_api_key_here"
      MCP_PORT: "8080"
      LOG_LEVEL: "info"
    ports:
      - "8080:8080"

4. Environment variables (customize as needed):

If the project contains a language-specific build (e.g., Node or Python), follow the repo’s build instructions (install dependencies, run tests, start the server). The Docker image and compose approach works without local runtime dependencies.

Available Resources

The MCP server exposes a concise HTTP API to interact with metadata. Common endpoints include (examples):

• GET /health — health check
• POST /v1/context — register or request model context for a resource
• GET /v1/metadata/{entityType}/{entityId} — fetch raw metadata for an entity
• POST /v1/resolve — resolve and return composed context objects for use by models

Example: register a context request via curl

curl -X POST "http://localhost:8080/v1/context" \
  -H "Content-Type: application/json" \
  -d '{
    "entityType": "table",
    "entityId": "sample_db.schema.users",
    "include": ["schema", "sampleRow", "lineage"]
  }'

Example Python client (requests):

import requests

resp = requests.post(
    "http://localhost:8080/v1/context",
    json={"entityType": "table", "entityId": "sample_db.schema.users", "include": ["schema","glossary"]},
)
print(resp.json())

Check the repository for full API schemas and response formats used to map OpenMetadata entities into MCP structures.

Use Cases

• Model prompt enrichment: Provide LLMs with authoritative column descriptions, sample rows, and data quality signals so prompts can be context-aware and less likely to hallucinate.
• Data discovery and exploration: Build UIs or bots that query the MCP server to retrieve unified metadata views (schema, owners, glossary) without embedding direct OpenMetadata access in each client.
• Lineage-aware impact analysis: Resolve upstream/downstream lineage for a dataset and surface it to analysts or automation tools to perform impact assessments prior to model re-training or schema changes.
• Governance and auditability: Centralize how models obtain metadata so access can be logged, validated, and governed centrally using your existing OpenMetadata policies.
• Service decoupling: Use the MCP server as a stable contract for model-serving platforms, allowing catalogue or schema representations to evolve behind the service without changing clients.

Next steps

• Review the repository README and API schema for concrete request/response definitions.
• Configure credentials and test the health endpoint after deployment.
• Integrate the MCP server into a staging model-serving flow to validate context resolution before production rollout.