MCP Datahub

An MCP server and composable Go library that connects AI assistants to DataHub metadata catalogs. Search datasets, explore schemas, trace lineage, and access glossary terms and domains.

[mcp-datahub.txn2.com](https://mcp-datahub.txn2.com) | [Installation](https://mcp-datahub.txn2.com/server/installation/) | [Library Docs](https://mcp-datahub.txn2.com/library/)

MCP Data Platform Ecosystem

mcp-datahub is part of a broader suite of open-source MCP servers designed to work together as a composable data platform. Each component can run standalone or be combined to give AI assistants unified access to storage, query engines, and metadata catalogs.

• txn2/mcp-data-platform
• txn2/mcp-s3
• txn2/mcp-trino

Two Ways to Use

1. Standalone MCP Server

Install and connect to Claude Desktop, Cursor, or any MCP client:

Claude Desktop (Easiest) - Download the .mcpb bundle from releases and double-click to install:

• macOS Apple Silicon: mcp-datahub_X.X.X_darwin_arm64.mcpb
• macOS Intel: mcp-datahub_X.X.X_darwin_amd64.mcpb
• Windows: mcp-datahub_X.X.X_windows_amd64.mcpb

Other Installation Methods:

# Homebrew (macOS)

brew install txn2/tap/mcp-datahub

Go install

go install github.com/txn2/mcp-datahub/cmd/mcp-datahub@latest

Manual Claude Desktop Configuration (if not using MCPB):

{

"mcpServers": { "datahub": { "command": "/opt/homebrew/bin/mcp-datahub", "env": { "DATAHUB_URL": "https://datahub.example.com", "DATAHUB_TOKEN": "your_token" } } } }

Multi-Server Configuration

Connect to multiple DataHub instances simultaneously:

# Primary server

export DATAHUB_URL=https://prod.datahub.example.com/api/graphql export DATAHUB_TOKEN=prod-token export DATAHUB_CONNECTION_NAME=prod

Additional servers (JSON)

export DATAHUB_ADDITIONAL_SERVERS='{"staging":{"url":"https://staging.datahub.example.com/api/graphql","token":"staging-token"}}'

Use datahub_list_connections to discover available connections, then pass the connection parameter to any tool.

2. Composable Go Library

Import into your own MCP server for custom authentication, tenant isolation, and audit logging:

import (

"github.com/txn2/mcp-datahub/pkg/client" "github.com/txn2/mcp-datahub/pkg/tools" )

// Create client and register tools with your MCP server datahubClient, _ := client.NewFromEnv() defer datahubClient.Close()

toolkit := tools.NewToolkit(datahubClient, tools.Config{}) toolkit.RegisterAll(yourMCPServer)

Customizing Tool Descriptions

Override tool descriptions to match your deployment:

toolkit := tools.NewToolkit(datahubClient, tools.Config{},

tools.WithDescriptions(map[tools.ToolName]string{ tools.ToolSearch: "Search our internal data catalog for datasets and dashboards", }), )

Customizing Tool Annotations

Override MCP tool annotations (behavior hints for AI clients):

toolkit := tools.NewToolkit(datahubClient, tools.Config{},

tools.WithAnnotations(map[tools.ToolName]*mcp.ToolAnnotations{ tools.ToolSearch: {ReadOnlyHint: true, OpenWorldHint: boolPtr(true)}, }), )

All 12 tools ship with default annotations: read tools are marked ReadOnlyHint: true; datahub_create is non-destructive and non-idempotent; datahub_update is non-destructive and idempotent; datahub_delete is destructive and idempotent.

Extensions (Logging, Metrics, Error Hints)

Enable optional middleware via the extensions package:

import "github.com/txn2/mcp-datahub/pkg/extensions"

// Load from environment variables (MCP_DATAHUB_EXT_*) cfg := extensions.FromEnv() opts := extensions.BuildToolkitOptions(cfg) toolkit := tools.NewToolkit(datahubClient, toolsCfg, opts...)

// Or load from a YAML/JSON config file serverCfg, _ := extensions.LoadConfig("config.yaml")

See the library documentation for middleware, selective tool registration, and enterprise patterns.

Combining with mcp-trino

Build a unified data platform MCP server by combining DataHub metadata with Trino query execution:

import (

datahubClient "github.com/txn2/mcp-datahub/pkg/client" datahubTools "github.com/txn2/mcp-datahub/pkg/tools" trinoClient "github.com/txn2/mcp-trino/pkg/client" trinoTools "github.com/txn2/mcp-trino/pkg/tools" )

// Add DataHub tools (search, lineage, schema, glossary) dh, _ := datahubClient.NewFromEnv() datahubTools.NewToolkit(dh, datahubTools.Config{}).RegisterAll(server)

// Add Trino tools (query execution, catalog browsing) tr, _ := trinoClient.NewFromEnv() trinoTools.NewToolkit(tr, trinoTools.Config{}).RegisterAll(server)

// AI assistants can now: // - Search DataHub for tables -> Get schema -> Query via Trino // - Explore lineage -> Understand data flow -> Run validation queries

See txn2/mcp-trino for the companion library.

Bidirectional Integration with QueryProvider

The library supports bidirectional context injection. While mcp-trino can pull semantic context from DataHub, mcp-datahub can receive query execution context back from a query engine:

import (

datahubTools "github.com/txn2/mcp-datahub/pkg/tools" "github.com/txn2/mcp-datahub/pkg/integration" )

// QueryProvider enables query engines to inject context into DataHub tools type myQueryProvider struct { trinoClient *trino.Client }

func (p *myQueryProvider) Name() string { return "trino" }

func (p *myQueryProvider) ResolveTable(ctx context.Context, urn string) (*integration.TableIdentifier, error) { // Map DataHub URN to Trino table (catalog.schema.table) return &integration.TableIdentifier{ Catalog: "hive", Schema: "production", Table: "users", }, nil }

func (p *myQueryProvider) GetTableAvailability(ctx context.Context, urn string) (*integration.TableAvailability, error) { // Check if table is queryable return &integration.TableAvailability{Available: true}, nil }

func (p *myQueryProvider) GetQueryExamples(ctx context.Context, urn string) ([]integration.QueryExample, error) { // Return sample queries for this entity return []integration.QueryExample{ {Name: "sample", SQL: "SELECT * FROM hive.production.users LIMIT 10"}, }, nil }

// Wire it up toolkit := datahubTools.NewToolkit(datahubClient, config, datahubTools.WithQueryProvider(&myQueryProvider{trinoClient: trino}), )

When a QueryProvider is configured, tool responses are enriched:

• Search results: Include query_context with table availability
• Entity details: Include query_table, query_examples, query_availability
• Schema: Include query_table for immediate SQL usage
• Lineage: Include execution_context mapping URNs to tables

Integration Middleware

Enterprise features like access control and audit logging are enabled through middleware adapters:

import (

datahubTools "github.com/txn2/mcp-datahub/pkg/tools" "github.com/txn2/mcp-datahub/pkg/integration" )

// Access control - filter entities by user permissions type myAccessFilter struct{} func (f *myAccessFilter) CanAccess(ctx context.Context, urn string) (bool, error) { /* ... */ } func (f *myAccessFilter) FilterURNs(ctx context.Context, urns []string) ([]string, error) { /* ... */ }

// Audit logging - track all tool invocations type myAuditLogger struct{} func (l *myAuditLogger) LogToolCall(ctx context.Context, tool string, params map[string]any, userID string) error { /* ... */ }

// Wire up with multiple integration options toolkit := datahubTools.NewToolkit(datahubClient, config, datahubTools.WithAccessFilter(&myAccessFilter{}), datahubTools.WithAuditLogger(&myAuditLogger{}, func(ctx context.Context) string { return ctx.Value("user_id").(string) }), datahubTools.WithURNResolver(&myURNResolver{}), // Map external IDs to URNs datahubTools.WithMetadataEnricher(&myEnricher{}), // Add custom metadata )

See the library documentation for complete integration patterns.

Available Tools

Read Tools (always available)

Write Tools (require DATAHUB_WRITE_ENABLED=true)

3 CRUD tools using the what discriminator pattern — 37 operations total:

Write tools are disabled by default for safety.

DataHub Version Compatibility

Minimum: DataHub 1.3.x. Full feature set: DataHub 1.4.x.

The client gracefully handles version differences — read queries return empty results (not errors) when a feature is unavailable on older versions.

See the tools reference for detailed documentation.

Configuration

| DATAHUB_CONNECTION_NAME | Display name for primary connection | `dat