Mcp Datahub

import (    "github.com/txn2/mcp-datahub/pkg/client"    "github.com/txn2/mcp-datahub/pkg/tools")
// Create client and register tools with your MCP serverdatahubClient, _ := client.NewFromEnv()defer datahubClient.Close()
toolkit := tools.NewToolkit(datahubClient, tools.Config{})toolkit.RegisterAll(yourMCPServer)

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

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

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 fileserverCfg, _ := extensions.LoadConfig("config.yaml")

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

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 toolstype 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 uptoolkit := datahubTools.NewToolkit(datahubClient, config,    datahubTools.WithQueryProvider(&myQueryProvider{trinoClient: trino}),)

import (    datahubTools "github.com/txn2/mcp-datahub/pkg/tools"    "github.com/txn2/mcp-datahub/pkg/integration")
// Access control - filter entities by user permissionstype 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 invocationstype myAuditLogger struct{}func (l *myAuditLogger) LogToolCall(ctx context.Context, tool string, params map[string]any, userID string) error { /* ... */ }
// Wire up with multiple integration optionstoolkit := 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)