# MCP server

Use the model from your AI. One remote server for Claude, ChatGPT, Cursor, VS Code, Gemini CLI, and any MCP client. Sign in or use an API key. Everything on the platform and the API, with the same output bundle.

> Informational documentation, based on the paper Data Language Models: A New Foundation Model Class for Tabular Data (arXiv:2605.06290, https://arxiv.org/abs/2605.06290). Reference material, not a hosted service; hosts, keys, and ids are placeholders.

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:

```text
https://mcp.example.com/mcp
```

Everything on the platform and the API is available over MCP. A result is the same [output bundle](/model/outputs) the API returns.

## Add the server

Every client points at the same URL. Pick yours.

Claude:

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

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

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

```text
ChatGPT
Settings › Connectors › Add

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

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

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

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

```bash
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.

| Rule | What it means |
|---|---|
| **Two ways in** | Sign in with your your account, or choose from your API keys. Both are managed and revocable from the platform. |
| **Nothing extra to grant** | What your account can do on the platform, it can do here. An API key does what its scopes allow, over MCP exactly as over REST. |
| **Your data, handled as before** | The Data Processing Agreement and Security controls apply unchanged. |

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](/model/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.

| Scope | Tools |
| --- | --- |
| `read` | `list_models`, `list_endpoints`, `get_endpoint`, `get_endpoint_logs`, `list_data`, `get_data`, `list_reports`, `get_report`, `list_jobs`, `get_job`, `get_usage` |
| `run` | `preflight`, `run` |
| `serve` | `serve` |
| `manage` | `create`, `refresh`, `upgrade`, `connect_data`, `sync_data`, `pin_data`, `unpin_data`, `generate_data`, `cancel_job` |
| `delete` | `delete_endpoint`, `delete_data`, `delete_report` |

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:

```python
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:

```python
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:

```python
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()
```

| Platform | Where the URL goes |
|---|---|
| GitHub Copilot | VS Code, see Add the server |
| Amazon Bedrock AgentCore | A Gateway target of type MCP, with the key in the outbound authorization header |
| Snowflake Cortex agents | An MCP tool source, with the key in the Authorization header |
| Databricks | The listing on Databricks Marketplace, Bearer Token authentication, key in the Unity Catalog HTTP connection |
| Replit | Integrations › custom MCP server, with the key stored as a Replit secret |
| n8n | The MCP Client node in an AI Agent workflow, with a header credential holding the key |

To design an agent around the bundle, with your own LLM narrating results, see [Agents and LLMs](/model/integrations/agents).

## Troubleshooting

| You see | What it means |
|---|---|
| `401` | The client has no credential, or it expired or was revoked. Sign in again, or check the key. |
| `403 insufficient_scope` | The credential lacks the scope named in the message. Use a key with that scope, or a sign-in for anything except delete. |
| `429` | A rate or size limit; the message names it. A per-run cap means the same input will not succeed on retry: split the data or create an endpoint. |
| A job instead of a result | The call took longer than a synchronous call allows. Ask for the result of that job id, or call `get_job`. |
| ChatGPT or Codex asks for a key | ChatGPT and Codex support sign-in only. Use a client that accepts keys if you need one. |

More in [Troubleshooting](/model/troubleshooting) and the error envelope. Support: support@example.com.

## Next

- [Agents and LLMs](/model/integrations/agents): Design an agent around the bundle, over MCP or REST.
- [Outputs](/model/outputs): Every field a tool result contains.
- [Authentication](/model/authentication): Scopes, keys, and what each one covers.