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
Provides tools for validating BigQuery SQL syntax and performing dry-run analysis to get cost estimates, schema previews, and metadata without executing queries
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
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.
Safe BigQuery exploration through Model Context Protocol
Documentation | Quick Start | Examples
mcp-bigquery is a Model Context Protocol (MCP) server that enables AI assistants (such as Claude) to interact securely with Google BigQuery.
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.
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: mcp-bigquery-dryrun
Install the package via pip:
pip install mcp-bigquerySet 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.jsonConfigure 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"
}
}
}
}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"
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 |
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 |
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.
Variable | Purpose | Default |
| Target GCP Project ID | Determined via ADC |
| Target BigQuery Region | Not set |
| Price per TiB for cost estimation | 5.0 |
| Logging verbosity (DEBUG, INFO, WARNING, ERROR, CRITICAL) | WARNING |
| Enable the bq_preview_table tool (true/false) | false |
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{
"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"
}
}
}
}Error: Could not automatically determine credentialsSolution: Re-authenticate using the command line:
gcloud auth application-default loginError: User does not have bigquery.tables.get permissionSolution: 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"Error: Project ID is requiredSolution: Ensure the BQ_PROJECT variable is set correctly in your configuration.
# 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# 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)# 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_resultVersion | 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 ( |
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 |
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/This project is licensed under the MIT License. See LICENSE for details.
Get table schema, metadata, and statistics
| Name | Required | Description | Default |
|---|---|---|---|
| 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 |
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.
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.
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.
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.
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.
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.
Perform a dry-run of a BigQuery SQL query to get cost estimates and metadata
| Name | Required | Description | Default |
|---|---|---|---|
| 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) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description indicates a dry-run is performed, implying no actual execution or data modification, but it does not disclose permissions needed or behavior for invalid queries. With no annotations, the description carries the full burden and is adequate but not exhaustive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, succinct sentence that conveys the core purpose without unnecessary words. It is optimally concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description lacks details about the output format and metadata provided. With no output schema, the description should explain what cost estimates and metadata are returned. It also omits behavioral context like error handling or permission requirements.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All parameters are described in the input schema with 100% coverage. The description adds no additional meaning beyond the schema, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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. The verb 'dry-run' and resource 'SQL query' are specific, and the purpose is distinct from sibling tools like bq_validate_query_syntax.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool should be used when one needs cost estimates and metadata before executing a query, but it does not explicitly state when to use it versus alternatives, nor does it provide exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Extract table and column dependencies from BigQuery SQL
| Name | Required | Description | Default |
|---|---|---|---|
| sql | Yes | The SQL query to analyze | |
| params | No | Optional query parameters (key-value pairs) |
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.
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.
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.
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.
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.
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.
Get comprehensive table information including partitioning and clustering
| Name | Required | Description | Default |
|---|---|---|---|
| table_id | Yes | The table ID | |
| dataset_id | Yes | The dataset ID | |
| project_id | No | GCP project ID (uses default if not provided) |
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.
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.
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.
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.
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.
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.
List all datasets in the BigQuery project
| Name | Required | Description | Default |
|---|---|---|---|
| project_id | No | GCP project ID (uses default if not provided) | |
| max_results | No | Maximum number of datasets to return |
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.
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.
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.
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.
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.
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.
List all tables in a BigQuery dataset with metadata
| Name | Required | Description | Default |
|---|---|---|---|
| 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) |
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.
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.
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.
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.
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.
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.
Get a preview of table data without running a query job (cost-free)
| Name | Required | Description | Default |
|---|---|---|---|
| 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) |
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.
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.
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.
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.
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.
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.
Enhanced syntax validation with detailed error reporting
| Name | Required | Description | Default |
|---|---|---|---|
| sql | Yes | The SQL query to validate | |
| params | No | Optional query parameters (key-value pairs) |
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.
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.
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.
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.
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.
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.
Validate BigQuery SQL syntax without executing the query
| Name | Required | Description | Default |
|---|---|---|---|
| sql | Yes | The SQL query to validate | |
| params | No | Optional query parameters (key-value pairs) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully convey behavior. It only states the tool validates syntax without execution, but it does not disclose what happens upon invalid syntax, permissions required, or whether it checks only syntax or also semantics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no wasted words. However, it could be slightly expanded to address sibling differentiation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of output schema and annotations, the description should explain what the tool returns (e.g., valid/invalid with errors). It also fails to distinguish from a similarly named sibling, leaving the agent potentially confused.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds no additional meaning beyond the schema's existing parameter descriptions for 'sql' and 'params'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it validates BigQuery SQL syntax without execution. However, it does not differentiate from the sibling tool 'bq_validate_query_syntax', which appears to have the same purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies it is safe to use for validation (no execution), but it provides no explicit guidance on when to use this tool versus the similar 'bq_dry_run_sql' or 'bq_validate_query_syntax'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.7.0bq_preview_tablev0.2.1bq_analyze_query_performancebq_analyze_query_structurebq_list_tables1 field changedInput schema / properties / max_results / descriptionPrevious value: -"Maximum number of tables to return"New value: +"Maximum number of tables"bq_query_info_schemav1.0.0bq_analyze_query_performancebq_analyze_query_structurebq_describe_tablebq_extract_dependenciesbq_get_table_infobq_list_datasetsbq_list_tablesbq_query_info_schemabq_validate_query_syntaxbq_dry_run_sqlbq_validate_sqlSome tools have overlapping purposes, such as bq_describe_table and bq_get_table_info both providing table metadata, and bq_validate_query_syntax and bq_validate_sql both validating SQL. While descriptions help differentiate, there is potential for agent confusion.
All tools follow the bq_verb_noun pattern with underscores. Verbs like 'list', 'validate', and 'describe' are consistent, though 'dry_run' and 'extract' differ slightly. The naming is mostly predictable.
With 8 tools, the server covers essential BigQuery validation and metadata operations without being sparse or bloated. Each tool serves a clear purpose within the domain.
The tool set covers core validation (syntax, dry-run, dependencies) and metadata exploration (datasets, tables, schemas). Minor gaps exist, such as dataset-level metadata, but overall the surface is adequate for the validator purpose.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Query OneLens cloud-cost data in natural language: breakdowns, trends, cost centers. Read-only.
DBRE-grade SQL analysis inside any MCP client. No connection. No install. Paste a query.
Query BigQuery, Snowflake, Redshift & Azure Synapse with natural language
Executes SQL in a real ephemeral database: rows, typed errors with suggestions, plans, diffs.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/caron14/mcp-bigquery'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
