Schema MCP server

Schema is available natively in the AI clients you already use. The MCP server is a remote server at https://mcp.schemalabs.ai/mcp that exposes the same operations as the REST API (run, create, serve, refresh, upgrade, data, reports, jobs, usage) as tools. No download, no binary, nothing to configure beyond a credential and your data.

What the server does

Every tool wraps exactly one API route and returns the API’s response unchanged, so what a key can do over REST it can do here, and nothing else. Results arrive as structured JSON under fixed keys; the readable text of a result is a fixed sentence and a summary and never contains values from your tables. Nothing you send is stored by the server: tables pass through to the API and are not retained.

Two ways to sign in

Sign in with your Schema account. Pick “sign in” in your client. Your browser opens the Schema login (password, Google or your company’s SSO), then a consent page listing what the client will be able to do. Sign-in is available on organizations with a subscription; if yours does not have one, connect with an API key instead. You can revoke a sign-in at any time from your organization’s API keys page: it appears there like any other key.

Connect with an API key. Create a key in the platform under API keys, scoped to what the integration needs, and paste it where your client stores secrets. Keys bill prepaid usage credits from the first cell, exactly as over REST. Use one dedicated, named key per integration so you can revoke and attribute each one separately; for a pipeline that calls a single endpoint, restrict the key to that endpoint.

Which option a client offers is the client’s: Claude Code, Cursor, VS Code, Gemini CLI and the agent frameworks accept either; Claude.ai, Claude Desktop and Cowork sign in; ChatGPT signs in only. Never put a key in a URL, a tool argument or a prompt.

Quickstart

1. Connect the server in your client (setup per client below).
2. Ask for a first result with a small inline table:

Run Schema on this table and tell me what it understood:
name, plan, monthly_spend, churned
Acme, pro, 1200, no
Globex, plus, 300, yes
Initech, pro, 950, no

3. For real data, register it once and refer to it by id:

Use connect_data to register my Postgres reporting database, then run Schema on the customers and invoices tables.

Inline tables suit small inputs; registered data (ds_{id} datasets and conn_{id} connections) suits everything else. The first output bundle is the same bundle the API and the platform return.

Setup per client

Claude.ai, Claude Desktop and Cowork

Settings → Connectors → Add custom connector → URL https://mcp.schemalabs.ai/mcp → Connect, then sign in. An organization admin can also enter a static API key in the connector’s header field where the client offers it.

Claude Code

claude mcp add --transport http schema https://mcp.schemalabs.ai/mcp

Then /mcp → schema → Authenticate to sign in, or add the key: claude mcp add --transport http schema https://mcp.schemalabs.ai/mcp --header "Authorization: Bearer $SCHEMA_API_KEY".

ChatGPT

Settings → Connectors → add https://mcp.schemalabs.ai/mcp and sign in. ChatGPT accepts sign-in only.

Cursor

.cursor/mcp.json:

{ "mcpServers": { "schema": { "url": "https://mcp.schemalabs.ai/mcp" } } }

Cursor prompts you to sign in; to use a key instead add "headers": { "Authorization": "Bearer ${env:SCHEMA_API_KEY}" }.

VS Code (GitHub Copilot)

.vscode/mcp.json:

{ "servers": { "schema": { "type": "http", "url": "https://mcp.schemalabs.ai/mcp" } } }

VS Code offers sign-in; for a key use an input variable and "headers": { "Authorization": "Bearer ${input:schema-key}" }.

Gemini CLI

~/.gemini/settings.json:

{ "mcpServers": { "schema": { "httpUrl": "https://mcp.schemalabs.ai/mcp", "headers": { "Authorization": "Bearer $SCHEMA_API_KEY" } } } }

CrewAI

from crewai_tools import MCPServerAdapter
with MCPServerAdapter({"url": "https://mcp.schemalabs.ai/mcp", "transport": "streamable-http",
                       "headers": {"Authorization": f"Bearer {os.environ['SCHEMA_API_KEY']}"}}) as tools:
    agent = Agent(role="data analyst", tools=tools, ...)

LangChain / LangGraph

from langchain_mcp_adapters.client import MultiServerMCPClient
client = MultiServerMCPClient({"schema": {"url": "https://mcp.schemalabs.ai/mcp", "transport": "streamable_http",
                              "headers": {"Authorization": f"Bearer {os.environ['SCHEMA_API_KEY']}"}}})
tools = await client.get_tools()

Amazon Bedrock AgentCore

Add a Gateway target of type MCP with the server URL and an outbound authorization header carrying the key.

Snowflake agent surfaces

Register the server URL as an MCP tool source for Cortex agents; the key travels in the Authorization header.

Databricks

Install the Schema listing from Databricks Marketplace (Bearer Token authentication) and put the org API key in the Unity Catalog HTTP connection.

Replit

Integrations → custom MCP server → URL https://mcp.schemalabs.ai/mcp; store the key as a Replit secret and reference it in the Authorization header.

n8n

In an AI Agent workflow add the MCP Client node with the server URL and a header credential holding the key.

LlamaIndex

from llama_index.tools.mcp import BasicMCPClient, McpToolSpec
tools = McpToolSpec(BasicMCPClient("https://mcp.schemalabs.ai/mcp",
                    headers={"Authorization": f"Bearer {os.environ['SCHEMA_API_KEY']}"})).to_tool_list()

Tools

The tool list you see is filtered to your credential’s scopes. A sign-in carries read, run, serve and manage; the delete tools need a pasted key that carries the delete scope.

• preflight returns the exact cell count and expected seconds before any job starts, and any refusal the real call would meet. Call it when the input is large or you want to know the cost.
• run returns the output bundle inline for inputs up to 1,000,000 cells. Above that, pass out to write the bundle to a file or warehouse table, or create an endpoint.
• Calls that take longer than about 45 seconds return a job; poll get_job for the result. create, refresh and upgrade always return a job.
• delete_*, cancel_job and unpin_data are marked destructive; your client asks before running them.

Troubleshooting

• 401 from the server — the client has no credential or it expired. Sign in again, or check the key. A sign-in stops working when the key it created is revoked or when you are removed from the organization.
• 403 insufficient_scope — the credential lacks the scope named in the message. Create a key with that scope, or use a sign-in for anything except delete.
• “needs a Schema subscription” — sign-in is not available on this organization; connect with an API key.
• “no prepaid credits on this organization” — a key bills usage credits; add credits in the platform account menu or sign in to use the subscription allowance.
• 429 — a rate or size limit. The message names the limit; a per-run cap means the same size will not succeed on retry, so split the data or create an endpoint.
• Result is a job — the call exceeded the synchronous budget. Call get_job with the job id until it completes.
• ChatGPT asks for a key — ChatGPT supports sign-in only; use a client that accepts keys if you need one.

Support: support@schemalabs.ai. Privacy: schemalabs.ai/privacy. Terms: schemalabs.ai/terms.