# RevCent MCP Operation: `GetMetadata`

This document explains how MCP/AI clients should use the `GetMetadata` operation in RevCent.

This file intentionally focuses on metadata discovery and how metadata names can help an MCP/AI prepare better `BigQueryRunQuery` reports and analysis.

Sources:
- RevCent operation schema for `GetMetadata`
- RevCent operation schema for `GetMetadataEntry`
- RevCent operation schema and Markdown documentation for `BigQueryRunQuery`
- RevCent operation schema guidance for `GetBigQueryTables`

---

## Operation Summary

`GetMetadata` returns a paginated list of metadata names saved/indexed in the RevCent account.

Important:

```text
GetMetadata returns metadata names.
GetMetadata does not return the saved values for each metadata name.
```

To retrieve the saved values for a specific metadata name, use:

```text
GetMetadataEntry
```

The schema states that values saved for each metadata name will not be returned when retrieving a list of metadata names. `GetMetadataEntry` is the operation used to retrieve values for a metadata name.

---

# GetMetadata vs GetMetadataEntry

| Operation | Purpose | Returns Metadata Names? | Returns Metadata Values? | Main Use |
|---|---|---:|---:|---|
| `GetMetadata` | Retrieve metadata names/index entries. | Yes | No | Discover what metadata names exist. |
| `GetMetadataEntry` | Retrieve one metadata entry by metadata ID. | Yes, one name | Yes, up to 500 unique values | Discover values for one metadata name. |

Practical workflow:

```text
Use GetMetadata first to discover metadata names.
Then use GetMetadataEntry to inspect values for a specific metadata name.
Then use BigQueryRunQuery for actual reporting, aggregations, and analysis.
Search operations can also use or surface metadata when finding individual records.
```

---

# Why Metadata Names Matter

Metadata names define the custom business dimensions available in the account.

Examples:

```text
source
campaign
utm_source
utm_campaign
affiliate_id
coupon_code
landing_page
checkout_version
funnel_name
traffic_channel
```

These names can become reporting dimensions.

Example business questions:

```text
What revenue came from each source?
Which campaign produced the highest net sales?
Which affiliate generated the most chargebacks?
Which landing page has the highest refund rate?
Which coupon code generated the most customers?
Which checkout version produced the most failed sales?
```

`GetMetadata` helps MCP/AI discover the available metadata names before writing or proposing BigQuery queries.

---

# Why GetMetadata Is Useful Before BigQueryRunQuery

`BigQueryRunQuery` is the correct operation for:

- Counts
- Aggregations
- Metrics
- Reports
- Dashboards
- Revenue analysis
- Customer analysis
- Subscription analysis
- Transaction analysis
- Refund analysis
- Fraud analysis
- Shipment analysis
- Joining related data across tables

`GetMetadata` does not run reports by itself.

Instead, it helps MCP/AI prepare better BigQuery queries by identifying valid metadata names.

Example:

```text
User asks: "Run revenue by traffic source."
MCP does not know whether the account uses source, utm_source, traffic_source, or channel.
MCP calls GetMetadata.
MCP sees metadata name = source.
MCP can now plan a BigQuery query grouped by source metadata.
```

---

# Recommended BigQuery Workflow With Metadata

When the user wants a metadata-based report:

```text
1. Use GetMetadata to discover available metadata names.
2. If the user needs possible values for a name, use GetMetadataEntry.
3. Use GetBigQueryTables to inspect tables and schemas.
4. Identify which table contains the target item data and metadata structure.
5. Build BigQuery Standard SQL using fully qualified table references.
6. Run BigQueryRunQuery.
```

This matters because `BigQueryRunQuery` requires:

```text
BigQuery Standard SQL
Fully qualified table references
Backticks around table references
Optimized queries that avoid the 30-second timeout
```

Table reference format:

```sql
`revcent.user.<table_name>`
```

Examples:

```sql
`revcent.user.sale`
`revcent.user.customer`
`revcent.user.transaction`
`revcent.user.subscription`
```

---

# Do Not Guess the BigQuery Metadata Field Shape

`GetMetadata` tells MCP/AI what metadata names exist.

It does not tell MCP/AI how metadata is represented inside each BigQuery table.

Before writing metadata SQL, use:

```text
GetBigQueryTables
```

to inspect the relevant table schema.

The metadata field may be represented differently depending on table and schema design.

Possible conceptual shapes include:

```text
A repeated record/array of name/value objects
A JSON field
A nested structure
A flattened field
A related table or field discovered through GetBigQueryTables
```

MCP/AI must confirm the actual field names and types from `GetBigQueryTables` before writing final SQL.

---

# Metadata Discovery Example for BigQuery

User asks:

```text
Show me sales by campaign.
```

MCP/AI process:

```text
1. Call GetMetadata.
2. Review available metadata names.
3. Confirm whether campaign exists.
4. If campaign exists, optionally call GetMetadataEntry to inspect known campaign values.
5. Call GetBigQueryTables.
6. Inspect sale table schema.
7. Build a BigQuery query using the confirmed metadata field structure.
8. Run BigQueryRunQuery.
```

`GetMetadata` helps avoid asking BigQuery to group by a metadata name that does not exist.

---

# BigQuery SQL Patterns for Metadata

The exact SQL depends on the schema returned by `GetBigQueryTables`.

The following examples are conceptual patterns only. MCP/AI must adapt them to the actual table schema.

## Pattern A: Metadata Stored as a Repeated Name/Value Record

If `GetBigQueryTables` shows metadata as a repeated record like:

```text
metadata: REPEATED RECORD
metadata.name
metadata.value
```

then a conceptual query might use:

```sql
SELECT
  m.value AS source,
  COUNT(*) AS sale_count,
  SUM(IF(amount_total IS NULL, 0, amount_total)) AS total_revenue
FROM `revcent.user.sale`,
UNNEST(metadata) AS m
WHERE m.name = 'source'
GROUP BY source
ORDER BY total_revenue DESC
```

Important:

```text
Only use this pattern if GetBigQueryTables confirms metadata is a repeated field that can be unnested.
```

## Pattern B: Metadata Stored as JSON

If `GetBigQueryTables` shows metadata as a JSON/string field, a conceptual query might use JSON functions.

Example concept:

```sql
SELECT
  JSON_VALUE(metadata, '$.source') AS source,
  COUNT(*) AS sale_count
FROM `revcent.user.sale`
GROUP BY source
ORDER BY sale_count DESC
```

Important:

```text
Only use this pattern if GetBigQueryTables confirms the field is JSON/string metadata and BigQuery JSON functions are appropriate.
```

## Pattern C: Metadata Exposed Through Another Field or Table

If `GetBigQueryTables` shows metadata in another field or related table, use the schema-provided table/field names.

Do not guess.

---

# Required Input Parameters

`GetMetadata` requires pagination parameters.

| Parameter | Type | Required | Description |
|---|---:|---:|---|
| `limit` | integer | Yes | Number of objects returned. Range: 1 to 25. Default is 25. |
| `page` | integer | Yes | Page number for pagination. |

Example request:

```json
{
  "limit": 25,
  "page": 1
}
```

---

# Output Summary

Successful response includes:

```json
{
  "api_call_id": "XXXXXXXXXXXXXXXXXXXX",
  "api_call_unix": 1740000000,
  "code": 1,
  "current_count": 2,
  "current_page": 1,
  "results": [
    {
      "created_date_unix": 1740000000,
      "id": "MMMMMMMMMMMMMMMMMMMM",
      "name": "source",
      "enabled": true,
      "updated_date_unix": 1740000000
    },
    {
      "created_date_unix": 1740000000,
      "id": "NNNNNNNNNNNNNNNNNNNN",
      "name": "campaign",
      "enabled": true,
      "updated_date_unix": 1740000000
    }
  ],
  "total_count": 2,
  "total_pages": 1
}
```

---

# `results[]` Fields

| Field | Type | Description |
|---|---:|---|
| `created_date_unix` | integer | Unix timestamp when the metadata entry was created. |
| `id` | string | 20-character Metadata ID. Use this ID with `GetMetadataEntry`. |
| `name` | string | Metadata name. |
| `enabled` | boolean | Whether the metadata entry is enabled. |
| `updated_date_unix` | integer | Unix timestamp when the metadata entry was last updated. |

Important:

```text
The result object does not include values.
```

Use `GetMetadataEntry` to retrieve saved values for one metadata name.

---

# When to Use GetMetadata

Use `GetMetadata` when:

```text
The user wants to know what metadata names exist.
The user wants metadata fields available for reporting.
MCP/AI needs to discover whether source, campaign, affiliate_id, email_version, checkout_page, facebook_post_id, instagram_post, or another custom field exists.
MCP/AI is preparing a BigQuery query grouped or filtered by metadata.
MCP/AI needs a metadata_id before calling GetMetadataEntry.
MCP/AI is building filter options for an analytics/reporting workflow.
```

---

# When Not to Use GetMetadata

Do not use `GetMetadata` when:

```text
The user wants values for one metadata name. Use GetMetadataEntry.
The user wants actual sales/customers/transactions matching metadata. Use BigQueryRunQuery or relevant list/search operations.
The user wants counts, totals, reports, or dashboards. Use BigQueryRunQuery.
The user wants to insert metadata. Use InsertMetadata.
The user wants to update item-specific data. Use the appropriate item or metadata operation.
```

---

---

# Metadata Can Be Any Custom Business Dimension

Metadata names and values can literally be anything the user or business has chosen to store.

Metadata is not limited to advertising, conversion tracking, UTM parameters, or affiliate attribution.

Advertising-related examples:

```text
source
campaign
utm_source
utm_campaign
affiliate_id
adgroup
keyword
```

Non-advertising examples:

```text
email_version
email_subject_variant
facebook_post
facebook_post_id
instagram_post
instagram_story
influencer_post
checkout_page
checkout_version
landing_page
funnel_step
product_quiz_answer
support_agent
call_center_batch
webinar_id
sms_campaign
shipping_promo
internal_experiment
```

Example metadata pairs:

```json
{
  "name": "email_version",
  "value": "welcome_v3"
}
```

```json
{
  "name": "facebook_post_id",
  "value": "post_987654"
}
```

```json
{
  "name": "instagram_post",
  "value": "spring_reel_02"
}
```

```json
{
  "name": "checkout_page",
  "value": "version_b"
}
```

Because metadata can be any name/value pair, MCP/AI should not assume metadata is advertising-related. Metadata may represent any custom business context the user wanted to store with customers, sales, transactions, subscriptions, or other records.

---

# When To Consider Metadata vs Known Schema Fields

MCP/AI should consider metadata when the user wants to search or report on something that is not an obvious built-in schema property.

Use known schema fields first when the requested concept clearly maps to an existing field.

Use metadata discovery when the requested concept sounds custom, business-specific, campaign-specific, content-specific, experimental, or not obviously present in the schema.

---

## Use Known Schema Fields When They Exist

If the user asks for something that is already a known searchable or reportable field in the item schema, metadata is not needed.

Examples:

```text
Search by customer first name.
Search by customer email.
Search by customer phone.
Search by transaction ID.
Search by gateway transaction ID.
Report sales by customer state.
Report customers by ZIP/postal code.
Report transactions by approved status.
Report subscriptions by status.
```

These concepts correspond to normal schema fields such as:

```text
first_name
last_name
email
phone
state
zip
transaction_id
gateway_transaction_id
approved
status
created_date_unix
```

Example:

```text
User asks: "Find customers named John."
```

This is not a metadata problem because `first_name` is a known customer/search field.

Example:

```text
User asks: "Run a report on sales by customer home state."
```

This is not metadata worth assuming because customer address state exists as a normal schema property.

MCP/AI should use Search operations, item list operations, or BigQuery table fields based on the schema rather than forcing metadata.

---

## Use Metadata Discovery When the Concept Is Custom or Ambiguous

If the user asks for something that does not clearly map to a built-in schema property, MCP/AI should inspect metadata.

Examples:

```text
Sales by affiliate.
Sales by page B.
Revenue by email version.
Orders from Facebook post X.
Customers from Instagram reel 2.
Declines by checkout version.
Refunds by landing page experiment.
Sales from webinar attendees.
Revenue by influencer post.
```

These may map to metadata names/values such as:

```text
affiliate_id = partner_123
checkout_page = version_b
email_version = welcome_v3
facebook_post_id = post_987654
instagram_post = spring_reel_02
landing_page = experiment_a
webinar_id = webinar_2026_05
influencer_post = creator_jane_post_04
```

MCP/AI should use:

```text
GetMetadata
```

to inspect the existing metadata names, then:

```text
GetMetadataEntry
```

to inspect exact values for likely metadata names.

This prevents guessing the wrong name/value pair.

---

# Metadata Discovery Decision Rule

Use this decision rule:

```text
If the requested search/report dimension is an obvious schema field, use the schema field.
If the requested dimension is not an obvious schema field, inspect metadata.
If unsure, inspect both the BigQuery schema and the metadata index before deciding.
```

Recommended workflow for reports:

```text
1. Identify the user’s requested dimension.
2. Check whether it is a known schema property using operation schemas or GetBigQueryTables.
3. If it is a known schema property, use that field directly.
4. If it is not a known schema property, call GetMetadata.
5. For likely metadata names, call GetMetadataEntry to inspect exact values.
6. Use BigQueryRunQuery for reporting/aggregation.
```

Recommended workflow for searches:

```text
1. Identify whether the user wants individual records or a report.
2. If individual records and the term maps to known fields, use the relevant Search operation.
3. If the term may be custom metadata, call GetMetadata and GetMetadataEntry first.
4. Use Search operations for individual record discovery.
5. Use BigQueryRunQuery for exact filtering, grouping, counts, revenue, or other metrics.
```

---

# Examples: Schema Field vs Metadata

| User request | Likely approach | Why |
|---|---|---|
| "Find customers named Sarah" | Search/schema field | `first_name` is a known customer field. |
| "Find sales for customer email jane@example.com" | Search/schema field | `email` is a known field. |
| "Report sales by customer home state" | BigQuery schema field | `state` is a known address/customer field. |
| "Report transactions by approval status" | BigQuery schema field | `approved` is a known transaction field. |
| "Sales by affiliate" | Check metadata | Affiliate is likely custom, such as `affiliate_id`. |
| "Sales by page B" | Check metadata | Page variant is likely custom, such as `checkout_page = version_b`. |
| "Revenue by email version" | Check metadata | Email version is likely custom, such as `email_version`. |
| "Orders from Instagram post 3" | Check metadata | Social post attribution is likely custom metadata. |
| "Declines by checkout version" | Check metadata | Checkout version is likely custom metadata. |

---

# Avoid Metadata Overuse

Metadata is powerful, but MCP/AI should not use it unnecessarily.

Do not convert obvious schema-field questions into metadata questions.

Wrong:

```text
User asks for sales by state.
MCP assumes metadata name = state.
```

Correct:

```text
Use the known address/customer state field if the schema supports it.
```

Wrong:

```text
User asks to search for customer first name Ryan.
MCP checks metadata first.
```

Correct:

```text
Use known customer search fields because first_name is a schema/search field.
```

Use metadata when it is the right tool: custom business dimensions, external attribution, content variants, experiments, campaign labels, and account-specific name/value data.

---

# Search Operations and Metadata

RevCent has multiple `Search...` operations that search previously created records using a single `search_term`.

Examples include:

```text
SearchCustomers
SearchSales
SearchTransactions
SearchSubscriptions
SearchChargebacks
SearchCustomerCards
```

These Search operations use a full-text search engine and many search result schemas include a `metadata` array.

The metadata array contains name/value pairs such as:

```json
[
  {
    "name": "affiliate_id",
    "value": "partner_123"
  },
  {
    "name": "checkout_page",
    "value": "version_b"
  }
]
```

This means metadata can be relevant to Search operations in two ways:

```text
1. Search results may include metadata that matched or helps explain the result.
2. The user's natural-language search/request may actually be referring to metadata, even if the user does not say "metadata."
```

---

## Users Often Describe Metadata Without Knowing It

Users may ask business questions using familiar business terms instead of metadata terminology.

Examples:

| User says | Likely metadata interpretation |
|---|---|
| "sales by affiliate" | Metadata name may be `affiliate_id`. |
| "sales by page B" | Metadata name may be `checkout_page`, value may be `version_b`. |
| "orders from Facebook" | Metadata name may be `source`, `utm_source`, or `traffic_channel`, value may be `Facebook`. |
| "customers from holiday campaign" | Metadata name may be `campaign` or `utm_campaign`, value may be `holiday_campaign` or similar. |
| "show me sales from funnel 2" | Metadata name may be `funnel_name`, `funnel_id`, or `checkout_version`. |
| "transactions from the upsell page" | Metadata name may be `page`, `checkout_page`, `landing_page`, or `funnel_step`. |

The user may not know that the business concept they are describing is stored as metadata.

MCP/AI should recognize when a request may involve metadata, even if the user does not use the word "metadata."

---

## Why the Metadata Index Matters for Search

When the user's request is ambiguous, MCP/AI should inspect the metadata index.

Use:

```text
GetMetadata
```

to see available metadata names.

Then use:

```text
GetMetadataEntry
```

to inspect exact values for a likely metadata name.

This prevents MCP/AI from guessing.

Example:

```text
User asks: "Show me sales by affiliate."
```

MCP should not assume the metadata name is exactly:

```text
affiliate
```

The account may actually use:

```text
affiliate_id
affiliate
partner_id
referrer
source
```

Recommended process:

```text
1. Call GetMetadata.
2. Look for names related to affiliate.
3. If `affiliate_id` exists, call GetMetadataEntry for that metadata ID.
4. Inspect actual affiliate values.
5. Decide whether to use SearchSales, BigQueryRunQuery, or another operation.
```

---

## Example: "Sales by Affiliate"

User request:

```text
How many sales did each affiliate bring in?
```

Likely meaning:

```text
Group sales by metadata name = affiliate_id.
```

Recommended MCP process:

```text
1. Use GetMetadata to discover whether affiliate_id exists.
2. Use GetMetadataEntry to inspect known affiliate_id values.
3. Use GetBigQueryTables to confirm the sale table and metadata field structure.
4. Use BigQueryRunQuery to aggregate sales by affiliate_id.
```

Why not SearchSales alone?

```text
SearchSales can help find individual sales matching a term.
BigQueryRunQuery is better for counts, grouping, metrics, and reporting.
```

---

## Example: "Sales by Page B"

User request:

```text
Show me sales by page B.
```

Likely meaning:

```text
Find or report sales where metadata name = checkout_page and value = version_b.
```

But MCP should verify.

Recommended process:

```text
1. Use GetMetadata to find page-related metadata names.
2. Possible names may include checkout_page, landing_page, page, funnel_page, checkout_version.
3. Use GetMetadataEntry for the most likely entries.
4. Confirm whether value version_b or page_b exists.
5. If the user wants individual matching records, use SearchSales or another relevant search/list operation where appropriate.
6. If the user wants counts, revenue, or reporting, use BigQueryRunQuery.
```

---

## Search Operations vs BigQueryRunQuery

Search operations and BigQuery serve different purposes.

| User goal | Better operation |
|---|---|
| Find individual records matching a phrase or value | Search operation, such as `SearchSales` or `SearchCustomers` |
| Inspect search results and matching highlights | Search operation |
| Count records by metadata value | `BigQueryRunQuery` |
| Revenue by metadata value | `BigQueryRunQuery` |
| Group by affiliate/campaign/source/page | `BigQueryRunQuery` |
| Build dashboards or reports | `BigQueryRunQuery` |
| Discover possible metadata names | `GetMetadata` |
| Discover possible metadata values | `GetMetadataEntry` |

Search is useful for retrieval and discovery.

BigQuery is useful for analytics and aggregation.

---

## Search Operation Metadata Awareness

Several Search operation result schemas include:

```text
metadata
highlights
score
```

The `metadata` array can show the metadata name/value pairs attached to the result.

The `highlights` array can show which fields matched the search term.

This can help MCP/AI understand why an item was returned.

Example search result concept:

```json
{
  "item_type": "sale",
  "id": "XXXXXXXXXXXXXXXXXXXX",
  "email": "customer@example.com",
  "metadata": [
    {
      "name": "checkout_page",
      "value": "version_b"
    }
  ],
  "highlights": [
    {
      "field": "metadata.value",
      "values": [
        "version_b"
      ]
    }
  ],
  "score": 12.5
}
```

MCP/AI should review metadata and highlights in search results when determining whether the user’s requested concept maps to metadata.

---

## Search Workflow When Metadata Is Suspected

When a user asks to search for or query a business concept that might be metadata:

```text
1. Identify whether the phrase sounds like a business dimension, campaign, source, affiliate, funnel, page, variant, coupon, or traffic attribute.
2. Call GetMetadata to inspect available metadata names.
3. If likely names exist, call GetMetadataEntry for exact values.
4. If the user wants individual records, use the appropriate Search operation.
5. If the user wants metrics/reporting, use BigQueryRunQuery.
6. If the exact metadata mapping is ambiguous, present the likely metadata name/value mapping before running the final query.
```

---

## Do Not Guess Metadata Names or Values

MCP/AI should not guess that:

```text
affiliate = affiliate_id
page B = checkout_page: version_b
facebook = source: Facebook
holiday = campaign: HolidaySale
```

without checking the existing metadata index and values.

The account may use different names or casing.

Correct behavior:

```text
Use GetMetadata to find the metadata name.
Use GetMetadataEntry to confirm exact values.
Then use Search or BigQuery with the exact metadata name/value.
```

---

## Practical Decision Examples

### User asks for individual records

```text
"Find sales from affiliate partner_123."
```

Recommended:

```text
1. Check metadata names and values.
2. If affiliate_id = partner_123 exists, use SearchSales or a relevant item search/list path for matching records.
3. If exact filtering is required and SearchSales is too broad, use BigQueryRunQuery or the relevant list operation with metadata filtering if available.
```

### User asks for a report

```text
"How much revenue came from affiliate partner_123?"
```

Recommended:

```text
1. Check metadata names and values.
2. Use GetBigQueryTables to confirm schema.
3. Run BigQueryRunQuery.
```

### User asks an ambiguous question

```text
"How did page B do?"
```

Recommended:

```text
1. Ask what metric is desired if needed: sales, revenue, declines, conversion, refunds, etc.
2. Check metadata names for page-related fields.
3. Check metadata values for version_b/page_b.
4. Use BigQueryRunQuery for metrics or SearchSales for individual sales.
```

# Metadata Names and Reporting Strategy

Good metadata names make reporting easier.

Examples of useful metadata names:

```text
source
campaign
utm_source
utm_campaign
affiliate_id
coupon_code
landing_page
checkout_version
traffic_channel
```

Poor or vague metadata names make reporting harder:

```text
thing
data
misc
x
test
value
```

MCP/AI should encourage consistent metadata naming.

If the account has duplicate concepts, such as:

```text
source
traffic_source
utm_source
Source
```

MCP/AI should warn that reporting may require normalizing or choosing the correct field.

---

# Metadata and BigQuery Reports: Use Cases

Metadata names discovered by `GetMetadata` can help build BigQuery reports such as:

```text
Sales by source
Revenue by campaign
Refunds by coupon_code
Chargebacks by affiliate_id
Declines by landing_page
Subscription renewals by traffic_channel
Customer lifetime value by original campaign
Shipping outcomes by funnel_name
```

The query itself should be run with:

```text
BigQueryRunQuery
```

using schemas from:

```text
GetBigQueryTables
```

---

# BigQuery Query Construction Rules to Remember

The BigQuery operation documentation emphasizes:

```text
Use BigQuery Standard SQL.
Use fully qualified table references.
Surround table references with backticks.
Use GetBigQueryTables before writing queries.
Optimize queries to avoid the 30-second timeout.
Avoid COALESCE.
When using TIMESTAMP_SUB, only use INTERVAL in DAY.
```

Correct table reference:

```sql
SELECT COUNT(*) AS total_sales
FROM `revcent.user.sale`
```

Incorrect:

```sql
SELECT COUNT(*) AS total_sales
FROM revcent.user.sale
```

---

# MCP Workflow: Metadata-Based Report Request

User asks:

```text
Run a report of revenue by source for the last 30 days.
```

MCP process:

```text
1. Call GetMetadata to confirm source exists.
2. Optionally call GetMetadataEntry for source values.
3. Call GetBigQueryTables to inspect sale table schema and metadata field shape.
4. Build optimized Standard SQL.
5. Use fully qualified backticked table names.
6. Avoid COALESCE.
7. Use TIMESTAMP_SUB only with INTERVAL in DAY.
8. Call BigQueryRunQuery.
9. If the query errors, fix SQL and retry.
```

---

# MCP Validation Checklist

Before calling `GetMetadata`:

1. `limit` is provided.
2. `limit` is between 1 and 25.
3. `page` is provided.
4. MCP understands this returns metadata names, not values.
5. If values are needed, MCP plans to call `GetMetadataEntry`.
6. If reports/metrics are needed, MCP plans to use `BigQueryRunQuery`.
7. MCP has considered whether the requested dimension is an obvious schema field before treating it as metadata.
7. If SQL is needed, MCP plans to call `GetBigQueryTables` to inspect table schemas.
8. MCP will not guess BigQuery metadata field shape from GetMetadata alone.

---

# Key Takeaways

```text
GetMetadata returns metadata names/index entries.
```

```text
GetMetadata does not return metadata values.
```

```text
Use GetMetadataEntry to retrieve values for one metadata name.
```

```text
GetMetadata is useful before BigQueryRunQuery because it helps MCP/AI discover valid metadata dimensions.
```

```text
BigQueryRunQuery is used for reports, metrics, counts, aggregations, and joins.
```

```text
Use GetBigQueryTables before writing metadata-based SQL because GetMetadata does not reveal BigQuery field structure.
```


---
Document Parent Directory
* [Operations](https://revcent.com/documentation/markdown/mcp/operation/index.md) - AI/MCP details and overviews for operations available within the RevCent MCP.