OpenMetadata MCP Tools Reference

All OpenMetadata MCP tools, with parameters and examples.

Available Tools

Tools are labeled Read (retrieve data only) or Write (create or modify data).

Category	Tools
Discover	search_metadata, semantic_search, company_context
Inspect	get_entity_details
Context	get_user_context, get_persona_context, find_context
Lineage & Impact	get_entity_lineage, create_lineage, root_cause_analysis
Create & Modify	create_entity, describe_entity_type, patch_entity
Data Quality	get_test_definitions, create_test_case

Which Tool to Call First

If you already have a fully qualified name (from a prior result, a user-supplied FQN, or a UI deep link), start with get_entity_details. Add include: ["context", "lineage", "quality"] as needed. This resolves most questions about a known asset in a single call. If you don’t have a fully qualified name yet, start with search_metadata (exact names, owners, tags, tiers) or semantic_search (vague or conceptual queries), then pass the fullyQualifiedName from a result into get_entity_details. Starting broad with search_metadata when you already know the FQN adds unnecessary round trips (re-searching, re-confirming the match) that calling the lookup tool directly avoids.

Fully Qualified Name (FQN) Format

An entity’s FQN is a dot-separated path built from the entity and its ancestors. The number of segments depends on entity type:

Entity Type	FQN Pattern	Example
Table	`service.database.schema.table`	`snowflake_prod.analytics.public.customers`
Database Schema	`service.database.schema`	`snowflake_prod.analytics.public`
Database	`service.database`	`snowflake_prod.analytics`
Dashboard	`service.dashboardName`	`sample_superset.10`
Tag	`Classification.TagName`	`PII.Sensitive`
Glossary Term	`glossary.term`	`marketing-terms.customer-acquisition-cost`

Consult the entity’s API Reference page for entity types not listed here. Special Characters: If a name segment contains a period (.) or a double quote ("), wrap that segment in double quotes, escaping any internal " by doubling it. For example, a schema literally named sales.eu inside database prod becomes service.prod."sales.eu".table.

Discover

Search and find data assets across your catalog using keyword, semantic, or natural language queries.

search_metadata

Type: Read Description: Find data assets and business terms by keyword. Use when you know specific names, owners, tags, tiers, services, or column names. Use Cases:

Discover tables containing specific data
Find dashboards related to business areas
Search for glossary terms
Locate pipelines by name or description

Parameters

Parameter	Type	Required	Description
`query`	string	No	Keywords to search for
`entityType`	string	No	Filter by entity type (see list below)
`size`	integer	No	Max results to return (default: 10, max: 50)
`from`	integer	No	Offset for pagination (default: 0)
`cursor`	string	No	Pagination cursor — pass the `nextCursor` value from the previous response to get the next page. Takes precedence over `from` when both are provided.
`fields`	string	No	Comma-separated additional fields to include
`queryFilter`	string	No	Advanced: direct OpenSearch DSL JSON query. Example: `{"bool": {"must": [{"term": {"entityType": "table"}}, {"term": {"tags.tagFQN": "PII.Sensitive"}}]}}`
`includeDeleted`	boolean	No	Include deleted entities (default: false)
`includeAggregations`	boolean	No	Include aggregation/facet data (default: false)
`maxAggregationBuckets`	integer	No	Max buckets per aggregation (default: 10, max: 50)

Three rules are easy to get silently wrong with this tool:

queryFilter value: Omit it entirely rather than sending an empty string, "null", or "{}". A degenerate value is not treated as “no filter”: it currently produces a 400 JSON parsing failed error instead of falling through to a normal keyword search.
Batch-reading known entities: To hydrate several already-known entities in one call instead of one get_entity_details call per entity, use a terms clause on fullyQualifiedName in queryFilter together with fields.
Finding a table’s data-quality tests: Match on originEntityFQN, not entityFQN. A column-level test stores the column’s FQN in entityFQN, so filtering on the table’s FQN there silently returns only table-level tests, with a clean but wrong total.

fullyQualifiedName, entityFQN, and originEntityFQN are indexed with a lowercase normalizer. Values passed in a term/terms clause must be lowercased, or the clause silently matches zero rows.

Entity Types

Service Entities: databaseService, messagingService, apiService, dashboardService, pipelineService, storageService, mlmodelService, metadataService, searchService
Data Asset Entities: apiCollection, apiEndpoint, table, storedProcedure, database, databaseSchema, dashboard, dashboardDataModel, pipeline, chart, topic, searchIndex, mlmodel, container
User Entities: user, team
Domain Entities: domain, dataProduct
Governance Entities: metric, glossary, glossaryTerm
Data Quality Entities: testCase, testSuite, testCaseResult

Examples Basic Search:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "search_metadata",
    "arguments": {
      "query": "sales"
    }
  }
}

Search for a Specific Entity Type:

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "search_metadata",
    "arguments": {
      "query": "customer",
      "entityType": "table",
      "size": 15
    }
  }
}

Search with Additional Fields:

{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "tools/call",
  "params": {
    "name": "search_metadata",
    "arguments": {
      "query": "order",
      "entityType": "table",
      "fields": "columns,queries,upstreamLineage",
      "size": 5
    }
  }
}

Sample Response:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Found 5 results matching 'sales':\n\n**Tables:**\n1. **sales_transactions** (mysql_prod.ecommerce.public.sales_transactions)\n   - Description: Daily sales transaction records\n   - Service: mysql_prod (MySQL)\n   - Owners: sales-team, john.doe@company.com\n   - Tags: PII, Financial\n\n2. **sales_reports** (postgresql_analytics.reporting.main.sales_reports)\n   - Description: Aggregated sales reporting data\n   - Service: postgresql_analytics (PostgreSQL)\n\n**Dashboards:**\n3. **Sales Performance Dashboard** (looker_prod.sales.sales_performance)\n   - Description: Real-time sales KPI dashboard\n   - Charts: 8 charts"
      }
    ]
  }
}

Results include a similarityScore field for each entity whenever the search backend returns a relevance score for that hit. This is the backend’s raw, opaque score (not a value normalized to a 0.0–1.0 range), so absolute values vary by query and are not comparable across searches — only relative ordering within the same result set is meaningful. Higher scores indicate stronger relevance.

semantic_search

Type: Read Description: Find data assets by meaning using vector search (setup guide). Use for exploratory queries where you don’t know exact names. Returns conceptually related assets even when no keywords match. Use Cases:

Explore data when you don’t know exact table names
Find assets related to a concept (e.g., “customer spending behavior”)
Discover hidden relationships across services

Parameters

Parameter	Type	Required	Description
`query`	string	Yes	Natural language description of what you’re looking for
`filters`	object	No	Optional filters: `entityType`, `service`, `tags` (each an array of strings)
`size`	integer	No	Number of results to return (default: 10, max: 50)
`from`	integer	No	Offset for pagination (default: 0)
`cursor`	string	No	Pagination cursor — pass the `nextCursor` value from the previous response to get the next page. Takes precedence over `from` when both are provided.
`k`	integer	No	KNN neighbor count for tuning result quality (default: 100)
`threshold`	number	No	Minimum similarity score 0.0–1.0 (default: 0.0)

Examples Conceptual Search:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "semantic_search",
    "arguments": {
      "query": "tables tracking customer purchase history and lifetime value"
    }
  }
}

Search with Filters and Threshold:

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "semantic_search",
    "arguments": {
      "query": "revenue forecasting and financial reporting",
      "filters": {
        "entityType": ["table", "dashboard"],
        "service": ["BigQuery"]
      },
      "threshold": 0.5,
      "size": 5
    }
  }
}

company_context

Type: Read Description: Read Company Context knowledge pills, the question/answer notes extracted from files in the Context Center. Pass query to find pills that answer a question, or fqn to read one you already have the name of; exactly one of the two. Each result carries the pill’s title, question, answer, summary, and source file, so a search result is usually enough on its own and needs no follow-up read. query needs vector embeddings configured on the server; fqn does not.

This tool replaces the earlier separate search_company_context and get_company_context tools, which no longer exist as of this release.

Parameters

Parameter	Type	Required	Description
`query`	string	No	Natural-language question to match pills against. Mutually exclusive with `fqn`.
`fqn`	string	No	Fully qualified name of a single pill, exactly as a previous result returned it. Mutually exclusive with `query`.
`size`	integer	No	Number of pills to return for a `query`. Default is 10, maximum is 50
`from`	integer	No	Offset for pagination (default: 0)
`cursor`	string	No	Pagination cursor — pass the `nextCursor` value from the previous response to get the next page. Takes precedence over `from` when both are provided.

Example

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "company_context",
    "arguments": {
      "query": "data retention policy",
      "size": 5
    }
  }
}

Inspect

Retrieve detailed information about a specific entity, with optional business context, lineage, and data-quality sections folded in.

get_entity_details

Type: Read Description: Retrieve full details for a specific entity by fully qualified name (FQN), with optional extra sections folded into the same call. If you already have the exact FQN (from a prior search result, or built from known segments using the documented FQN format), pass it directly. If you’re not certain of the exact segment values (service, database, schema, or table names as stored in OpenMetadata may differ from source-system names), use search_metadata or semantic_search first and pass through the fullyQualifiedName from the result to avoid a failed lookup. The response includes an extension field containing any custom properties defined for the entity type. Pass entities instead of entityType/fqn to read up to 10 entities in one call.

get_asset_context and get_knowledge_content are no longer separate tools as of this release. Use include: ["context"] in place of get_asset_context, and include: ["content"] in place of get_knowledge_content.

Parameters

Parameter	Type	Required	Description
`entityType`	string	Yes*	Type of entity (e.g., `table`, `dashboard`, `topic`, `pipeline`). Required unless `entities` is used.
`fqn`	string	Yes*	Fully qualified name, using the exact value from `search_metadata` or `semantic_search` results. Required unless `entities` is used.
`entities`	array of string	No	Read several entities in one call instead of `entityType`/`fqn`. Each item is `entityType:fqn`, for example `table:sample_data.ecommerce_db.shopify.dim_address`. Maximum 10 per call.
`columnOffset`	integer	No	Zero-based index of the first column to return, for paging through a wide table’s columns. Defaults to 0.
`columnLimit`	integer	No	Maximum number of columns to return starting at `columnOffset`.
`include`	array of string	No	Extra sections to fold into this call instead of a separate one: `context` (business knowledge: approved glossary term definitions and Context Center articles, plus type-specific structural context such as primary/foreign keys, frequent joins, and partitions for tables), `lineage` (immediate upstream/downstream FQNs only; use `get_entity_lineage` for depth or transformation SQL), `quality` (test-suite pass/fail summary, including a `neverRun` count), `content` (full body of a knowledge item, or matching passages when `query` is set). `context` already includes a lineage summary, so combining it with `lineage` returns the same neighbors twice.
`query`	string	No	Focuses the `context` and `content` sections on one question. Ignored by the other sections.
`format`	string	No	Rendering for the `context` and `content` sections: `markdown` (default) or `json`.
`passages`	integer	No	How many passages the `content` section returns when `query` is set (1-10, default 3).

Examples Get Table Details:

{
  "jsonrpc": "2.0",
  "id": 4,
  "method": "tools/call",
  "params": {
    "name": "get_entity_details",
    "arguments": {
      "entityType": "table",
      "fqn": "mysql_prod.ecommerce.public.customer_orders"
    }
  }
}

Get Dashboard Details:

{
  "jsonrpc": "2.0",
  "id": 5,
  "method": "tools/call",
  "params": {
    "name": "get_entity_details",
    "arguments": {
      "entityType": "dashboard",
      "fqn": "superset_prod.sales.quarterly_revenue"
    }
  }
}

Get Table Details with Business Context, Lineage, and Data Quality:

{
  "jsonrpc": "2.0",
  "id": 6,
  "method": "tools/call",
  "params": {
    "name": "get_entity_details",
    "arguments": {
      "entityType": "table",
      "fqn": "mysql_prod.ecommerce.public.customer_orders",
      "include": ["context", "lineage", "quality"]
    }
  }
}

Sample Response:

{
  "jsonrpc": "2.0",
  "id": 4,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "## Table: customer_orders\n\n**FQN**: mysql_prod.ecommerce.public.customer_orders\n**Service**: mysql_prod (MySQL)\n**Database**: ecommerce | **Schema**: public\n**Description**: Stores all customer order transactions\n\n**Owners**: ecommerce-team, sarah.johnson@company.com\n**Tags**: PII, Financial, Customer-Data | **Tier**: Tier1\n\n**Columns** (5):\n- order_id (BIGINT) - Primary key\n- customer_id (BIGINT) - FK to customer table\n- order_date (TIMESTAMP)\n- total_amount (DECIMAL)\n- status (VARCHAR)"
      }
    ]
  }
}

Context

Retrieve context knowledge associated with the current user, a persona, or a business question. Context tools are all Read operations. For an asset’s own business and structural context, use get_entity_details with include: ["context"] instead.

get_user_context

Type: Read Description: Returns context about the currently authenticated user — identity (ID, name, display name, email, admin/bot flags), team memberships, roles (direct and team-inherited), domains, active persona, and lightweight summaries of entities the user owns and follows. Use this to answer identity questions such as “what is my role?” or “what do I own?” before asking the user for details. The user is resolved from the authenticated request — there is no parameter to look up another user. Parameters

Parameter	Type	Required	Description
`includeOwnedSummary`	boolean	No	Include a summary of entities owned by the user and their teams (default: `true`)
`includeFollowedSummary`	boolean	No	Include a summary of entities the user follows (default: `true`)
`ownedLimit`	integer	No	Max owned entities to return, 1–100 (default: 20)
`followedLimit`	integer	No	Max followed entities to return, 1–100 (default: 20)
`ownedFilter`	string	No	Narrow owned entities to ones worth surfacing: `NONE` (default, all owned), `MISSING_DESCRIPTION`, `MISSING_TIER`, or `ANY_GAP`. Gap filters apply to data-asset entity types only

Example

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "get_user_context",
    "arguments": {
      "ownedFilter": "ANY_GAP"
    }
  }
}

Sample Response

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "## Current User\n\n**Name**: Jane Doe\n**Email**: jane.doe@company.com\n**Persona**: Data Analyst\n**Teams**: analytics-team, data-platform\n**Roles**: DataSteward"
      }
    ]
  }
}

get_persona_context

Type: Read Description: Returns the shared AI context document curated for a persona — preferences, use cases, and runbook entries scoped to that persona’s role. With no personaName, returns context for the caller’s active persona. The document can span multiple parts. Call again with an incremented part while the response’s hasMore is true. Access is limited to persona members, admins, and bots. Parameters

Parameter	Type	Required	Description
`personaName`	string	No	Fully qualified name of the persona. Omit to use the caller’s active persona
`format`	string	No	`markdown` (default) or `json`
`part`	integer	No	One-based document part to fetch. Start at 1 and continue while `hasMore` is `true` (default: 1)

Example

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "get_persona_context",
    "arguments": {
      "personaName": "Data Analyst"
    }
  }
}

find_context

Type: Read Description: For a business question where no specific asset has been chosen yet, semantically searches the company-knowledge layer — glossary term definitions, metric definitions, and Context Center articles — and returns the matching definitions plus the candidate data assets each concept points to (glossary terms → the tables tagged with them, metrics → the assets they apply to, and articles → the assets they’re about). Use this to bootstrap a data question from business concepts into candidate tables, then call get_entity_details with include: ["context"] on those FQNs. This is a semantic search over company knowledge, not a keyword search over asset or persona memories. Parameters

Parameter	Type	Required	Description
`query`	string	Yes	Natural-language question or business terms to find relevant company knowledge and candidate assets for
`size`	integer	No	Number of knowledge items to return (default: 10, max: 50)
`format`	string	No	`markdown` (default) returns definitions and candidate assets as an LLM-friendly document. `json` returns the structured result

Example

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "find_context",
    "arguments": {
      "query": "PII handling policy",
      "size": 5
    }
  }
}

Lineage & Impact

Explore data dependencies, trace upstream sources, and analyze downstream impact.

get_entity_lineage

Type: Read Description: Retrieve upstream and downstream lineage for any entity to understand data dependencies and perform impact analysis. Pass the exact fullyQualifiedName from search results. Parameters

Parameter	Type	Required	Description
`entityType`	string	Yes	Type of entity
`fqn`	string	Yes	Fully qualified name of the entity
`upstreamDepth`	integer	No	Hops to traverse upstream (default: 3, max: 10)
`downstreamDepth`	integer	No	Hops to traverse downstream (default: 3, max: 10)
`includeColumnLineage`	boolean	No	Include column-level lineage mappings. Default is `false` (table-level only)

Examples Get Full Lineage:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "get_entity_lineage",
    "arguments": {
      "entityType": "table",
      "fqn": "mysql_prod.ecommerce.public.sales_transactions",
      "upstreamDepth": 3,
      "downstreamDepth": 3
    }
  }
}

Downstream-Focused Impact Analysis:

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "get_entity_lineage",
    "arguments": {
      "entityType": "table",
      "fqn": "mysql_prod.ecommerce.public.sales_transactions",
      "upstreamDepth": 1,
      "downstreamDepth": 5
    }
  }
}

create_lineage

Type: Write Description: Create a lineage relationship between two entities. Identify each entity by fqn (the fully qualified name a search result already returns) or by id (UUID) and type. fqn is preferred, since it skips the extra lookup an id would need. Parameters

Parameter	Type	Required	Description
`fromEntity`	object	Yes	Source entity with `type` (string) and either `fqn` (fully qualified name, preferred) or `id` (UUID string)
`toEntity`	object	Yes	Destination entity with `type` (string) and either `fqn` or `id` (UUID string)

Example

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "create_lineage",
    "arguments": {
      "fromEntity": {
        "type": "table",
        "fqn": "mysql_prod.ecommerce.public.raw_orders"
      },
      "toEntity": {
        "type": "table",
        "fqn": "mysql_prod.ecommerce.public.dim_orders"
      }
    }
  }
}

Tip: search_metadata and get_entity_details results already carry each entity’s fqn — pass it straight through to create_lineage instead of resolving an id first.

root_cause_analysis

Type: Read Description: Trace a data quality failure back to its origin by traversing data quality lineage across pipeline hops. Parameters

Parameter	Type	Required	Description
`fqn`	string	Yes	FQN of the entity where failure was detected
`entityType`	string	Yes	Entity type to analyze (for example, `table`)
`upstreamDepth`	integer	No	Hops to traverse upstream (default: 3, max: 10)
`downstreamDepth`	integer	No	Hops to traverse downstream (default: 3, max: 10)
`queryFilter`	string	No	Optional OpenSearch DSL filter JSON
`includeDeleted`	boolean	No	Include deleted entities in traversal (default: false)

Example

{
  "jsonrpc": "2.0",
  "id": 12,
  "method": "tools/call",
  "params": {
    "name": "root_cause_analysis",
    "arguments": {
      "fqn": "mysql_prod.ecommerce.public.customer_orders",
      "entityType": "table",
      "upstreamDepth": 4,
      "downstreamDepth": 1,
      "includeDeleted": false
    }
  }
}

Create & Modify

Create new entities of any registered type, discover what an entity type requires before creating it, and update existing entities.

create_glossary, create_glossary_term, create_context_memory, create_classification, create_tag, create_domain, create_data_product, and create_metric are no longer separate tools as of this release. Use create_entity with the corresponding entityType for all of them.

create_entity

Type: Write Description: Create a new entity through the repository registered for its entity type. This tool never modifies an existing entity; a name that is already taken fails. Use patch_entity for every edit. Fields every type shares are top-level parameters; fields specific to the entity go in attributes. Call describe_entity_type first when the requirements aren’t already known. Reference-valued attributes take an object naming the target, such as {"type": "glossary", "fullyQualifiedName": "Finance"}; an id may be given instead of the name. Unknown entity types and attributes are rejected before anything is written. Entity types whose resource endpoint performs required authentication, scheduling, specialized authorization, or secret-handling work are rejected with the dedicated API to use instead (users, bots, apps, event subscriptions, ingestion pipelines, test cases, services, and automation workflows). To create a test case use create_test_case; for lineage use create_lineage. A Context Center article is entityType: "page" with attributes: {"pageType": "Article", "page": {}}, its markdown body in description, the assets it documents in attributes.relatedEntities, and an optional attributes.parent page to nest it under. Writes take effect immediately, so confirm the target with the user before calling. Parameters

Parameter	Type	Required	Description
`entityType`	string	Yes	Registered entity type to create, for example `glossary`, `glossaryTerm`, `classification`, `tag`, `domain`, `dataProduct`, `metric`, or `page` for a Context Center article.
`name`	string	Yes	Entity name, unique within its parent scope.
`description`	string	No	Description of the entity in Markdown.
`displayName`	string	No	Human-readable display name.
`owners`	array of string	No	User or team names to own the entity, for example `["john.doe", "Data Platform"]`. A name that resolves to neither fails the call.
`tags`	array of string	No	Tag FQNs to apply, for example `["PII.Sensitive", "Tier.Tier1"]`.
`domains`	array of string	No	Domain FQNs the entity belongs to.
`reviewers`	array of string	No	User or team names to review the entity.
`extension`	object	No	Custom properties as `{propertyName: value}`.
`attributes`	object	No	Fields specific to this `entityType`. Values match the schema returned by `describe_entity_type`. Reference fields use objects such as `{"type": "glossary", "fullyQualifiedName": "Finance"}` or `{"type": "glossary", "id": "<uuid>"}`; arrays of references use arrays of those objects.

Examples Create a Glossary (replaces the former create_glossary tool):

{
  "jsonrpc": "2.0",
  "id": 6,
  "method": "tools/call",
  "params": {
    "name": "create_entity",
    "arguments": {
      "entityType": "glossary",
      "name": "Marketing Terms",
      "description": "Marketing-related terms used across campaigns, analytics, and reporting",
      "owners": ["marketing-team", "alice.smith@company.com"],
      "reviewers": ["data-governance-team"],
      "attributes": {
        "mutuallyExclusive": false
      }
    }
  }
}

Create a Domain (replaces the former create_domain tool):

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "create_entity",
    "arguments": {
      "entityType": "domain",
      "name": "Finance",
      "description": "Domain for all finance and accounting data assets.",
      "owners": ["finance-team"],
      "attributes": {
        "domainType": "Consumer-aligned",
        "experts": ["jane.doe"]
      }
    }
  }
}

Create a Context Center Article (replaces the former create_context_memory tool):

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "create_entity",
    "arguments": {
      "entityType": "page",
      "name": "finance-warehouse-preference",
      "description": "Always query the FINANCE_PROD warehouse for finance dashboards.",
      "domains": ["Finance"],
      "attributes": {
        "pageType": "Article",
        "page": {}
      }
    }
  }
}

describe_entity_type

Type: Read Description: Return the attributes that create_entity accepts for one entity type: each field’s name, type, whether it’s required, and its allowed values. Call this before create_entity when the type’s requirements aren’t already known, rather than guessing attribute names. Parameters

Parameter	Type	Required	Description
`entityType`	string	Yes	Registered entity type whose create attributes to return.

Example

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "describe_entity_type",
    "arguments": {
      "entityType": "dataProduct"
    }
  }
}

patch_entity

Type: Write Description: Update an existing entity’s properties using JSON Patch (RFC 6902). Use get_entity_details first to retrieve the current state before constructing a patch. Parameters

Parameter	Type	Required	Description
`entityType`	string	Yes	Type of entity to patch (e.g., `table`, `glossaryTerm`)
`fqn`	string	Yes	Fully qualified name of the entity to patch
`patch`	string	Yes	JSON Patch operations array as a JSON string. Each operation has `op` (`add`/`remove`/`replace`), `path`, and `value`

Example

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "patch_entity",
    "arguments": {
      "entityType": "table",
      "fqn": "mysql_prod.ecommerce.public.customer_orders",
      "patch": "[{\"op\":\"replace\",\"path\":\"/description\",\"value\":\"Updated description for customer orders table.\"}]"
    }
  }
}

Data Quality

Access test definitions and create test cases to validate your data assets.

get_test_definitions

Type: Read Description: List test definitions available in OpenMetadata for tables or columns. Call this before create_test_case to identify valid test types and their required parameters. Parameters

Parameter	Type	Required	Description
`entityType`	string	Yes	`TABLE` for table-level tests or `COLUMN` for column-level tests
`limit`	integer	No	Max results to return (default: 10)
`cursor`	string	No	Pagination cursor — pass the `nextCursor` value from the previous response to get the next page. Preferred over `after`.
`after`	string	No	Legacy pagination token, equivalent to `cursor`. Prefer `cursor` for new integrations.
`testPlatform`	string	No	Filter by platform: `OpenMetadata`, `GreatExpectations`, `DBT`, `Deequ`, `Soda`, `Other` (default: `OpenMetadata`)

Example

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "get_test_definitions",
    "arguments": {
      "entityType": "COLUMN",
      "limit": 20
    }
  }
}

create_test_case

Type: Write Description: Create a data quality test case for a table or column. For column tests, ensure the column’s data type is listed in the test definition’s supportedDataTypes. Parameters

Parameter	Type	Required	Description
`name`	string	Yes	Name of the test case
`fqn`	string	Yes	FQN of the target entity (typically the table FQN)
`testDefinitionName`	string	Yes	Name of the test definition returned by `get_test_definitions`
`parameterValues`	array	Yes	List of test parameter objects (`name` + `value`) required by the test definition
`columnName`	string	No	Column name for column-level test cases
`entityType`	string	No	Target OpenMetadata entity type (default: `table`). For column-level tests, keep `entityType` as `table` and set `columnName`.
`description`	string	No	Optional description of the test case

Example

{
  "jsonrpc": "2.0",
  "id": 11,
  "method": "tools/call",
  "params": {
    "name": "create_test_case",
    "arguments": {
      "name": "customer_id_not_null",
      "fqn": "mysql_prod.ecommerce.public.customer_orders",
      "columnName": "customer_id",
      "entityType": "table",
      "testDefinitionName": "columnValuesToBeNotNull",
      "description": "Ensures customer_id is always populated for downstream joins",
      "parameterValues": []
    }
  }
}

​OpenMetadata MCP Tools Reference

​Available Tools

​Which Tool to Call First

​Fully Qualified Name (FQN) Format

​Discover

​search_metadata

​semantic_search

​company_context

​Inspect

​get_entity_details

​Context

​get_user_context

​get_persona_context

​find_context

​Lineage & Impact

​get_entity_lineage

​create_lineage

​root_cause_analysis

​Create & Modify

​create_entity

​describe_entity_type

​patch_entity

​Data Quality

​get_test_definitions

​create_test_case

OpenMetadata MCP Tools Reference

Available Tools

Which Tool to Call First

Fully Qualified Name (FQN) Format

Discover

search_metadata

semantic_search

company_context

Inspect

get_entity_details

Context

get_user_context

get_persona_context

find_context

Lineage & Impact

get_entity_lineage

create_lineage

root_cause_analysis

Create & Modify

create_entity

describe_entity_type

patch_entity

Data Quality

get_test_definitions

create_test_case