MCP server

The model is available natively in Claude, ChatGPT, Cursor, and any MCP client. Your AI hands the model raw tables and databases; the model returns the data understanding, how the sources relate, what is missing, and what can be predicted from it. One remote server, nothing to install:

https://mcp.example.com/mcp

Everything on the platform and the API is available over MCP. A result is the same output bundle the API returns.

Add the server

Every client points at the same URL. Pick yours.

Claude:

Claude.ai, Claude Desktop, Cowork
Settings › Connectors › Add custom connector

Name        Tabular model
Server URL  https://mcp.example.com/mcp

Claude Code:

claude mcp add --transport http model https://mcp.example.com/mcp

ChatGPT:

ChatGPT
Settings › Connectors › Add

Server URL  https://mcp.example.com/mcp

Codex:

# ~/.codex/config.toml, then: codex mcp login model
[mcp_servers.model]
url = "https://mcp.example.com/mcp"

Cursor:

// Cursor Settings › Customize › MCP, or .cursor/mcp.json
{
  "mcpServers": {
    "model": { "url": "https://mcp.example.com/mcp" }
  }
}

VS Code:

// Command Palette › MCP: Add Server › HTTP, or .vscode/mcp.json
{
  "servers": {
    "model": { "type": "http", "url": "https://mcp.example.com/mcp" }
  }
}

Gemini CLI:

gemini mcp add --transport http model https://mcp.example.com/mcp

Any other MCP client: add a remote server with the URL above. Agent frameworks connect the same way; see Agent frameworks.

Sign in

Sign in with your your account, or use an API key instead, where your client supports it. Your client prompts for whichever it offers on first use.

Use

Everything on the platform and the API, available over MCP. Ask in your own words: run the model on a table, connect a source, create an endpoint, read a report.

Inline tables suit small inputs; registered data suits everything else.

Access

Same rules as the API.

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 and Codex sign in only.

Create keys on the platform under API, one dedicated, named key per integration, and store each one where your client keeps secrets. Never put a key in a URL, a tool argument, or a prompt. See Authentication.

Tools

Every platform and API operation is a tool. The list your AI sees depends on the credential: a sign-in covers read, run, serve, and manage; the delete tools need an API key that carries the delete scope.

What to expect:

• Long work returns a job. Runs that take a while, and every create, refresh, and upgrade, return a job id; your AI checks it with get_job.
• Destructive tools ask first. Delete, cancel, and unpin are marked destructive, so your client confirms with you before running them.
• Sources with credentials belong on the platform. Register databases and cloud sources on the Data page and refer to them by id. Use connect_data for sources that need no credentials.

Tool arguments are the API's request fields under the API's names, and a result is the API's response.

Agent frameworks

Any framework that consumes MCP servers connects to the same URL. Store the key in the framework's secret store and use a dedicated, named key per integration.

CrewAI:

import os
from crewai import Agent
from crewai_tools import MCPServerAdapter

server = {
    "url": "https://mcp.example.com/mcp",
    "transport": "streamable-http",
    "headers": {"Authorization": f"Bearer {os.environ['API_KEY']}"},
}
with MCPServerAdapter(server) as tools:
    analyst = Agent(role="data analyst", tools=tools, goal="...", backstory="...")

LangChain:

import os
from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({
    "model": {
        "url": "https://mcp.example.com/mcp",
        "transport": "streamable_http",
        "headers": {"Authorization": f"Bearer {os.environ['API_KEY']}"},
    }
})
tools = await client.get_tools()   # LangChain and LangGraph

LlamaIndex:

import os
from llama_index.tools.mcp import BasicMCPClient, McpToolSpec

client = BasicMCPClient(
    "https://mcp.example.com/mcp",
    headers={"Authorization": f"Bearer {os.environ['API_KEY']}"},
)
tools = McpToolSpec(client).to_tool_list()

To design an agent around the bundle, with your own LLM narrating results, see Agents and LLMs.

Troubleshooting

More in Troubleshooting and the error envelope. Support: support@example.com.

Next

• Agents and LLMs: Design an agent around the bundle, over MCP or REST.
• Outputs: Every field a tool result contains.
• Authentication: Scopes, keys, and what each one covers.