What can you do with this server?

The BigQuery Validator server provides tools for validating and analyzing BigQuery SQL queries without executing them. * SQL Validation: Check BigQuery SQL syntax for correctness using the bq_validate_sql tool * Dry-Run Analysis: Perform dry-run operations using the bq_dry_run_sql tool to obtain: * Cost estimates in USD based on bytes processed (customizable price per TiB) * Referenced tables identification * Output schema preview * Parameter Support: Both validation and dry-run tools support parameterized queries with key-value pairs * Safe Operation: All operations are dry-run only - no queries are executed or data modified

Which integrations are available for this server?

Provides tools for validating BigQuery SQL syntax and performing dry-run analysis to get cost estimates, schema previews, and metadata without executing queries

How do I use BigQuery Validator?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@BigQuery Validator estimate the cost of SELECT * FROM sales.transactions WHERE date > '2024-01-01'" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

de en es ja ko ru zh

BigQuery Validator

by caron14

Overview Schema Source Related Servers Discussions Admin

Python

Hybrid

mcp-bigquery

Safe BigQuery exploration through Model Context Protocol

MIT License PyPI Version Python Support Downloads

Documentation | Quick Start | Examples

Overview

mcp-bigquery is a Model Context Protocol (MCP) server that enables AI assistants (such as Claude) to interact securely with Google BigQuery.

Key Features

Secure execution: All operations are strictly limited to dry-run verification. The server never executes queries that mutate data or incur execution costs.
Cost transparency: Provides estimates of query costs and processed bytes before execution.
Static analysis: Analyzes query dependencies and validates SQL syntax.
Schema exploration: Browses datasets, tables, and columns.

Business Value

Problem	Solution with mcp-bigquery
Unintentional execution of costly queries	Pre-execution cost estimation
Delayed development due to SQL syntax errors	Early syntax error detection
Lack of visibility into schema structures	Secure schema metadata discovery
Risk of unauthorized data mutation by AI	Enforced dry-run constraints

Related MCP server: BigQuery MCP Server

Quick Start

Step 1: Installation

Install the package via pip:

pip install mcp-bigquery

Step 2: Authentication

Set up Google Cloud Platform authentication:

# For user account authentication
gcloud auth application-default login

# For service account authentication
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json

Step 3: Claude Desktop Configuration

Configure the server in the Claude Desktop configuration file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

Add the following entry:

{
  "mcpServers": {
    "mcp-bigquery": {
      "command": "mcp-bigquery",
      "env": {
        "BQ_PROJECT": "your-gcp-project-id"
      }
    }
  }
}

Step 4: Verification

Restart Claude Desktop and run the following queries to verify the setup:

"What datasets are available in my BigQuery project?"
"Can you estimate the cost of: SELECT * FROM dataset.table"
"Show me the schema for the users table"

Available Tools

SQL Validation and Analysis

Tool	Purpose	Primary Use Case
bq_validate_sql	Check SQL syntax	Verification prior to query execution
bq_dry_run_sql	Retrieve cost estimates and metadata	Pre-execution cost assessment
bq_extract_dependencies	Map table dependencies	Lineage and dependency mapping
bq_validate_query_syntax	Detailed syntax analysis	Debugging complex SQL queries

Schema Discovery

Tool	Purpose	Primary Use Case
bq_list_datasets	List all datasets in the project	Initial project discovery
bq_list_tables	List tables with partitioning metadata	Dataset structure browsing
bq_describe_table	Get detailed schema details	Column-level verification
bq_get_table_info	Retrieve comprehensive metadata	Table statistics analysis
bq_preview_table	Preview table data (cost-free)	Checking sample records without data scan costs

IMPORTANT

Thebq_preview_table tool uses client.list_rows (API: tabledata.list) to retrieve sample rows directly, resulting in zero bytes scanned and no execution costs. To prevent unintended exposure of sensitive information (such as PII) to the LLM, this tool is disabled by default. You must explicitly opt in by setting MCP_BQ_ENABLE_PREVIEW=true in your environment config.

Configuration

Environment Variables

Variable	Purpose	Default
`BQ_PROJECT`	Target GCP Project ID	Determined via ADC
`BQ_LOCATION`	Target BigQuery Region	Not set
`SAFE_PRICE_PER_TIB`	Price per TiB for cost estimation	5.0
`LOG_LEVEL`	Logging verbosity (DEBUG, INFO, WARNING, ERROR, CRITICAL)	WARNING
`MCP_BQ_ENABLE_PREVIEW`	Enable the bq_preview_table tool (true/false)	false

Example .env File

For local testing or development environments, you can define these variables in a .env file:

BQ_PROJECT=your-gcp-project-id
BQ_LOCATION=asia-northeast1
SAFE_PRICE_PER_TIB=5.0
LOG_LEVEL=WARNING
MCP_BQ_ENABLE_PREVIEW=true

Complete Claude Desktop Configuration Example

{
  "mcpServers": {
    "mcp-bigquery": {
      "command": "mcp-bigquery",
      "env": {
        "BQ_PROJECT": "my-production-project",
        "BQ_LOCATION": "asia-northeast1",
        "SAFE_PRICE_PER_TIB": "6.0",
        "LOG_LEVEL": "WARNING",
        "MCP_BQ_ENABLE_PREVIEW": "true"
      }
    }
  }
}

Troubleshooting

Mapped Errors and Solutions

Authentication Error

Error: Could not automatically determine credentials

Solution: Re-authenticate using the command line:
```
gcloud auth application-default login
```

Permission Denied

Error: User does not have bigquery.tables.get permission

Solution: Grant the BigQuery Data Viewer role to the target identity:

gcloud projects add-iam-policy-binding YOUR_PROJECT \
  --member="user:your-email@example.com" \
  --role="roles/bigquery.dataViewer"

Project ID Missing

Error: Project ID is required

Solution: Ensure the BQ_PROJECT variable is set correctly in your configuration.

Examples of Usage

Example 1: Check Costs Before Running

# Before running an expensive query...
query = "SELECT * FROM `bigquery-public-data.github_repos.commits`"

# First, check the cost
result = bq_dry_run_sql(sql=query)
print(f"Estimated cost: ${result['usdEstimate']}")
print(f"Data processed: {result['totalBytesProcessed'] / 1e9:.2f} GB")

# Output:
# Estimated cost: $12.50
# Data processed: 2500.00 GB

Example 2: Understand Table Structure

# Check table schema
result = bq_describe_table(
    dataset_id="your_dataset",
    table_id="users"
)

# Output:
# ├── user_id (INTEGER, REQUIRED)
# ├── email (STRING, NULLABLE)
# ├── created_at (TIMESTAMP, REQUIRED)
# └── profile (RECORD, REPEATED)
#     ├── name (STRING)
#     └── age (INTEGER)

Example 3: Track Data Dependencies

# Understand query dependencies
query = """
WITH user_stats AS (
  SELECT user_id, COUNT(*) as order_count
  FROM orders
  GROUP BY user_id
)
SELECT u.name, s.order_count
FROM users u
JOIN user_stats s ON u.id = s.user_id
"""

result = bq_extract_dependencies(sql=query)

# Output:
# Tables: ['orders', 'users']
# Columns: ['user_id', 'name', 'id']
# Dependency Graph:
#   orders → user_stats → final_result
#   users → final_result

Project Status and Version History

Version	Release Date	Summary of Changes
v0.7.1	2026-08-17	Refined mcp dependency constraints and streamlined wiki documentation
v0.7.0	2026-06-21	Added cost-free table preview tool (`bq_preview_table`) and security opt-in configuration
v0.6.0	2026-06-21	Thread-safe caching, recursive AST queries, backoff retries, and Google API exception mapping
v0.5.0	2026-01-02	Consolidated formatters, client cache, and unified logging controls
v0.4.2	2025-12-08	Modular schema explorer and unified client/logging controls
v0.4.1	2025-01-22	Error handling and debug logging improvements
v0.4.0	2025-01-22	Added schema discovery tools
v0.3.0	2025-01-17	Integrated SQL static analysis engine
v0.2.0	2025-01-16	Initial release supporting basic validation and dry-run queries

Development and Contribution

For instructions on local development setup and contribution policies, please refer to the CONTRIBUTING.md guide.

# Clone the repository
git clone https://github.com/caron14/mcp-bigquery.git
cd mcp-bigquery

# Install development dependencies
pip install -e ".[dev]"

# Execute the test suite
pytest tests/

License

This project is licensed under the MIT License. See LICENSE for details.

Available Tools

9 tools

bq_describe_tableB

Get table schema, metadata, and statistics

ParametersJSON Schema

Name	Required	Description
`table_id`	Yes	The table ID
`dataset_id`	Yes	The dataset ID
`project_id`	No	GCP project ID (uses default if not provided)
`format_output`	No	Whether to format schema as table string

TDQS

B3.3/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It correctly implies a read-only operation ('Get') and lists output categories (schema, metadata, statistics), but does not disclose permissions, latency, or data freshness. Adequate but not detailed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that front-loads the verb and resource. Every word contributes meaning with zero waste.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read tool with a well-documented input schema and no output schema, the description gives a high-level summary but lacks specifics on the return format, field details, or how it differs from similar siblings. It meets minimum viability.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

All 4 parameters are fully documented in the input schema (100% coverage). The description adds no extra parameter semantics beyond the schema descriptions, so baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Get' and the resource 'table schema, metadata, and statistics'. However, it does not differentiate from sibling tool 'bq_get_table_info', which likely has overlapping functionality.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'bq_get_table_info' or 'bq_list_tables'. It lacks when-not-to-use or context for selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

bq_dry_run_sqlB

Perform a dry-run of a BigQuery SQL query to get cost estimates and metadata

ParametersJSON Schema

Name	Required	Description
`sql`	Yes	The SQL query to dry-run
`params`	No	Optional query parameters (key-value pairs)
`pricePerTiB`	No	Price per TiB for cost estimation (defaults to env var or 5.0)

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description bears full responsibility for behavioral disclosure. It only states the tool performs a dry-run and returns cost estimates and metadata, but fails to mention key aspects such as idempotency (safe to call multiple times), required permissions, rate limits, or what exactly 'metadata' includes. The non-destructive nature is implied but not explicit.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that efficiently conveys the tool's purpose. It is front-loaded and contains no unnecessary words or information, earning its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 3 parameters (one nested object) and no output schema, the description is minimal. It outlines the goal but omits details on return values, error handling, and edge cases. While the tool is straightforward, the lack of output schema means the description should provide more context on what the agent can expect from the dry-run results.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with each parameter described in the input schema. The description itself adds no additional semantic meaning beyond what the schema provides. Baseline is 3 because the schema does the heavy lifting; the description does not compensate for any gaps.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool performs a dry-run of a BigQuery SQL query to get cost estimates and metadata. It uses a specific verb (dry-run) and resource (BigQuery SQL query). However, it does not distinguish from the sibling tool 'bq_validate_sql', which may also involve checking queries, reducing clarity on when to use each.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like bq_validate_sql. There is no mention of prerequisites, context, or situations where this tool is appropriate or not, leaving the agent with no decision support.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

bq_extract_dependenciesC

Extract table and column dependencies from BigQuery SQL

ParametersJSON Schema

Name	Required	Description	Default
`sql`	Yes	The SQL query to analyze
`params`	No	Optional query parameters (key-value pairs)

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must fully disclose behavioral traits. It does not mention whether the tool executes the query, is read-only, requires permissions, or has side effects. 'Extract' implies reading but it is not explicit.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence with no redundant information. Every word is necessary.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool extracts dependencies but provides no output schema, leaving the agent uninformed about the return format. Given the complexity of dependencies (tables, columns), the description is too sparse.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the schema already describes both parameters. The description adds no additional meaning beyond the schema, so baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'Extract' and the resource 'table and column dependencies from BigQuery SQL', making the action clear. It implicitly distinguishes from siblings like bq_validate_query_syntax, but does not explicitly differentiate.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives (e.g., bq_validate_sql). The description lacks any context about appropriate use cases or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

bq_get_table_infoB

Get comprehensive table information including partitioning and clustering

ParametersJSON Schema

Name	Required	Description
`table_id`	Yes	The table ID
`dataset_id`	Yes	The dataset ID
`project_id`	No	GCP project ID (uses default if not provided)

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry the full burden of behavioral transparency. It mentions the tool is a 'get' operation but does not disclose auth requirements, error handling, or whether it is read-only. The inclusion of partitioning and clustering adds some output context but not behavioral traits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that states the tool's purpose without any wasted words. It is maximally concise while still conveying essential information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple information-retrieval tool with three parameters and no output schema, the description provides the core purpose and hints at output content (partitioning, clustering). However, it lacks details on error behavior, output format, and differentiation from siblings, making it adequate but incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema has 100% description coverage, so baseline is 3. The description does not add any extra meaning to the parameters beyond the schema, as it focuses on the output instead.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves comprehensive table information including partitioning and clustering. However, it does not explicitly distinguish itself from the sibling tool bq_describe_table, which likely has overlapping functionality.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives like bq_describe_table. The description lacks any usage context or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

bq_list_datasetsB

List all datasets in the BigQuery project

ParametersJSON Schema

Name	Required	Description	Default
`project_id`	No	GCP project ID (uses default if not provided)
`max_results`	No	Maximum number of datasets to return

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided. The description lacks behavioral details such as pagination, rate limits, or error handling. The claim 'List all datasets' is contradicted by the max_results parameter, which limits results.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence without fluff, but could be more informative about behavior. It is efficient but slightly under-specified.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema, so description should explain return format. It does not. Lacks context on when to use vs siblings like bq_list_tables. Insufficient for an agent to fully understand the tool's role.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema descriptions cover 100% of parameters with clear meanings. The description adds no extra value beyond the schema, meeting the baseline but not exceeding it.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'List' and the resource 'datasets in the BigQuery project', distinguishing it from siblings like bq_list_tables which list tables instead.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool vs alternatives (e.g., bq_list_tables for tables). Missing context on prerequisites or suitable scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

bq_list_tablesA

List all tables in a BigQuery dataset with metadata

ParametersJSON Schema

Name	Required	Description
`dataset_id`	Yes	The dataset ID
`project_id`	No	GCP project ID (uses default if not provided)
`max_results`	No	Maximum number of tables
`table_type_filter`	No	Filter by table types (TABLE, VIEW, EXTERNAL, MATERIALIZED_VIEW)

TDQS

A3.7/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so the description bears full burden. It states the operation is a listing with metadata but omits behavioral details like pagination, rate limits, or whether it requires specific permissions. It is not misleading but leaves gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence of 8 words, front-loaded with purpose. Every word earns its place; no wasted text.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Tool has no output schema. Description says 'with metadata' but does not specify what metadata fields are returned. For a list operation, this is adequate but not complete. Parameters are well-documented, but return value details are missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema has 100% coverage with descriptions for all 4 parameters. The description adds no extra meaning beyond 'with metadata', which hints at return content. Baseline is 3 since schema already provides clarity.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'List all tables in a BigQuery dataset with metadata', specifying the verb 'list', resource 'tables', and scope 'in a BigQuery dataset'. It distinguishes itself from siblings like bq_describe_table and bq_get_table_info effectively.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool vs alternatives (e.g., bq_list_datasets lists datasets, not tables). The description implies usage for listing tables with metadata but doesn't provide when-not or exclusion criteria.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

bq_preview_tableB

Get a preview of table data without running a query job (cost-free)

ParametersJSON Schema

Name	Required	Description
`table_id`	Yes	The table ID
`dataset_id`	Yes	The dataset ID
`project_id`	No	GCP project ID (uses default if not provided)
`max_results`	No	Maximum number of rows to preview (default: 5, hard limit: 10)

TDQS

B3.4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, so the description must fully disclose behavior. It mentions cost-free and no query job, but fails to describe return format (e.g., rows), ordering (first rows?), or the hard limit of 10 from the schema. This omission leaves significant behavioral unknowns.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single, front-loaded sentence with zero wasted words. It efficiently conveys purpose and key differentiator.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, the description should explain return values (e.g., 'returns first N rows as JSON') but does not. It also omits details like permission requirements or that preview uses the first rows. The tool is simple, but the description is incomplete for safe invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with all parameters described in the schema. The description adds no extra meaning beyond summarizing the schema. Thus baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('preview table data') and key benefit ('cost-free, without running a query job'). It distinguishes from siblings like bq_describe_table (schema) and bq_run_query (costly query). This provides a specific verb+resource with differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use for quick, cost-free previews but lacks explicit when-not or alternative tools. With siblings including bq_get_table_info and bq_dry_run_sql, no comparison or exclusion is provided, leaving guidance implicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

bq_validate_query_syntaxC

Enhanced syntax validation with detailed error reporting

ParametersJSON Schema

Name	Required	Description	Default
`sql`	Yes	The SQL query to validate
`params`	No	Optional query parameters (key-value pairs)

TDQS

C2.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It claims 'detailed error reporting' but does not explain what constitutes enhanced behavior, side effects, or limitations. Lacks any behavioral context beyond a vague promise.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is very short (one phrase), but it is front-loaded with functionality. However, it sacrifices necessary detail for brevity, making it less helpful.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no output schema and two parameters, the description should explain what 'enhanced' validation entails, expected error messages, or usage examples. It fails to provide sufficient context for effective use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with adequate parameter descriptions. The tool description adds no additional parameter-specific meaning, achieving only baseline value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states 'syntax validation' which implies validating SQL syntax, but does not explicitly mention SQL queries. The phrase 'enhanced...with detailed error reporting' adds some clarity but fails to distinguish from sibling tool 'bq_validate_sql'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus the similar sibling 'bq_validate_sql'. The description offers no context for selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

bq_validate_sqlA

Validate BigQuery SQL syntax without executing the query

ParametersJSON Schema

Name	Required	Description	Default
`sql`	Yes	The SQL query to validate
`params`	No	Optional query parameters (key-value pairs)

TDQS

A3.7/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description only states the tool validates without executing. It does not disclose what happens on invalid syntax, auth requirements, or whether it checks table existence, leaving significant behavioral gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single 8-word sentence with no extraneous information, achieving maximum conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (2 parameters, no output schema, no annotations), the description is minimally adequate but lacks details about return values or behavior on errors, which would help agents understand the output.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%; both parameters have clear descriptions in the schema. The tool description adds no extra parameter information beyond what the schema already provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description specifies the verb 'validate' and the resource 'BigQuery SQL syntax', and clearly states it does not execute the query, distinguishing it from bq_dry_run_sql which executes a dry run.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use for syntax checking only, not execution. It contrasts with 'without executing', but does not explicitly name when not to use or mention bq_dry_run_sql as an alternative.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

1 tool updatev0.7.0Jun 21, 2026
- Addedbq_preview_table
4 tool updatesv0.2.1May 1, 2026
- Removedbq_analyze_query_performance
- Removedbq_analyze_query_structure
- Changedbq_list_tables1 field changed
  - changedInput schema / properties / max_results / description
```
Previous value: -"Maximum number of tables to return"New value: +"Maximum number of tables"
```
- Removedbq_query_info_schema
9 tool updatesv1.0.0Jan 3, 2026
- Addedbq_analyze_query_performance
- Addedbq_analyze_query_structure
- Addedbq_describe_table
- Addedbq_extract_dependencies
- Addedbq_get_table_info
- Addedbq_list_datasets
- Addedbq_list_tables
- Addedbq_query_info_schema
- Addedbq_validate_query_syntax
2 tool updatesAug 16, 2025
- First observedbq_dry_run_sql
- First observedbq_validate_sql

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

B3.1/5.0

Scored 2026-09-10 01:01 across 9 tools

Disambiguation2/5

Several tools have overlapping purposes: bq_validate_sql and bq_validate_query_syntax both validate syntax, while bq_describe_table and bq_get_table_info both return table metadata. Agents could easily confuse these and pick the wrong tool.

Naming Consistency4/5

Naming is mostly consistent with a clear bq_ prefix and snake_case verb_noun pattern. The main inconsistency is validate_sql versus validate_query_syntax, which are different names for the same kind of operation.

Tool Count4/5

Nine tools is a reasonable count for a BigQuery exploration and validation server, but at least two pairs are redundant. Trimming the duplicates would make the set tighter without losing any real capability.

Completeness4/5

The server covers dataset/table discovery, schemas, partitioning/clustering metadata, data previews, SQL syntax validation, dry-run cost estimation, and dependency extraction. Minor gaps exist, such as no way to list columns independently or execute queries, but these are outside the validator scope.

Maintenance

ActivitySlowing

ResponsivenessNo issues

Resources

Need Help?

Reddit Discussion

Related Servers

Related MCP Connectors

onelens-mcpOAuth
io.github.astuto-ai
Query OneLens cloud-cost data in natural language: breakdowns, trends, cost centers. Read-only.
Search Cloud Platforms Finance
2
sixta-connect AOAuth
ai.sixta
DBRE-grade SQL analysis inside any MCP client. No connection. No install. Paste a query.
Databases Code Analysis
132
mcp-server AOAuth
io.quanti
Query BigQuery, Snowflake, Redshift & Azure Synapse with natural language
Databases Search Data Platforms
2
sqlai.dev SQL Verifier A
io.github.JadeSparrow
Executes SQL in a real ephemeral database: rows, typed errors with suggestions, plans, diffs.
Databases Developer Tools
52

Related MCP Servers

mcp-bigquery-dryrun
Cloud Platforms Databases
caron14
A
license
A
quality
F
maintenance
Validates BigQuery SQL syntax and performs dry-run analysis without executing queries, providing cost estimates, referenced tables, and schema previews.
Updated a year ago (2025-08-16 06:24 UTC)
2
Apache 2.0
BigQuery MCP Server
Databases Cloud Platforms
amenke-lang
F
license
Not graded
quality
D
maintenance
Enables read-only interaction with Google BigQuery, including SQL queries, dataset/table listing, schema retrieval, table preview, and metadata access via service account authentication.
Updated 7 months ago (2026-02-25 01:39 UTC)
-
sql-review-agent
Databases Cloud Platforms Developer Tools
ARAVINDHRAJA123
F
license
Not graded
quality
C
maintenance
Enables reviewing BigQuery SQL queries for performance issues, cost estimation, and suggested rewrites via an MCP interface.
Updated 3 months ago (2026-07-05 15:43 UTC)
1
-
GCP BigQuery MCP Server
Databases Cloud Platforms
roymani06
F
license
Not graded
quality
C
maintenance
Enables secure read-only interaction with Google BigQuery through natural language, including listing datasets, listing tables, retrieving metadata, and executing queries with cost controls.
Updated 7 days ago (2026-09-19 16:37 UTC)
-

Appeared in Searches

Google BigQuery cloud data warehouse service