> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tako.com/llms.txt
> Use this file to discover all available pages before exploring further.
# MCP Server
Tako runs a hosted, remote [Model Context Protocol](https://modelcontextprotocol.io) server, so any MCP-compatible client — Claude, ChatGPT, Cursor, and others — can search, answer, and fetch data from Tako without you writing any glue code. The model decides when to call Tako; the server runs the call and returns grounded, up-to-date results plus the interactive charts behind them.
There is nothing to install or host: the server is a single endpoint.
```
https://mcp.tako.com/mcp
```
It speaks **Streamable HTTP** (the current MCP remote transport).
This page covers the three data tools — `tako_search`, `tako_answer`, and `tako_contents` — which mirror Tako's [Search](/documentation/integrating-tako/guides/search), [Answer](/documentation/integrating-tako/guides/answer), and [Contents](/api-reference/contents) APIs, plus `tako_visualize` (build a chart from your own data — Tako's [Thin-Viz](/documentation/integrating-tako/guides/chart-creation) API), the deep-research `tako_agent`, and the `get_credit_balance` utility.
## Connect
Your client decides how it authenticates — you don't have to choose. **Web hosts** (Claude.ai, ChatGPT, Claude Desktop) open a **Tako sign-in window** the first time you add the connector; approve once and nothing goes in a config file. **CLI and editor** clients send a **Bearer token** in an `Authorization: Bearer tako_sk_…` header — though most of them can do the sign-in flow instead if you leave the header out.
Mint a token at [tako.com/dashboard](https://tako.com/dashboard) → **Settings → API tokens**. Tokens look like `tako_sk_…`, are shown once, and each connected client appears as its own named, revocable key.
The endpoint is the same everywhere: `https://mcp.tako.com/mcp`.
### Claude.ai
Requires a Claude Pro, Max, Team, or Enterprise plan.
1. Open **Settings → Connectors → Add custom connector**.
2. Enter `https://mcp.tako.com/mcp` and click **Add**.
3. Approve the Tako sign-in window when it opens — the Tako tools then appear. No token required.
On Team/Enterprise, a workspace owner adds the connector; members then click **Connect** to sign in individually.
### ChatGPT
Requires ChatGPT Plus, Pro, Business, Enterprise, or Edu.
**Web only.** The connector setup lives in the ChatGPT web app — Developer mode and custom connectors aren't available in the desktop or mobile apps.
1. Open **Settings → Apps** (formerly "Connectors") → **Advanced settings → Developer mode** and toggle it on.
2. Click **Create app**, give it a name, and set the **Connector URL** to `https://mcp.tako.com/mcp`.
3. Approve the Tako sign-in when prompted. No token required.
### Claude Code
Add Tako with the CLI, passing a Bearer token:
```bash theme={null}
claude mcp add --transport http tako https://mcp.tako.com/mcp \
--header "Authorization: Bearer tako_sk_YOUR_TOKEN"
```
Or connect via OAuth — omit the header, then run `/mcp` inside Claude Code and approve the Tako sign-in:
```bash theme={null}
claude mcp add --transport http tako https://mcp.tako.com/mcp
```
Verify with `claude mcp list`.
### Claude Desktop
1. Open **Settings → Connectors → Add custom connector**.
2. Enter `https://mcp.tako.com/mcp`.
3. Sign in when the Tako window opens.
Claude Desktop connects through Anthropic's cloud and does **not** accept a static Bearer token — use the OAuth sign-in here. (To run Tako locally with a token instead, see [Other](#other).)
### Cursor
[](https://cursor.com/install-mcp?name=tako\&config=eyJuYW1lIjoidGFrbyIsInR5cGUiOiJodHRwIiwidXJsIjoiaHR0cHM6Ly9tY3AudGFrby5jb20vbWNwIn0=)
The button installs Tako and starts the sign-in flow — no token needed. Or add it to `~/.cursor/mcp.json` (or a project `.cursor/mcp.json`) by hand:
```json theme={null}
{
"mcpServers": {
"tako": {
"url": "https://mcp.tako.com/mcp",
"headers": {
"Authorization": "Bearer ${env:TAKO_API_KEY}"
}
}
}
}
```
Cursor auto-detects the transport. To sign in with OAuth instead of a token, omit `headers`.
### VS Code
[](https://insiders.vscode.dev/redirect/mcp/install?name=tako\&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmcp.tako.com%2Fmcp%22%7D)
The button installs Tako and starts the sign-in flow. Or add it to `.vscode/mcp.json` by hand:
```json theme={null}
{
"servers": {
"tako": {
"type": "http",
"url": "https://mcp.tako.com/mcp",
"headers": {
"Authorization": "Bearer ${input:tako-key}"
}
}
},
"inputs": [
{ "id": "tako-key", "type": "promptString", "description": "Tako API key", "password": true }
]
}
```
The top-level key is `servers` (in user `settings.json` it nests under `"mcp"`). Omit `headers` and `inputs` to sign in with OAuth instead.
### Windsurf
Add Tako to `~/.codeium/windsurf/mcp_config.json` — note the key is `serverUrl`, not `url`:
```json theme={null}
{
"mcpServers": {
"tako": {
"serverUrl": "https://mcp.tako.com/mcp",
"headers": {
"Authorization": "Bearer ${env:TAKO_API_KEY}"
}
}
}
}
```
### Codex
Use the Codex CLI; it reads the token from an environment variable rather than storing it in the config file:
```bash theme={null}
export TAKO_API_TOKEN="tako_sk_YOUR_TOKEN"
codex mcp add tako --url https://mcp.tako.com/mcp --bearer-token-env-var TAKO_API_TOKEN
```
That writes the following to `~/.codex/config.toml`, which you can also add by hand:
```toml theme={null}
[mcp_servers.tako]
url = "https://mcp.tako.com/mcp"
bearer_token_env_var = "TAKO_API_TOKEN"
```
Or sign in via OAuth with `codex mcp login tako`.
### Gemini CLI
Add Tako with the CLI — the Streamable HTTP key is `httpUrl`:
```bash theme={null}
gemini mcp add --transport http \
--header "Authorization: Bearer tako_sk_YOUR_TOKEN" \
tako https://mcp.tako.com/mcp
```
Equivalent `~/.gemini/settings.json`:
```json theme={null}
{
"mcpServers": {
"tako": {
"httpUrl": "https://mcp.tako.com/mcp",
"headers": {
"Authorization": "Bearer tako_sk_YOUR_TOKEN"
}
}
}
}
```
### Zed
Add a context server to Zed's `settings.json` (Zed calls MCP servers "context servers"):
```json theme={null}
{
"context_servers": {
"tako": {
"url": "https://mcp.tako.com/mcp",
"headers": {
"Authorization": "Bearer tako_sk_YOUR_TOKEN"
}
}
}
}
```
Omit `headers` to sign in with OAuth instead.
### Cline
In the Cline **MCP Servers** panel, open the **Remote Servers** tab, set the URL to `https://mcp.tako.com/mcp`, and choose the **Streamable HTTP** transport. The equivalent JSON config:
```json theme={null}
{
"mcpServers": {
"tako": {
"url": "https://mcp.tako.com/mcp",
"headers": {
"Authorization": "Bearer tako_sk_YOUR_TOKEN"
}
}
}
}
```
### Roo Code
Open Roo Code's MCP settings (**Edit Global MCP**) and add Tako — the `type` must be `streamable-http`:
```json theme={null}
{
"mcpServers": {
"tako": {
"type": "streamable-http",
"url": "https://mcp.tako.com/mcp",
"headers": {
"Authorization": "Bearer tako_sk_YOUR_TOKEN"
}
}
}
}
```
### Kiro
[](https://kiro.dev/launch/mcp/add?name=tako\&config=%7B%22url%22%3A%22https%3A%2F%2Fmcp.tako.com%2Fmcp%22%7D)
The button installs Tako and starts the sign-in flow. Or add it to `~/.kiro/settings/mcp.json` (or workspace `.kiro/settings/mcp.json`) by hand:
```json theme={null}
{
"mcpServers": {
"tako": {
"url": "https://mcp.tako.com/mcp",
"headers": {
"Authorization": "Bearer tako_sk_YOUR_TOKEN"
}
}
}
}
```
Omit `headers` to sign in with OAuth instead.
### Warp
In Warp, open **Settings → Agents → MCP servers → + Add**, choose the **URL (Streamable HTTP)** option, and paste:
```json theme={null}
{
"mcpServers": {
"tako": {
"url": "https://mcp.tako.com/mcp",
"headers": {
"Authorization": "Bearer tako_sk_YOUR_TOKEN"
}
}
}
}
```
Warp also offers a one-click OAuth sign-in if you add the server by URL without a header.
### Goose
Run `goose configure` → **Add Extension → Remote Extension (Streamable HTTP)**, set the endpoint to `https://mcp.tako.com/mcp`, then add a **Custom Request Header**: `Authorization: Bearer tako_sk_YOUR_TOKEN`. The Goose desktop app has the same flow under **Extensions → Add custom extension**.
### Antigravity
In Antigravity, open the side-panel **"…" menu → Manage MCP Servers → View raw config** (the raw-config view shows the exact file path for your install), and add Tako — note the key is `serverUrl`:
```json theme={null}
{
"mcpServers": {
"tako": {
"serverUrl": "https://mcp.tako.com/mcp",
"headers": {
"Authorization": "Bearer tako_sk_YOUR_TOKEN"
}
}
}
}
```
Omit `headers` to sign in with OAuth instead.
### Other
Any client that speaks **Streamable HTTP** can use Tako: point it at `https://mcp.tako.com/mcp` and either complete the OAuth sign-in or send `Authorization: Bearer tako_sk_…`.
For clients that only support **stdio** servers, bridge to the remote endpoint with [`mcp-remote`](https://github.com/geelen/mcp-remote):
```json theme={null}
{
"mcpServers": {
"tako": {
"command": "npx",
"args": ["mcp-remote", "https://mcp.tako.com/mcp", "--header", "Authorization:${AUTH_HEADER}"],
"env": { "AUTH_HEADER": "Bearer tako_sk_YOUR_TOKEN" }
}
}
}
```
The header is supplied through an `env` var with no space after the colon — the documented workaround for an `npx` argument-escaping bug on some clients. To use OAuth instead, drop `--header`/`env` and run the bare bridge: `npx mcp-remote https://mcp.tako.com/mcp`.
## Tools
### `tako_search`
Find live data for a *specific, known* thing and get back ranked **knowledge cards** — each a structured factual answer with an interactive chart — backed by Tako's curated knowledge graph **and** the live web. On hosts that support it, the top card **renders inline automatically**; reference it in your reply and link `embed_url` so the user can open it fullscreen.
Use it for a current or latest value, a time series, a statistic, a price, a score, a schedule, a forecast, a poll, or prediction-market odds — including a direct comparison of two named entities — across sports, economics, finance, demographics, technology, weather, elections, prediction markets, web traffic, real estate, energy, and health. When the question instead needs *figuring something out* — resolving a cohort, ranking or filtering a set by criteria, or multi-step reasoning across many entities — use `tako_agent` instead.
| Parameter | Type | Default | Description |
| ------------------ | ---------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `query` | string | — (required) | Natural-language query, e.g. `"US GDP growth"` or `"Intel vs Nvidia revenue"`. |
| `count` | integer (1–20) | `10` | Maximum number of cards to return. |
| `sources` | array of `"data"` \| `"web"` | `["data","web"]` | Where to search. Defaults to **both** Tako's curated cards and the live web; pass `["data"]` for curated cards only or `["web"]` for web results only. The legacy value `tako` is accepted as a synonym for `data`. |
| `effort` | `"instant"` \| `"fast"` | (auto) | `instant` is the fastest cached path; `fast` runs the standard synchronous search. Omit to let Tako choose. |
| `include_contents` | boolean | `false` | Inline each result's underlying data in the response (a `content` object): the Tako card's CSV and any web page's text, fetched in the same call. Leave off and use `tako_contents` to fetch data on demand. |
| `country_code` | string | `"US"` | ISO country code for localized results. |
| `locale` | string | `"en-US"` | Locale for results. |
Returns `cards` (each with `card_id`, `title`, `description`, `webpage_url`, `image_url`, `embed_url`, and — when `include_contents` is set — an inline `content` object), `web_results` (`title`, `url`, `snippet`, `source_name`, with inline `content` when requested; web results are not chartable cards), `contents_total_cost` (USD for any inlined data, `0` otherwise), and `request_id`. When the top card is chartable, the response also lifts its `embed_url` and `image_url` to the root for inline rendering.
Prompt: *"How has Nvidia's revenue grown since 2015?"*
```json theme={null}
// tako_search({ "query": "Nvidia revenue since 2015" })
{
"cards": [
{
"card_id": "j60lxSe9mhx4-ni0ylTk",
"title": "NVIDIA Corporation Revenue",
"description": "Annual revenue, FY2015–FY2024…",
"webpage_url": "https://tako.com/card/j60lxSe9mhx4-ni0ylTk",
"embed_url": "https://tako.com/embed/j60lxSe9mhx4-ni0ylTk",
"image_url": "https://tako.com/api/v1/image/j60lxSe9mhx4-ni0ylTk/"
}
],
"web_results": [],
"contents_total_cost": 0,
"request_id": "req_abc123",
"embed_url": "https://tako.com/embed/j60lxSe9mhx4-ni0ylTk",
"image_url": "https://tako.com/api/v1/image/j60lxSe9mhx4-ni0ylTk/"
}
```
### `tako_answer`
Ask a factual question about a *specific, known* thing and get back a single **grounded, citation-backed text answer** (prose, not a chart), plus the backing cards and web results. Use it when the user wants a direct written answer rather than a rendered chart. When the question needs *figuring something out* — cohort resolution, ranking or filtering a set, multi-step reasoning across many entities — use `tako_agent` instead.
| Parameter | Type | Default | Description |
| ------------------ | ---------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `query` | string | — (required) | Natural-language question, e.g. `"What was US GDP in 2024?"`. |
| `sources` | array of `"data"` \| `"web"` | `["data","web"]` | Where to ground the answer. Defaults to **both** Tako's curated data and the live web; pass `["data"]` for curated data only or `["web"]` for live web only. The legacy value `tako` is accepted as a synonym for `data`. |
| `include_contents` | boolean | `false` | Inline the underlying data of each backing result (`content`): the card's CSV and any web page's text. Leave off and use `tako_contents` to fetch data on demand. |
| `country_code` | string | `"US"` | ISO country code for localized results. |
| `locale` | string | `"en-US"` | Locale for results. |
Returns `answer` (the synthesized text), `cards` (backing knowledge cards with `card_id`, `title`, `description`, `webpage_url`, `image_url`, `embed_url`, plus inline `content` when `include_contents` is set), `web_results` (`title`, `url`, `snippet`, `source_name`), `contents_total_cost` (USD for any inlined data, `0` otherwise), and a `request_id`.
Prompt: *"What is the current US unemployment rate?"*
```json theme={null}
// tako_answer({ "query": "current US unemployment rate" })
{
"answer": "The current US unemployment rate is 4.1% (latest monthly reading).",
"cards": [
{
"card_id": "j60lxSe9mhx4-ni0ylTk",
"title": "United States Unemployment Rate",
"embed_url": "https://tako.com/embed/j60lxSe9mhx4-ni0ylTk",
"webpage_url": "https://tako.com/embed/j60lxSe9mhx4-ni0ylTk"
}
],
"web_results": [],
"contents_total_cost": 0,
"request_id": "req_abc123"
}
```
`tako_search` and `tako_answer` take nearly the same inputs and differ only in what comes back: `tako_search` returns cards to render, `tako_answer` returns prose plus the backing cards. Reach for `tako_answer` when you want a written answer read back to the user, and `tako_search` when you want to display or post-process the charts.
### `tako_agent`
Tako's **deep research agent** — for questions that require *figuring something out* rather than retrieving a known value: resolving a cohort ("which companies match…"), ranking or filtering a set by criteria, multi-step aggregation, or multi-hop reasoning across many entities that a single `tako_search` / `tako_answer` can't satisfy. It researches across Tako and the web and returns a synthesized `answer` plus the supporting chart `cards` and `web_results`. Runs server-side (typically \~30–90s).
| Parameter | Type | Default | Description |
| ----------- | ---------------------------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `query` | string | — (required) | The analytical question to work through, e.g. `"Which of the largest US semiconductor companies grew revenue fastest since 2015?"`. |
| `sources` | array of `"data"` \| `"web"` | `["data","web"]` | Where the agent researches. Defaults to **both**; pass `["data"]` for curated data only or `["web"]` for the live web only. The legacy value `tako` is accepted as a synonym for `data`. |
| `thread_id` | string | — | A `thread_id` from a prior run, to ask a follow-up in the same conversation. Omit to start a new thread. |
Returns an agent run: `run_id`, `thread_id`, `status` (`queued` → `running` → `completed` / `failed`), and on completion a `result` carrying the synthesized `answer`, the backing `cards`, `web_results`, and a `request_id`.
On **ChatGPT** the agent is split into two tools — `tako_agent_start` (dispatch; returns a `run_id`) and `tako_agent_wait` (poll until done) — because the single-call path can't survive that host's tool-call timeout. Every other host exposes a single `tako_agent` tool that dispatches and waits in one call.
See the [Agent guide](/documentation/integrating-tako/guides/agent) for the dispatch / poll / stream flow over the HTTP API.
### `tako_contents`
Fetch the content **behind a result you already have**, given that result's URL. A Tako card URL resolves to a CSV of the card's underlying dataset; any other URL resolves to the page's extracted full text. One URL per call. Use it after a `tako_search` / `tako_answer` result when the user wants the raw data or text — the input is a result URL, not a search query. `mode` controls delivery: `inline` (the default) returns the data in the response so the model can read it; `url` returns a presigned download link instead.
| Parameter | Type | Default | Description |
| --------- | --------------------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `url` | string | — (required) | The result URL to fetch — a Tako card's `webpage_url`/`embed_url` (→ CSV) or a web result's `url` (→ page text). |
| `mode` | `"inline"` \| `"url"` | `"inline"` | `inline` returns the content in the response (`data`) so the model can read it — CSV is capped at 1000 rows (`total_rows` / `truncated` flag the cap); `url` returns a short-lived `download_url` (no row cap), for handing the user a file or for large datasets you don't need to read. |
Returns `format` (e.g. `csv` or `text`), the `source_url`, and `cost` (USD for the fetch — Tako-card CSV is free; web text is metered). In `inline` mode it also returns `data` (the content, with `total_rows` / `truncated` describing CSV truncation) and leaves `download_url` / `expires_at` null. In `url` mode it returns a short-lived `download_url` + `expires_at` and leaves `data` null.
Prompt: *"Get the data behind that Nvidia chart."*
```json theme={null}
// tako_contents({ "url": "https://tako.com/embed/j60lxSe9mhx4-ni0ylTk" }) // mode defaults to "inline"
{
"format": "csv",
"data": "fiscal_year,revenue_usd_b\n2015,5.0\n2016,6.9\n…\n2024,60.9",
"total_rows": 10,
"truncated": false,
"download_url": null,
"expires_at": null,
"source_url": "https://tako.com/embed/j60lxSe9mhx4-ni0ylTk",
"cost": 0
}
```
### `tako_visualize`
Build a brand-new interactive Tako chart from your own data — the **Thin-Viz** chart-creation tool (it posts to Tako's [Thin-Viz](/documentation/integrating-tako/guides/chart-creation) `create` endpoint). This is the only **write** tool on the server: it mints a publicly hostable chart and returns its URLs. Pass an array of component configs (optionally a `header`, plus one or more visualization components); Tako renders, hosts, and returns the card. Auto-renders inline when the host supports it.
| Parameter | Type | Default | Description |
| ---------------------- | ---------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `components` | array of objects | — (required) | One or more component configs. Each has a `component_type` (e.g. `"header"`, `"generic_timeseries"`, `"categorical_bar"`, `"choropleth"`, `"pie"`, `"scatter"`, `"treemap"` — 15+ types), an optional `component_variant`, and a `config` object whose shape depends on the component type. |
| `title` | string | header title | Card title. Falls back to the header component's title if omitted. |
| `description` | string | — | Optional card description. |
| `source` | string | — | Optional data-source attribution shown in the card footer (e.g. `"Yahoo Finance"`, `"Company Reports"`). |
| `height` | integer | — | Optional chart height in pixels (100–2000); overrides the default aspect-ratio height. |
| `normalize_currencies` | string | — | Optional target ISO 4217 currency code (e.g. `"USD"`) to convert currency-denominated datasets. |
Returns `card_id`, `title`, `description`, `webpage_url`, `embed_url`, and `image_url` for the new card. On hosts that support MCP Apps the card auto-renders inline; otherwise share the returned `embed_url` (or `webpage_url`).
See [Visualize Your Data](/documentation/integrations/agent-skills/visualize-your-data) for an agent-ready setup.
Prompt: *"Chart sales by region: North America 500, Europe 300 (USD)."*
```json theme={null}
// tako_visualize({
// "title": "Sales by Region",
// "components": [
// { "component_type": "categorical_bar",
// "config": { "datasets": [{ "label": "Sales", "units": "USD",
// "data": [{ "x": "North America", "y": 500 }, { "x": "Europe", "y": 300 }] }] } }
// ]
// })
{
"card_id": "k71pYf3aZ2qb-rs9wmUv",
"title": "Sales by Region",
"description": null,
"webpage_url": "https://tako.com/charts/k71pYf3aZ2qb-rs9wmUv",
"embed_url": "https://tako.com/embed/k71pYf3aZ2qb-rs9wmUv",
"image_url": "https://tako.com/api/v1/image/k71pYf3aZ2qb-rs9wmUv/"
}
```
### `get_credit_balance`
Return the current account's remaining Tako credits (plus subscription metadata). Call it **only when the user explicitly asks** about their balance, credits, or subscription — Tako's other tools surface their own cost in each response, so a pre-flight balance check before another call is redundant and noisy. Takes no parameters.
Returns `details`, an object carrying `credit_balance` (the remaining balance, a number) and `formatted_credit_balance` (a display string), plus any additional subscription / usage fields.
Prompt: *"How many Tako credits do I have left?"*
```json theme={null}
// get_credit_balance({})
{
"details": {
"credit_balance": 4.85,
"formatted_credit_balance": "$4.85"
}
}
```
## Troubleshooting
The OAuth flow needs your Tako account to have at least one API token. Mint one at [tako.com/dashboard](https://tako.com/dashboard) → **Settings → API tokens**, then retry the connection.
Confirm your client supports the **Streamable HTTP** transport and is pointed at `https://mcp.tako.com/mcp` (not a `.../sse` path). For header-based clients, make sure the `Authorization: Bearer tako_sk_…` header is set and the token hasn't been revoked.