The BlazeSQL MCP Server allows MCP-compatible clients to interact with BlazeSQL databases using natural language queries.
Execute Natural Language Queries: Translate natural language requests into SQL queries and execute them against a specified BlazeSQL database.
Retrieve Structured Results: Receive the agent's natural language explanation, the generated SQL query, and the query results in JSON format.
Use MCP Tool: Interact with BlazeSQL via the blazesql_query tool by providing a database ID (db_id) and a natural language request.
Secure Communication: Uses standard MCP stdio transport for seamless integration with clients like MCP Inspector and Cursor.
Robust Validation: Ensures correct usage through input parameter validation with zod and secure API key handling.
Handles API key authentication securely via environment variables for connecting to the BlazeSQL service.
Provides integration with BlazeSQL Natural Language Query API, allowing users to query databases using natural language requests and receive SQL queries and formatted results.
Used to implement the MCP server that connects to BlazeSQL's API, enabling natural language database querying capabilities.
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., "@BlazeSQL MCP Server show me the top 5 customers by total purchase amount"
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.
blaze-sql-server is a secure-by-default MCP server and CLI for the BlazeSQL natural-language query API.
It supports two modes:
serve: run as an MCP stdio server for Cursor, Claude Desktop, Codex, and other MCP clients
query: execute a single BlazeSQL request directly from the shell
MCP tool: exposes blazesql_query
CLI commands: serve, query, doctor, help, version
Security defaults: HTTPS-only remote endpoints, bounded timeouts, redacted logging, capped formatted output
Validation: runtime config validation plus BlazeSQL response-shape validation
Tooling: pnpm, CI, automated tests, and project-level mcporter config
Related MCP server: MySQL MCP Server
Node.js >=20.11.0
pnpm >=10
A BlazeSQL API key
pnpm install
cp .env.sample .envSet at least:
BLAZE_API_KEY=YOUR_API_KEY_HEREOptional environment variables:
BLAZE_API_ENDPOINT
BLAZE_REQUEST_TIMEOUT_MS
BLAZE_MAX_RESPONSE_CHARS
BLAZE_LOG_LEVEL
BLAZE_ALLOW_INSECURE_ENDPOINT
pnpm buildFor backward compatibility, running the binary with no arguments starts the stdio server:
node build/index.jsExplicitly:
node build/index.js serveThe exposed MCP tool is:
blazesql_query
db_id: BlazeSQL database ID
natural_language_request: the prompt to send to BlazeSQL
MCPorter can discover this server automatically via the project-level config at config/mcporter.json.
From the project root:
npx mcporter list
npx mcporter call blazesql.blazesql_query db_id:"your_db_id" natural_language_request:"show me total users"Ad hoc usage from anywhere:
npx mcporter call --stdio "node /path/to/blaze-sql-mcp-server/build/index.js" --name blazesql blazesql.blazesql_query db_id:"your_db_id" natural_language_request:"total sales last month"Print help:
node build/index.js --helpRun a direct query:
node build/index.js query --db-id db_demo --request "show me total users by city"Use positional arguments:
node build/index.js query db_demo "show me total users by city"Read the request from stdin:
printf 'show me total users by city\n' | node build/index.js query db_demo --stdinAvailable output formats:
node build/index.js query db_demo "show me total users by city" --format markdown
node build/index.js query db_demo "show me total users by city" --format text
node build/index.js query db_demo "show me total users by city" --format jsonCheck runtime configuration:
node build/index.js doctor
node build/index.js doctor --jsondoctor is safe to run in shared terminals: it never prints the raw API key.
pnpm typecheck
pnpm test
pnpm checkExample stdio command:
/absolute/path/to/node /absolute/path/to/blaze-sql-mcp-server/build/index.jsBecause the binary defaults to serve, MCP clients do not need an extra subcommand.
The CLI shape intentionally follows the same single-purpose command pattern popularized by tools like mcporter: a predictable command surface, direct shell usage, and one obvious machine-readable mode where it matters.
Executes a natural language query against a specified BlazeSQL database.
| Name | Required | Description | Default |
|---|---|---|---|
| db_id | Yes | The ID of the BlazeSQL database connection to query. | |
| natural_language_request | Yes | The query expressed in natural language (e.g., 'show me total users per city'). |
| Name | Required | Description |
|---|---|---|
| query | Yes | The SQL query generated and executed by BlazeSQL. |
| data_result | Yes | The structured data returned by the query, as a map of column names to value arrays. |
| agent_response | Yes | Natural language explanation of the results from BlazeSQL. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool executes queries but doesn't describe traits like error handling, performance implications, authentication needs, or rate limits. For a query execution tool with zero annotation coverage, this is a significant gap in transparency.
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, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and appropriately sized, making it easy to understand quickly. Every part of the sentence contributes to clarifying the tool's function.
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 tool has an output schema (which handles return values), 100% schema coverage, and no annotations, the description is minimally complete. It covers the basic purpose but lacks behavioral context and usage guidelines. For a query tool with no annotations, it should do more to compensate, but the output schema mitigates some gaps.
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?
The schema description coverage is 100%, so the schema already documents both parameters (db_id and natural_language_request) with clear descriptions. The description adds no additional meaning beyond what the schema provides, such as examples or constraints. Baseline 3 is appropriate when the schema does the heavy lifting.
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's purpose with a specific verb ('executes') and resource ('natural language query against a specified BlazeSQL database'). It distinguishes what it does (execute natural language queries) from potential alternatives (like SQL queries), though without sibling tools, differentiation isn't needed. However, it could be more specific about the type of queries or results.
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, prerequisites, or exclusions. It mentions the tool's function but lacks context on appropriate scenarios, such as when natural language queries are supported or if there are limitations. With no sibling tools, this gap is less critical but still present.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
With only one tool, there is no possibility of ambiguity or overlap between tools. The single tool has a clearly defined purpose that cannot be confused with any other tool in the set.
A single tool inherently has perfect naming consistency as there are no other tools to compare it against. The tool name follows a clear verb_noun pattern (blazesql_query) which would be consistent if more tools existed.
A single tool is generally too few for a database query server, as it lacks basic operations like listing databases, describing schemas, or managing connections. This minimal set limits functionality and forces all interactions through one interface.
The tool surface is severely incomplete for a SQL database server. While the query tool covers execution, there are obvious gaps such as no tools for schema exploration, database listing, transaction management, or data manipulation beyond queries, which will cause agent failures in many workflows.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
A Model Context Protocol server for Wix AI tools
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
GibsonAI MCP server: manage your databases with natural language
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/arjshiv/blaze-sql-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
