Trino MCP Server

Implements the Model Context Protocol (MCP) specification to expose Trino SQL query execution as a discoverable, schema-validated tool that LLM clients can invoke. The server translates MCP tool calls into Trino JDBC connections, executes parameterized SQL queries, and returns structured result sets with type information. This enables AI assistants to execute complex analytical queries against distributed data sources without embedding Trino-specific knowledge.

Provides four MCP tools (list_catalogs, list_schemas, list_tables, get_table_schema) that query Trino's system catalog to enumerate available data sources, their hierarchical structure, and column-level metadata including types and nullability. The server caches catalog structure in memory and refreshes on demand, enabling LLMs to explore multi-petabyte data warehouses without loading full schema into context.

Enforces configurable query execution timeouts and allows clients to cancel long-running queries via MCP cancellation requests. When a timeout or cancellation occurs, the server gracefully closes the Trino connection and releases resources, preventing resource leaks. Timeout errors are reported to the client with clear messages indicating the timeout duration.

Captures errors from Trino query execution and translates them into clear, actionable error messages that are returned to the MCP client. Trino-specific error codes (e.g., SYNTAX_ERROR, PERMISSION_DENIED) are preserved and included in error responses, enabling LLM clients to understand and potentially recover from errors. Stack traces are logged server-side but not exposed to clients to avoid information leakage.

Implements both STDIO (standard input/output) and HTTP/Server-Sent Events (SSE) transport protocols for MCP communication, allowing flexible deployment across different client architectures. STDIO transport is used by desktop clients (Claude Desktop, Cursor) via subprocess invocation, while HTTP/SSE enables remote server deployments and web-based integrations. The server automatically detects transport mode at startup and routes requests accordingly.

Enforces read-only SQL execution by default, parsing incoming queries to detect and block INSERT, UPDATE, DELETE, DROP, and ALTER statements before transmission to Trino. Administrators can configure granular permissions (e.g., allow specific schemas, deny certain tables) via configuration files. The server validates query intent against the permission policy and returns clear error messages for blocked operations, preventing accidental or malicious data modifications through LLM-driven queries.

Provides pre-built binaries for macOS (Intel/ARM), Linux (x86_64/ARM64), and Windows (x86_64), plus Docker image distribution via GitHub Container Registry and Homebrew package for macOS/Linux. This eliminates the need to compile from source for most users and enables one-command installation and updates. The Docker image includes Trino JDBC driver and all dependencies, simplifying containerized deployments.

Implements the Model Context Protocol (MCP) specification to ensure compatibility with multiple AI assistant platforms (Claude Desktop, Cursor, Windsurf, ChatWise) without platform-specific code. The server exposes tools via MCP's standardized tool discovery mechanism, allowing any MCP-compatible client to discover and invoke Trino query capabilities. This abstraction layer decouples the MCP server from client implementation details.

Accepts SQL queries with parameter placeholders (e.g., ? or $1 syntax) and binds user-provided values using Trino's native parameterized query API, preventing SQL injection attacks. The server validates parameter types against the query's expected input types and returns clear error messages for type mismatches. This enables LLMs to construct queries dynamically while maintaining security and correctness.

Loads server configuration (Trino connection details, transport settings, permission policies) from YAML/JSON files or environment variables, enabling flexible deployment across development, staging, and production environments without code changes. Configuration is validated at startup and errors are reported clearly, preventing silent misconfigurations. Environment variables override file-based settings, allowing containerized deployments to inject secrets and connection details.

Manages a pool of Trino JDBC connections with configurable pool size, connection timeout, and idle timeout settings. The server reuses connections across multiple queries to reduce connection overhead, and automatically closes idle connections to free resources. Connection pool metrics (active connections, queued requests) are available for monitoring and debugging.

Streams query results from Trino in batches rather than loading the entire result set into memory, enabling efficient handling of large result sets without memory exhaustion. Batch size and memory limits are configurable, allowing tuning for different deployment environments. Results are streamed to the MCP client as they become available, reducing latency for queries that return large datasets.