> ## 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. # Tako MCP Server > Live web search plus licensed data the open web doesn't have — finance, economics, web traffic, sports and more — in one MCP call for Claude, ChatGPT, Cursor, or any MCP client. export const ContentsExportLimits = () => <>Export requires the card to be marked exportable: true in the tako_search result. Cards from license-protected sources — S&P Global, FactSet, Visible Alpha, CoinMarketCap — come back non-exportable. That's a licensing boundary, not an error, so retrying doesn't help: read the figure from the card's description, which carries the latest value and its range, and cite the chart. Cards from open sources such as FRED, OECD, BIS, and Fiscal.ai export normally. Web URLs are always fetchable.; export const CoverageDomains = () => <>The graph covers finance and markets, company KPIs, economics, website and app traffic, sports, weather, elections, prediction markets, demographics, energy, real estate, health, and more.; Tako's [Model Context Protocol](https://modelcontextprotocol.io) server searches the live web and a proprietary graph of licensed, continuously updated data in the same call. Ask for a figure with context and one search returns both — cited, and with the chart behind the number. Web search reaches whatever the graph doesn't, so one tool call stands in for two. There's nothing to install or host. Point your client at one endpoint: ``` https://mcp.tako.com/mcp ``` It speaks **Streamable HTTP**, the current MCP remote transport. `tako_search` answers before you sign in, on a lower rate limit. ## Connect Every configuration here works as written, with no credentials. Sign in to run every tool on your own limits. Your client opens a Tako sign-in window the first time it connects, and approving it mints an API key for you, so there's nothing to copy. CLI and editor clients also take an API key, from [tako.com/console/api-keys](https://tako.com/console/api-keys) — in most config files that's one more block beside the URL: ```json theme={null} "headers": { "Authorization": "Bearer tako_sk_YOUR_KEY" } ``` Chat hosts — ChatGPT, Claude.ai, and Claude Desktop — connect through their vendor's cloud, so they only take the sign-in. ### One-click install Each button adds the server and starts the Tako sign-in. ### Claude Code The plugin installs the tools plus Tako's bundled [research skills](/documentation/integrations/agent-skills/financial-research) in two commands: ```bash theme={null} claude plugin marketplace add TakoData/tako-mcp claude plugin install tako@tako ``` To sign in, run `/mcp`, select **tako**, then choose **Authenticate**. For the tools without the skills, add the server directly: ```bash theme={null} claude mcp add --transport http tako https://mcp.tako.com/mcp ``` Verify with `claude mcp list`. Keep one Tako connection active — the plugin and a manual entry each register the full tool set, so together they give you two copies of every tool. ### Codex **Install Tako from the OpenAI plugin directory.** One install adds Tako's tools and skills, and the same listing covers ChatGPT. The listing uses Tako's ChatGPT surface, which asks you to sign in. See [ChatGPT & Codex](/documentation/integrations/chatgpt). To add the server by hand instead: ```bash theme={null} codex mcp add tako --url https://mcp.tako.com/mcp ``` Sign in with `codex mcp login tako`. Codex can also read an API key from the environment rather than storing it in the config file: ```bash theme={null} export TAKO_API_TOKEN="tako_sk_YOUR_KEY" codex mcp add tako --url https://mcp.tako.com/mcp --bearer-token-env-var TAKO_API_TOKEN ``` Either command writes `~/.codex/config.toml`, which you can also edit by hand: ```toml theme={null} [mcp_servers.tako] url = "https://mcp.tako.com/mcp" bearer_token_env_var = "TAKO_API_TOKEN" ``` In the Codex app, open **Settings → Plugins → Add MCP server** and paste the endpoint URL instead. ### ChatGPT **Install Tako from the OpenAI plugin directory.** One install adds Tako's tools and skills. It works on every ChatGPT plan, including the free tier, and doesn't require Developer mode. The listing uses Tako's ChatGPT surface, which asks you to sign in. See [ChatGPT & Codex](/documentation/integrations/chatgpt). To add Tako as a custom connector instead: *Requires a ChatGPT Pro, Business, or Enterprise plan with Developer mode enabled.* Turn on **Developer mode** in ChatGPT's settings. Then in **Plugins**, click **+**, name the plugin, and set the **Connector URL**: ``` https://mcp.tako.com/mcp ``` That's Tako's generic endpoint: four tools, with charts as static images. The ChatGPT-specific surface `https://mcp.tako.com/mcp/chatgpt` adds `tako_visualize` and an interactive chart widget, and accepts only the OAuth sign-in, not an API key. In the ChatGPT app, open **Settings → Plugins → Add MCP server** and paste the same URL. ### Claude Desktop *Requires a Claude Pro, Max, Team, or Enterprise plan. Claude.ai takes the same steps.* Open **Settings → Connectors → Add custom connector** and paste the endpoint: ``` https://mcp.tako.com/mcp ``` Sign in when the Tako window opens. Claude Desktop and Claude.ai connect through Anthropic's cloud, so neither accepts an `Authorization` header — to use an API key, bridge the endpoint with `mcp-remote` from **Other clients**. ### Cursor The button adds the server and starts the Tako sign-in. Or add `~/.cursor/mcp.json` (or a project `.cursor/mcp.json`) by hand: ```json theme={null} { "mcpServers": { "tako": { "url": "https://mcp.tako.com/mcp" } } } ``` Cursor detects the transport. ### VS Code The button adds the server and starts the Tako sign-in. Or add `.vscode/mcp.json` by hand: ```json theme={null} { "servers": { "tako": { "type": "http", "url": "https://mcp.tako.com/mcp" } } } ``` The top-level key is `servers`; in user `settings.json` it nests under `"mcp"`. VS Code prompts for the sign-in when you authenticate. An API key goes through a prompted input rather than a plain header: ```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 } ] } ``` ### Other clients Add Tako to `~/.codeium/windsurf/mcp_config.json`. The key is `serverUrl`, not `url`: ```json theme={null} { "mcpServers": { "tako": { "serverUrl": "https://mcp.tako.com/mcp" } } } ``` The extension installs the tools, Tako's bundled research skills, and the `/data`, `/chart`, and `/coverage` commands: ```bash theme={null} gemini extensions install https://github.com/TakoData/tako-mcp ``` Sign in with `/mcp auth tako`. For the tools alone, add the server instead — the Streamable HTTP key is `httpUrl`: ```bash theme={null} gemini mcp add --transport http tako https://mcp.tako.com/mcp ``` ```json theme={null} { "mcpServers": { "tako": { "httpUrl": "https://mcp.tako.com/mcp" } } } ``` Fill an `Authorization` header completely or leave it out. Gemini substitutes an unset `${VAR}` literally, and rejects the malformed header rather than ignoring it, so a half-filled key breaks a connection that no key at all would have made. Zed calls MCP servers "context servers". Add one to Zed's `settings.json`: ```json theme={null} { "context_servers": { "tako": { "url": "https://mcp.tako.com/mcp" } } } ``` 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 config: ```json theme={null} { "mcpServers": { "tako": { "url": "https://mcp.tako.com/mcp" } } } ``` 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" } } } ``` The button adds the server and starts the Tako sign-in. Or add `~/.kiro/settings/mcp.json` (or workspace `.kiro/settings/mcp.json`) by hand: ```json theme={null} { "mcpServers": { "tako": { "url": "https://mcp.tako.com/mcp" } } } ``` 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" } } } ``` Run `goose configure` → **Add Extension → Remote Extension (Streamable HTTP)** and set the endpoint to `https://mcp.tako.com/mcp`. The desktop app has the same flow under **Extensions → Add custom extension**. Goose takes an API key as a **Custom Request Header**: `Authorization: Bearer tako_sk_YOUR_KEY`. In Antigravity, open the side-panel **"…" menu → Manage MCP Servers → View raw config**, which names the config file path for your install. Add Tako, where the key is `serverUrl`: ```json theme={null} { "mcpServers": { "tako": { "serverUrl": "https://mcp.tako.com/mcp" } } } ``` Add Tako to `opencode.json`: ```json theme={null} { "mcp": { "tako": { "type": "remote", "url": "https://mcp.tako.com/mcp", "enabled": true } } } ``` Any client that speaks **Streamable HTTP** can use Tako. Point it at `https://mcp.tako.com/mcp`. A client that supports only **stdio** servers reaches the endpoint through the [`mcp-remote`](https://github.com/geelen/mcp-remote) bridge: ```json theme={null} { "mcpServers": { "tako": { "command": "npx", "args": ["-y", "mcp-remote", "https://mcp.tako.com/mcp"] } } } ``` To authenticate with an API key, pass the header through an `env` var with no space after the colon. That's the documented workaround for an `npx` argument-escaping bug: ```json theme={null} { "mcpServers": { "tako": { "command": "npx", "args": ["-y", "mcp-remote", "https://mcp.tako.com/mcp", "--header", "Authorization:${AUTH_HEADER}"], "env": { "AUTH_HEADER": "Bearer tako_sk_YOUR_KEY" } } } } ``` TakoData/tako-mcp tako/tako ## Try it Once the tools appear, ask your agent something Tako's data answers directly. Say "use Tako" in your first message to guarantee the agent calls the tool. * *"Use Tako — what was Nvidia's most recent quarterly revenue?"* — one `tako_search` call returns the figure in the top card's headline, with its source and the chart behind it. * *"Use Tako to compare US CPI, core CPI, and PCE inflation."* — the agent fans out narrow `tako_search` calls, one per metric, and synthesizes them. * *"What data does Tako have on Costco?"* — once you're signed in, `tako_available_data` lists the coverage and surfaces name ambiguity, and is never charged. * *"How much traffic does stripe.com get?"* — SimilarWeb web and app traffic, one of the graph's twelve domains. If the answer comes back with a chart and a source line, you're connected. ## Tools On `https://mcp.tako.com/mcp`, the listing is the same four tools whether or not you sign in; only `?tools=` changes it. What sign-in changes is what runs: `tako_search` answers on a lower rate limit, and the other three reply with sign-in instructions in place of a result. | Tool | Without sign-in | What it does | | - | - | - | | `tako_search` | Runs | The entry point for a data question. Searches Tako's data graph and the live web in one call, and returns ranked **knowledge cards** — each with a headline value that's often the answer itself, graph node ids, and an interactive chart — plus web results. The top card renders inline on hosts that support it. Four parameters: `query`, `sources`, `country_code`, `locale`. Retrieval is best with narrow queries (one entity + one metric, e.g. `"Nvidia revenue"`) fanned out in parallel. | | `tako_available_data` | Asks you to sign in | **Never charged.** Discovers what proprietary, continuously updated data exists for an entity or metric, and returns the **canonical name to search on** — search matches the graph's names, not your phrasing. Also returns node ids for graph traversal and, when the target is unambiguous, a ready-to-run `next_call`. | | `tako_contents` | Asks you to sign in | Fetches what's behind results the model already has, **up to 10 urls per call**: a card's data rows, or a web page's extracted text (pass `query` to get back only the matching passages). Rows bill per 1,000 delivered, up to 2,000 per card — set `max_rows` when the recent rows are enough. Cards must be marked `exportable: true`. | | `tako_graph_related` | Asks you to sign in | **Never charged.** Explores what a graph node connects to: its metrics, the entities a metric covers, competitors, industry, index membership, and sources. Pass a `node_id` alone for the map of every relation group, or add `relation` to page one group. | Every tool answers on two channels at once: structured content for code to read, and a rendered markdown summary for the model. Both carry the same fields, so a host that surfaces only one loses nothing. On connect, the server also advertises [MCP server instructions](https://modelcontextprotocol.io/specification/2025-06-18/basic/lifecycle#initialization) that hosts like Claude and Claude Code place in the model's system prompt. They steer data and metric questions to Tako ahead of the host's built-in web search, and note that Tako covers the live web too — so one call can stand in for a separate web search on mixed questions. The host's own web search stays the fallback for anything outside Tako's coverage. **Opt-in tools** Three heavier tools are off by default to keep the tool surface small. Select them with `?tools=` on the connection URL: ``` https://mcp.tako.com/mcp?tools=search,available_data,contents,graph_related,agent ``` **`?tools=` is an allowlist that replaces the default listing, not an addition to it.** `?tools=agent` lists `tako_agent` and nothing else. Name every tool you rely on, defaults included. Each value is a tool name, with the `tako_` prefix optional. An unrecognized value is dropped, and a `?tools=` that names nothing recognizable falls back to the defaults, so a typo never leaves the connection with no tools — but it does drop the tool it misspells. Opt-in tools all need a signed-in connection. | Tool name | Enables | What it's for | | - | - | - | | `search_advanced` | `tako_search_advanced` | One synthesized, citation-backed [answer](/documentation/integrating-tako/answer/overview) with `include_answer: true`, or a call `tako_search` can't express: per-source counts, inline card rows, graph pins, web domain and category filters, and `effort: deep`. It takes the [v3 search](/api-reference/search-v3) body with `sources` split into separate `data` and `web` blocks, plus `include_answer` and `output_schema` (fills a JSON Schema from the same evidence), neither of which the search body carries. `data.include_contents` inlines each card's rows and bills per card — cap it with `data.max_rows`. Returns the same payload as `tako_search`, minus the inline chart render — `embed_url` is still there to click through. | | `agent` | `tako_agent` | Tako's deep-research **Answer Agent** (\~30–90s) for questions that need figuring out — cohorts, rankings, multi-step reasoning. Returns a written answer with numbered citations, the chart cards it built, and a `thread_id` to pass back for a follow-up. See the [Agent guide](/documentation/integrating-tako/agent/overview). | | `visualize` | `tako_visualize` | Publishes an embeddable Tako chart from your own data — the [Thin-Viz](/documentation/integrating-tako/chart-creation/overview) API as a tool. The card is **public and permanent**, readable by anyone with the link, so confirm with the user before calling and never send sensitive data. | MCP is the **simplest** way to give an agent Tako — one endpoint, zero glue code — but it trades control for convenience: connection-level auth and a fixed tool surface. For production integrations that need typed SDKs, streaming, retries, and fine-grained request control, call the [API directly](/documentation/getting-started/quickstart) or follow an integration guide ([OpenAI Responses](/documentation/integrations/openai-responses-api), [Anthropic tool calling](/documentation/integrations/anthropic-tool-calling), [Vercel AI SDK](/documentation/integrations/vercel-ai-sdk)). ## Build Tako into your agent Building your own agent rather than connecting a client? Hand your coding agent the **integration prompt** at the top of the [Quickstart](/documentation/getting-started/quickstart#add-tako-to-your-agent). It reads the docs, asks the right questions, and wires Tako in the best way for your stack (this MCP server or the direct API, whichever fits). ## Troubleshooting Confirm your client supports the **Streamable HTTP** transport and is pointed at `https://mcp.tako.com/mcp` (not a `.../sse` path). Restart the client so it re-runs the `tools/list` handshake. If you sent an API key, check that the `Authorization: Bearer tako_sk_…` header is set and the key hasn't been revoked. Tako rejects an invalid key rather than treating the connection as signed out. Those three are **opt-in**. Reconnect with `?tools=` on the URL and restart the client. The parameter *replaces* the default listing, so name the defaults too: ``` https://mcp.tako.com/mcp?tools=search,available_data,contents,graph_related,agent ``` See [Tools](#tools) for the token table. If a **default** tool is missing instead, look for a `?tools=` on the URL that left it out — a misspelled token included. An unrecognized token is dropped and the rest are honored, so `?tools=serch,contents` lists `tako_contents` alone. Only a `?tools=` that names nothing recognizable falls back to the defaults. On the Claude Code plugin, the connection URL is pinned, so `?tools=` isn't available. Add the server yourself with `claude mcp add` and the parameter — and remove the plugin's connection so you don't get two copies of every tool. If a tool replies with sign-in instructions, the connection isn't signed in. All four default tools are listed either way, but only `tako_search` answers without credentials. Sign in through your client, or add an `Authorization: Bearer tako_sk_…` header, then retry the call. If a signed-in connection hits a rate limit, you've reached your account's limit rather than the credential-free one — check [pricing](https://tako.com/pricing) for your plan's rates. `tako_available_data` and `tako_graph_related` are never charged, so use them for coverage checks instead of a priced search. You don't need a pre-existing API key — approving the sign-in mints a per-host key automatically (named `MCP: ` at [tako.com/console/api-keys](https://tako.com/console/api-keys)). If a host stops authenticating, remove and re-add the connector to mint a fresh key. Deleting a host's `MCP: ` key at the console kills that host's access; rotating your key kills every host's grant at once. Tako keeps at most ten MCP keys — connecting an eleventh host trims the oldest. ## Next steps Run every tool on your own limits Rates and free credits One prompt for your coding agent This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.