> ## 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. # Quickstart export const AgentPromptCard = ({title, description, agents, children}) => { const marks = { claude: , cursor: , chatgpt: }; const shown = (agents === undefined ? ['claude', 'cursor', 'chatgpt'] : agents).map(key => marks[key]).filter(Boolean); const headerPad = shown.length ? `${1.75 * shown.length + 1.25}rem` : '0'; return
{shown.length > 0 &&
{shown}
}
{title}
{description}
{children}
; }; export const WhyTakoCTA = ({description, href}) =>

{description ? `${description} ` : null}Why do developers use Tako? →

; For AI agents: Use [llms.txt](https://docs.tako.com/llms.txt) for a full index of all documentation. ## Add Tako to your agent The fastest way to build with Tako. Paste one prompt into your coding agent to wire Tako into an existing project, or create a new Tako agent from the console.
Follow the agent quickstart in the console. It generates a prompt for your coding agent in seconds to build with the Tako APIs. ```text theme={null} I want to integrate Tako into this project. Tako serves live financial, macroeconomic, sports, and company data as citation-backed answers and interactive charts. Its surfaces: Search (ranked knowledge cards with charts), Answer (one grounded, written answer), Contents (full data rows / page text), a deep-research Agent, a Data Graph (free coverage checks), and chart creation from my own data. Step 1: Read the docs before changing anything. - Fetch https://docs.tako.com/llms.txt. It indexes every documentation page. - From that index, read the quickstart plus the pages that match my stack and use case: the integration guide for my framework (OpenAI Responses, Anthropic tool calling, Vercel AI SDK, OpenAI-compatible), the MCP server page, and the relevant per-feature "for coding agents" references. Step 2: Ask me these questions one at a time and wait for my answers. 1. What does this project/agent do, and what kinds of data questions should Tako handle for it? (financial, macro, sports, company, web traffic…) 2. What framework or runtime is it built on? (Vercel AI SDK, OpenAI Agents SDK / Responses API, Anthropic API, LangChain, raw MCP client, plain backend, something else) 3. Quick answers or deep research? Single grounded answers and searches are one call; the Agent API dispatches long-running multi-step research. 4. Is a search or data tool already wired in (Exa, Tavily, Brave, built-in web search)? Should Tako replace it or run alongside it? 5. Do I need the data itself (full rows, CSV export via Contents) or charts built from my own data? 6. Where do secrets live in this project? Assume the key is TAKO_API_KEY unless I say otherwise. Step 3: Evaluate and propose before writing code. - Recommend the integration surface that fits my answers, and say why: the hosted MCP server (https://mcp.tako.com/mcp: zero glue code, connection-level auth, opt-in tools via ?tools=) vs. the Python/TypeScript SDKs or REST API (typed control, streaming, retries) vs. a provider-native tool-calling guide from the docs. Prefer the simplest surface that covers the use case. - Show me a short plan first (files to change, tools to expose, prompts to update) and wait for my OK. Step 4: Integrate with best practices. - Wire Tako in the idiomatic way for my framework. Never hardcode the key. Read it from the environment. - Add tool-choice guidance to the agent's system prompt: Answer for one specific data question that needs a conclusion; Search fanned out in parallel, one entity + one metric per query, when the agent needs the evidence; the Data Graph / available-data check as a free pre-check of what coverage exists; Contents for the full rows behind an exportable result; the Agent API for questions that need figuring out. - Do not remove or rename existing tools unless I chose to replace one. If Tako replaces a provider, migrate its call sites and prompts, and tell me exactly what changed. Step 5: Verify. - Make one free coverage-check call (available data / Data Graph) and one real search, show me the results, and summarize what you integrated and why. If TAKO_API_KEY is not set, tell me to sign up at https://tako.com (free credits included) and create a key at https://tako.com/console/api-keys. ```
## Installation Tako ships official SDKs for **Python** and **TypeScript / JavaScript**. Every endpoint is also a single `POST`, so any other language works over the [REST API](#make-your-first-request) directly. ```bash Python theme={null} pip install tako-sdk ``` ```bash TypeScript / JavaScript theme={null} npm install tako-sdk ``` ```bash Vercel AI SDK theme={null} npm install @takoviz/ai-sdk ai @ai-sdk/openai ``` ```bash MCP theme={null} https://mcp.tako.com/mcp ``` For one-click MCP setup in Cursor, VS Code, and Kiro, see the [MCP server](/documentation/integrations/mcp-server) page. For ChatGPT and Codex, install from the [OpenAI plugin directory](/documentation/integrations/chatgpt). ## Get your API key New to Tako? [Sign up](https://tako.com) and get free credits to start building. Create an API key from your [Tako console](https://tako.com/console/api-keys). Store it as an environment variable — for example `TAKO_API_KEY` — rather than hardcoding it. ## Pick the right tool Each API is a single call over the same curated, real-time data. Here's what each one is for. You want the question answered, not the data. `"Should I wear a jacket in New York this week?"` **Returns** — a written answer, with the sources behind it. You want the data itself, and you'll do the rest. `"Nvidia quarterly revenue"` **Returns** — knowledge cards and web results, no LLM in the loop. You have a result already, and you need what's under it. `"https://tako.com/card/…"` **Returns** — that card's rows as CSV, or a web page as clean text. The question needs real work before anything can answer it. `"Which of the 20 largest US semiconductor companies grew revenue fastest since 2015?"` **Returns** — a cited brief from an asynchronous research job. Already have your own data? **[Thin-Viz](/documentation/integrating-tako/chart-creation/overview)** turns it into interactive, embeddable Tako cards. Want to see what data is available? The **[Data Graph](/documentation/integrating-tako/data-graph/overview)** lets you explore the entities and metrics Tako covers, then pin exactly what you find into Search. It consumes no credits, so it's the cheapest way to find out what Tako has before you query it. ## Make your first request Pick the use case closest to what you're building. Each is a single call over the same real-time data — the code and the live result below both change to match. **Search** returns fast, structured knowledge cards for a query — no LLM in the loop. Ideal for pulling live prices you render or compute on yourself. ```bash cURL theme={null} curl -X POST https://tako.com/api/v3/search \ -H "X-API-Key: $TAKO_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "query": "What are today'\''s top performing stocks?" }' ``` ```python Python theme={null} import os from tako import Configuration, SearchRequest from tako.lib import Tako config = Configuration() config.api_key["apiKey"] = os.environ["TAKO_API_KEY"] client = Tako(config) results = client.search(SearchRequest(query="What are today's top performing stocks?")) for card in results.cards or []: print(card.title, card.webpage_url) ``` ```typescript TypeScript theme={null} import { Tako } from "tako-sdk"; const tako = new Tako({ apiKey: process.env.TAKO_API_KEY! }); const results = await tako.search({ query: "What are today's top performing stocks?" }); for (const card of results.cards ?? []) { console.log(card.title, card.webpage_url); } ```

A knowledge card — a full data series with its sources, ready to render or compute on.