> ## Documentation Index
> Fetch the complete documentation index at: https://docs.open-metadata.org/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP Tools Reference

# OpenMetadata MCP Tools Reference

All OpenMetadata MCP tools, with parameters and examples.

## Available Tools

| Category              | Tools                                                                                                                                                                                         |
| --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Discover**          | [search\_metadata](#search_metadata), [semantic\_search](#semantic_search), [search\_company\_context](#search_company_context)                                                               |
| **Inspect**           | [get\_entity\_details](#get_entity_details), [get\_company\_context](#get_company_context)                                                                                                    |
| **Lineage & Impact**  | [get\_entity\_lineage](#get_entity_lineage), [create\_lineage](#create_lineage), [root\_cause\_analysis](#root_cause_analysis)                                                                |
| **Knowledge**         | [create\_glossary](#create_glossary), [create\_glossary\_term](#create_glossary_term), [create\_context\_memory](#create_context_memory)                                                      |
| **Govern & Classify** | [create\_classification](#create_classification), [create\_tag](#create_tag), [create\_domain](#create_domain), [create\_data\_product](#create_data_product), [patch\_entity](#patch_entity) |
| **Data Quality**      | [get\_test\_definitions](#get_test_definitions), [create\_test\_case](#create_test_case)                                                                                                      |
| **Metrics**           | [create\_metric](#create_metric)                                                                                                                                                              |

## Discover

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

### search\_metadata

**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)                 |
| `fields`                | string  | No       | Comma-separated additional fields to include       |
| `queryFilter`           | string  | No       | Advanced: direct OpenSearch DSL JSON query         |
| `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) |

**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`

**Examples**

**Basic Search**:

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "search_metadata",
    "arguments": {
      "query": "sales"
    }
  }
}
```

**Search for a Specific Entity Type**:

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

**Search with Additional Fields**:

```json theme={null}
{
  "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**:

```json theme={null}
{
  "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"
      }
    ]
  }
}
```

### semantic\_search

**Description**: Find data assets by meaning using vector search ([setup guide](../../deployment/semantic-search#enable-semantic-search)). 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)                           |
| `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**:

```json theme={null}
{
  "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**:

```json theme={null}
{
  "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
    }
  }
}
```

### search\_company\_context

**Description**: Semantic search over company context knowledge pills from the Context Center. Returns matching pills with their title, question, answer, summary, and source file. Use this to answer questions from company documents, runbooks, FAQs, and policies.

**Parameters**

| Parameter | Type    | Required | Description                                                               |
| --------- | ------- | -------- | ------------------------------------------------------------------------- |
| `query`   | string  | Yes      | Natural-language question or topic to find relevant company knowledge for |
| `size`    | integer | No       | Number of pills to return. Default is 10, maximum is 50                   |

**Example**

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "search_company_context",
    "arguments": {
      "query": "data retention policy",
      "size": 5
    }
  }
}
```

## Inspect

Retrieve detailed information about specific entities and company knowledge pills.

### get\_entity\_details

**Description**: Retrieve full details for a specific entity by fully qualified name (FQN). Pass the exact `fullyQualifiedName` value from search results — do not construct FQNs manually.

**Parameters**

| Parameter    | Type   | Required | Description                                                                                    |
| ------------ | ------ | -------- | ---------------------------------------------------------------------------------------------- |
| `entityType` | string | Yes      | Type of entity (e.g., `table`, `dashboard`, `topic`, `pipeline`)                               |
| `fqn`        | string | Yes      | Fully qualified name — use the exact value from `search_metadata` or `semantic_search` results |

**Examples**

**Get Table Details**:

```json theme={null}
{
  "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**:

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

**Sample Response**:

```json theme={null}
{
  "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)"
      }
    ]
  }
}
```

### get\_company\_context

**Description**: Fetch a single company context knowledge pill by its fully qualified name. Returns the full title, question, answer, summary, and source file. Use the `fullyQualifiedName` or `name` returned by `search_company_context`.

**Parameters**

| Parameter | Type   | Required | Description                                                                                                       |
| --------- | ------ | -------- | ----------------------------------------------------------------------------------------------------------------- |
| `fqn`     | string | Yes      | The `fullyQualifiedName` or `name` of the knowledge pill from a `search_company_context` result. Pass it verbatim |

**Example**

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "get_company_context",
    "arguments": {
      "fqn": "data-retention-policy.gdpr-rules"
    }
  }
}
```

## Lineage & Impact

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

### get\_entity\_lineage

**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**:

```json theme={null}
{
  "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**:

```json theme={null}
{
  "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

**Description**: Create a lineage relationship between two entities. Requires the `id` (UUID) and `type` of both the source and destination entities.

**Parameters**

| Parameter    | Type   | Required | Description                                                    |
| ------------ | ------ | -------- | -------------------------------------------------------------- |
| `fromEntity` | object | Yes      | Source entity with `type` (string) and `id` (UUID string)      |
| `toEntity`   | object | Yes      | Destination entity with `type` (string) and `id` (UUID string) |

**Example**

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "create_lineage",
    "arguments": {
      "fromEntity": {
        "type": "table",
        "id": "3a1b2c3d-4e5f-6789-abcd-ef0123456789"
      },
      "toEntity": {
        "type": "table",
        "id": "9f8e7d6c-5b4a-3210-fedc-ba9876543210"
      }
    }
  }
}
```

> **Tip**: Retrieve entity UUIDs from `get_entity_details` results before calling `create_lineage`.

### root\_cause\_analysis

**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**

```json theme={null}
{
  "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
    }
  }
}
```

## Knowledge

Create and manage glossaries, terms, and reusable context memories.

### create\_glossary

**Description**: Create a new glossary to organize business terms. Set `mutuallyExclusive: true` to restrict entities to a single term from the glossary at a time.

**Parameters**

| Parameter           | Type    | Required | Description                                                             |
| ------------------- | ------- | -------- | ----------------------------------------------------------------------- |
| `name`              | string  | Yes      | Name of the glossary                                                    |
| `description`       | string  | Yes      | Description of the glossary's purpose                                   |
| `mutuallyExclusive` | boolean | Yes      | If `true`, only one term from this glossary can tag an entity at a time |
| `owners`            | array   | No       | List of owner usernames or emails                                       |
| `reviewers`         | array   | No       | List of reviewer usernames or emails                                    |

**Examples**

**Create a Business Glossary**:

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

**Create a Mutually Exclusive Technical Glossary**:

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 7,
  "method": "tools/call",
  "params": {
    "name": "create_glossary",
    "arguments": {
      "name": "Data Quality Metrics",
      "description": "Standardized definitions for data quality measurements and KPIs",
      "owners": ["data-quality-team"],
      "mutuallyExclusive": true
    }
  }
}
```

**Sample Response**:

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 6,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "✅ Successfully created glossary: **Marketing Terms**\n\n- Owners: marketing-team, alice.smith@company.com\n- Reviewers: data-governance-team\n- Mutually Exclusive: No\n- Status: Active"
      }
    ]
  }
}
```

### create\_glossary\_term

**Description**: Create a new term within an existing glossary. Supports hierarchical parent–child relationships between terms.

**Parameters**

| Parameter     | Type   | Required | Description                                            |
| ------------- | ------ | -------- | ------------------------------------------------------ |
| `glossary`    | string | Yes      | FQN of the parent glossary                             |
| `name`        | string | Yes      | Name of the term                                       |
| `description` | string | Yes      | Definition of the term                                 |
| `parentTerm`  | string | No       | FQN of the parent term (for nested/hierarchical terms) |
| `owners`      | array  | No       | List of owner usernames or emails                      |
| `reviewers`   | array  | No       | List of reviewer usernames or emails                   |

**Examples**

**Create a Root-Level Term**:

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 8,
  "method": "tools/call",
  "params": {
    "name": "create_glossary_term",
    "arguments": {
      "glossary": "marketing-terms",
      "name": "Customer Acquisition Cost",
      "description": "The total cost of acquiring a new customer, including marketing and sales expenses divided by the number of customers acquired in a specific period",
      "owners": ["marketing-team", "finance-team"]
    }
  }
}
```

**Create a Child Term**:

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 9,
  "method": "tools/call",
  "params": {
    "name": "create_glossary_term",
    "arguments": {
      "glossary": "marketing-terms",
      "parentTerm": "marketing-terms.customer-acquisition-cost",
      "name": "Organic CAC",
      "description": "Customer acquisition cost for customers acquired through organic channels (SEO, word of mouth) without paid advertising",
      "owners": ["marketing-team"]
    }
  }
}
```

### create\_context\_memory

**Description**: Save a reusable piece of knowledge to the Context Center — a preference, instruction, runbook step, or FAQ answer the assistant should retain across conversations. Use this when the user explicitly asks you to remember, note, or store something.

**Parameters**

| Parameter     | Type   | Required | Description                                                              |
| ------------- | ------ | -------- | ------------------------------------------------------------------------ |
| `name`        | string | Yes      | Stable, unique system name. Reusing an existing name updates that memory |
| `question`    | string | Yes      | The canonical question or instruction this memory represents             |
| `answer`      | string | Yes      | The canonical answer or guidance to retain                               |
| `title`       | string | No       | Short human-readable title shown in the Context Center                   |
| `summary`     | string | No       | One-line summary of the memory                                           |
| `memoryType`  | string | No       | `Preference`, `UseCase`, `Note`, `Runbook`, or `Faq`. Defaults to `Note` |
| `memoryScope` | string | No       | `UserGlobal` (broad) or `EntityScoped` (tied to a specific entity)       |
| `owners`      | array  | No       | OpenMetadata usernames or team names                                     |
| `tags`        | array  | No       | Tag FQNs to apply                                                        |
| `domains`     | array  | No       | Domain FQNs this memory belongs to                                       |

**Example**

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "create_context_memory",
    "arguments": {
      "name": "finance-warehouse-preference",
      "title": "Finance Dashboard Warehouse",
      "question": "Which warehouse should finance dashboards query?",
      "answer": "Always query the FINANCE_PROD warehouse for finance dashboards.",
      "memoryType": "Preference",
      "memoryScope": "UserGlobal",
      "domains": ["Finance"]
    }
  }
}
```

## Govern & Classify

Define and apply classifications, tags, domains, data products, and entity updates.

### create\_classification

**Description**: Create a new Classification in OpenMetadata. A Classification is a top-level container that groups related Tags (e.g., `PII`, `Tier`). The `name` becomes the root segment of every tag FQN under it. The `mutuallyExclusive` flag is immutable once the classification exists.

**Parameters**

| Parameter           | Type    | Required | Description                                                                                                       |
| ------------------- | ------- | -------- | ----------------------------------------------------------------------------------------------------------------- |
| `name`              | string  | Yes      | Name of the classification. Becomes the root segment of tag FQNs (e.g., `PII` → `PII.Sensitive`). Must be unique. |
| `description`       | string  | Yes      | Description of the classification in Markdown format.                                                             |
| `displayName`       | string  | No       | Human-readable display name.                                                                                      |
| `mutuallyExclusive` | boolean | No       | If `true`, an entity can only carry one tag from this classification at a time. Immutable after creation.         |
| `owners`            | array   | No       | OpenMetadata usernames or team names to set as owners. Each must already exist.                                   |
| `reviewers`         | array   | No       | OpenMetadata usernames or team names to set as reviewers. Each must already exist.                                |
| `domains`           | array   | No       | FQNs of domains this classification belongs to. Each domain must already exist.                                   |

**Example**

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "create_classification",
    "arguments": {
      "name": "PII",
      "description": "Tags for classifying Personally Identifiable Information across data assets.",
      "mutuallyExclusive": false,
      "owners": ["data-governance-team"],
      "reviewers": ["privacy-team"]
    }
  }
}
```

### create\_tag

**Description**: Create a new Tag inside a Classification in OpenMetadata. The tag FQN is `Classification.TagName` (e.g., `PII.Sensitive`). At least one of `classification` or `parent` must be provided.

**Parameters**

| Parameter           | Type    | Required | Description                                                                                                         |
| ------------------- | ------- | -------- | ------------------------------------------------------------------------------------------------------------------- |
| `name`              | string  | Yes      | Name of the tag (the leaf segment, e.g., `Sensitive`). Must be unique within its parent.                            |
| `description`       | string  | Yes      | Description of the tag in Markdown format.                                                                          |
| `classification`    | string  | No       | Name of the classification this tag belongs to (e.g., `PII`). Must already exist. Optional if `parent` is provided. |
| `parent`            | string  | No       | FQN of the parent tag for a nested tag (e.g., `PII.PersonalData`). Must already exist. Omit for a top-level tag.    |
| `displayName`       | string  | No       | Human-readable display name.                                                                                        |
| `mutuallyExclusive` | boolean | No       | If `true`, child tags under this tag are mutually exclusive on an entity.                                           |
| `owners`            | array   | No       | OpenMetadata usernames or team names to set as owners. Each must already exist.                                     |
| `reviewers`         | array   | No       | OpenMetadata usernames or team names to set as reviewers. Each must already exist.                                  |
| `domains`           | array   | No       | FQNs of domains this tag belongs to. Each domain must already exist.                                                |

**Examples**

**Create a top-level tag**:

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "create_tag",
    "arguments": {
      "name": "Sensitive",
      "description": "Data that contains sensitive personal information requiring strict access controls.",
      "classification": "PII"
    }
  }
}
```

**Create a nested tag**:

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "create_tag",
    "arguments": {
      "name": "Email",
      "description": "Email addresses — a subset of sensitive personal data.",
      "parent": "PII.Sensitive"
    }
  }
}
```

### create\_domain

**Description**: Create a new Domain in OpenMetadata. A Domain is a top-level governance grouping of data assets. To create a child domain, set `parent` to the FQN of an existing parent domain. `domainType` defaults to `Aggregate` if omitted.

**Parameters**

| Parameter     | Type   | Required | Description                                                                                 |
| ------------- | ------ | -------- | ------------------------------------------------------------------------------------------- |
| `name`        | string | Yes      | Name of the domain. Must be unique.                                                         |
| `description` | string | Yes      | Description of the domain in Markdown format.                                               |
| `domainType`  | string | No       | Type of domain: `Source-aligned`, `Consumer-aligned`, or `Aggregate` (default).             |
| `parent`      | string | No       | FQN of an existing parent domain when creating a child domain. Omit for a top-level domain. |
| `displayName` | string | No       | Human-readable display name.                                                                |
| `experts`     | array  | No       | OpenMetadata login names of domain experts (e.g., `john.doe`). Each must already exist.     |
| `owners`      | array  | No       | OpenMetadata usernames or team names to set as owners. Each must already exist.             |
| `tags`        | array  | No       | Tag FQNs to apply to this domain (e.g., `Tier.Tier1`).                                      |

**Examples**

**Create a top-level domain**:

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "create_domain",
    "arguments": {
      "name": "Finance",
      "description": "Domain for all finance and accounting data assets.",
      "domainType": "Consumer-aligned",
      "experts": ["jane.doe"],
      "owners": ["finance-team"]
    }
  }
}
```

**Create a child domain**:

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "create_domain",
    "arguments": {
      "name": "Revenue",
      "description": "Sub-domain covering revenue tracking and forecasting.",
      "domainType": "Aggregate",
      "parent": "Finance"
    }
  }
}
```

### create\_data\_product

**Description**: Create a new Data Product in OpenMetadata. A Data Product groups data assets that deliver business value and must belong to at least one Domain. All referenced domain FQNs must already exist.

**Parameters**

| Parameter     | Type   | Required | Description                                                                                                         |
| ------------- | ------ | -------- | ------------------------------------------------------------------------------------------------------------------- |
| `name`        | string | Yes      | Name of the data product. Must be unique.                                                                           |
| `description` | string | Yes      | Description of the data product in Markdown format.                                                                 |
| `domains`     | array  | Yes      | FQNs of the domains this data product belongs to (e.g., `Finance`). At least one required; each must already exist. |
| `displayName` | string | No       | Human-readable display name.                                                                                        |
| `experts`     | array  | No       | OpenMetadata login names of data product experts (e.g., `john.doe`). Each must already exist.                       |
| `owners`      | array  | No       | OpenMetadata usernames or team names to set as owners. Each must already exist.                                     |
| `reviewers`   | array  | No       | OpenMetadata usernames or team names to set as reviewers. Each must already exist.                                  |
| `tags`        | array  | No       | Tag FQNs to apply to this data product (e.g., `Tier.Tier1`, `PII.Sensitive`).                                       |

**Example**

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "create_data_product",
    "arguments": {
      "name": "customer_360",
      "displayName": "Customer 360",
      "description": "Unified view of customer data including orders, support history, and lifetime value.",
      "domains": ["Finance", "Marketing"],
      "experts": ["alice.smith"],
      "owners": ["data-platform-team"],
      "tags": ["Tier.Tier1"]
    }
  }
}
```

### patch\_entity

**Description**: Update an existing entity's properties using [JSON Patch](https://jsonpatch.com/) (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**

```json theme={null}
{
  "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

**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)                                                                                |
| `after`        | string  | No       | Pagination cursor — use `nextCursor` from the previous response                                                    |
| `testPlatform` | string  | No       | Filter by platform: `OpenMetadata`, `GreatExpectations`, `DBT`, `Deequ`, `Soda`, `Other` (default: `OpenMetadata`) |

**Example**

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

### create\_test\_case

**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**

```json theme={null}
{
  "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": []
    }
  }
}
```

## Metrics

Define and track measurable business and technical KPIs.

### create\_metric

**Description**: Create a new metric entity in OpenMetadata to track and standardize business KPIs.

**Parameters**

| Parameter                  | Type   | Required | Description                                                              |
| -------------------------- | ------ | -------- | ------------------------------------------------------------------------ |
| `name`                     | string | Yes      | Name of the metric                                                       |
| `description`              | string | No       | Description of the metric in Markdown format                             |
| `displayName`              | string | No       | Human-readable display name for the metric                               |
| `metricExpressionLanguage` | string | Yes      | Expression language used for the metric (for example, `SQL`)             |
| `metricExpressionCode`     | string | Yes      | Metric formula/expression in the selected language                       |
| `metricType`               | string | No       | Metric type such as `COUNT`, `SUM`, `AVERAGE`, `RATIO`, or `OTHER`       |
| `granularity`              | string | No       | Time granularity such as `DAY`, `WEEK`, `MONTH`, `QUARTER`, or `YEAR`    |
| `unitOfMeasurement`        | string | No       | Unit of measurement such as `COUNT`, `DOLLARS`, `PERCENTAGE`, or `OTHER` |
| `customUnitOfMeasurement`  | string | No       | Custom unit string, required when `unitOfMeasurement` is `OTHER`         |
| `owners`                   | array  | No       | List of owner usernames or emails                                        |
| `reviewers`                | array  | No       | List of reviewer usernames or emails                                     |
| `relatedMetrics`           | array  | No       | List of related metric FQNs                                              |
| `tags`                     | array  | No       | List of tags to apply                                                    |
| `domains`                  | array  | No       | List of domains to associate                                             |

**Example**

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 10,
  "method": "tools/call",
  "params": {
    "name": "create_metric",
    "arguments": {
      "name": "monthly_recurring_revenue",
      "displayName": "Monthly Recurring Revenue",
      "description": "Monthly recurring revenue from active subscriptions.",
      "metricExpressionLanguage": "SQL",
      "metricExpressionCode": "SUM(subscription_amount)",
      "metricType": "SUM",
      "granularity": "MONTH",
      "unitOfMeasurement": "DOLLARS",
      "owners": ["finance-team"],
      "reviewers": ["data-governance-team"],
      "tags": ["Finance", "KPI"],
      "domains": ["Revenue"]
    }
  }
}
```