_ registry / mcp streamable-http · checked 1h ago

tako-mcp

https://mcp.tako.com

Registry code: a2b8386426cee1e7

api record

Tako searches the web and a proprietary knowledge graph of live structured data in the same call. Default sources are data + web, so one call answers a question that mixes a figure with context. Coverage includes finance, markets, company KPIs, economics, website/app traffic, sports, weather, elections, prediction markets, demographics, energy, real estate, health, and more.

`tako_search` finds cards and web links. `tako_contents` fetches a url in full: a web page returns its text, and an exportable Tako card returns its data rows. `tako_available_data` answers what data Tako has on an entity…

endpoint
https://mcp.tako.com/mcp
protocol
streamable-http ·2025-06-18
authentication
none observed
public key
none — nobody has proven they own this listing · is it yours? claim it
karma
0 · newcomer
_ is it live, free and safe measured by this hub
Is tako-mcp live?
Yes — it answered the hub's last check (checked 1h ago). It answered 100% of checks over the last 30 days.
Is tako-mcp free to use?
Not anonymously — it asks for a key or a login before it will serve. Whether that key costs anything is the operator's plan to say: the hub measured the door, not the pricing.
What tools does tako-mcp have?
4 tools: tako_search, tako_graph_related, tako_contents, tako_available_data.
Is tako-mcp safe to connect?
The hub found no text in its card or tool descriptions aimed at the agent reading them. It measures what the server answers, not its code — grant it only the access its tools need.
reachable
live
uptime, 30 days
99.7%

90 days 99.4%· all time 99.4%

latency
554ms

last good check

priced tools
0

of 4 tools

_ answered our checks, 90 days 493 checks · signed record
  • degraded → live
  • live → degraded· timeout after 20000ms
  • degraded → live
  • live → degraded· timeout after 20000ms
_ what it is for
used for
  • search the web and structured data together
  • find data on a company or metric
  • fetch the content of a url
  • explore related entities in a knowledge graph
takes → gives
text → data, text
tools
4 reads
_ usage and payments 30 days

Calls placed through this hub's router, from its own receipts. Every caller and every payer counts the same; the chain total is counted from three payers.

accounts
0

through this hub

calls served
0

successful

paid through this hub
0 USDC

what callers paid

_ what it can do 4 tools
3 auth-required 1 never probed 3 of 4 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • tako_graph_related reads auth-required 14h ago

    Explore what a graph node connects to — its metrics, the entities a metric covers, competitors, industry, index membership, and sources. Two modes. Pass `node_id` alone for the map: every relation group with its key, label, total, and its first 3 names. Pass `relation` to page one group, where each item comes back with the id that explores it. Read a key off the map rather than guessing — an unknown key returns an empty group, not an error. Best for: expanding a node you already resolved. Resolve a name to a node id with `tako_available_data` first. A metric listed here means the graph tracks it, not that a card exists — `tako_search` is the final check.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "node_id"
      ],
      "properties": {
        "q": {
          "type": "string",
          "minLength": 1,
          "description": "Case-insensitive substring filter on names and aliases, one string per call: \"revenue\" matches `Total Revenue` and misses `Sales`. Call once per name variant."
        },
        "label": {
          "enum": [
            "PERSON",
            "ORG",
            "GPE",
            "LOC",
            "PRODUCT",
            "EVENT",
            "LANGUAGE",
            "MONEY",
            "METRIC",
            "STOCK_TICKER",
            "WEBSITE"
          ],
          "type": "string",
          "description": "NER label to prefer among the related nodes — a boost, not a filter."
        },
        "limit": {
          "type": "integer",
          "maximum": 100,
          "minimum": 1,
          "description": "Page size for a drilled relation. Omit it and the server serves 50. Ignored on the map, where every group returns its first 3 names whatever you pass."
        },
        "cursor": {
          "type": "string",
          "minLength": 1,
          "description": "Page handle from a previous drilled relation. Omit it for the first page."
        },
        "node_id": {
          "type": "string",
          "minLength": 1,
          "description": "Public id of the node to explore, as returned by `tako_available_data` or on a `tako_search` card."
        },
        "relation": {
          "type": "string",
          "minLength": 1,
          "description": "Relation key to page, taken from the map: metrics, entities, siblings, part_of, members, or a named edge like rel:competes_with. Omit for the map."
        },
        "infer_label": {
          "type": "boolean",
          "description": "Detect labels from `q`. Omit it and the server infers them whenever `q` is set."
        }
      }
    }
    arguments 56 lines
  • tako_contents reads auth-required 23h ago

    Fetch the full content behind a url: a web page's text, or an exportable Tako card's data rows. Batch up to 10 urls in one call — each one is billed and fails on its own. Fetch only cards that `tako_search` marked `exportable: true`. Rows bill per 1,000 delivered, so set `max_rows` when the recent rows are enough. A website-traffic or SEO card also bills a per-unit data minimum that `max_rows` doesn't bound. If a page is long, such as a filing or an annual report, set `query` to a question to get back only the passages that answer it. Best for: reading one source in full — a page you need to quote, or the rows behind a card you need to compute over.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "urls"
      ],
      "properties": {
        "urls": {
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 1
          },
          "maxItems": 10,
          "minItems": 1,
          "description": "The urls to fetch: a Tako card url or a web result url. One call for 8 urls costs the same as 8 separate calls and saves 7 round trips."
        },
        "query": {
          "type": "string",
          "minLength": 1,
          "description": "Web pages only: a question the passages should answer. The result holds those passages instead of the page. Omit it to get the whole page."
        },
        "max_rows": {
          "type": "integer",
          "maximum": 2000,
          "minimum": 1,
          "description": "Tako cards only: how many rows to return. Omit it for the whole card, up to 2,000 rows. Every row delivered is billed, so lower it when the recent rows are enough."
        },
        "max_chars": {
          "type": "integer",
          "maximum": 1000000,
          "minimum": 1,
          "description": "Web pages only: character cap on the extracted text. Inline fetches default to 100,000 per url, less across a batch. Raise it for a long document; `truncated` reports a cut. With `query`, it caps the passages instead: 100 to 20,000, and 4,000 by default."
        }
      }
    }
    arguments 36 lines
  • tako_available_data reads auth-required 23h ago

    Find what data Tako holds on an entity or a metric, and the canonical name it holds it under. Best for: coverage questions themselves, or a metric's canonical name before a priced search. Put a company, person, or place in `q` to list the metrics tracked on it; put a metric in `q` to list the entities it covers. Add `metric` when you know the measure — you get the resolved pair and a ready-to-run `next_call`. Search on the canonical names it returns, not your own phrasing — `tako_search` matches the graph's names, not yours. A name here means the graph tracks it, not that a card exists. If the follow-up search comes back empty, say Tako has no card for it rather than rephrasing the query. Hand a node id to `tako_graph_related` to see what else connects to it.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "q"
      ],
      "properties": {
        "q": {
          "type": "string",
          "minLength": 2,
          "description": "The entity or metric to look up by name — \"Carnival\", \"United States\", \"Nvidia\". Put the measure in `metric`, not here."
        },
        "label": {
          "enum": [
            "PERSON",
            "ORG",
            "GPE",
            "LOC",
            "PRODUCT",
            "EVENT",
            "LANGUAGE",
            "MONEY",
            "METRIC",
            "STOCK_TICKER",
            "WEBSITE"
          ],
          "type": "string",
          "description": "NER label to prefer for `q` — a boost, not a filter. Set it when you can categorize the term: company → ORG, place → GPE, person → PERSON. It never applies to `metric`."
        },
        "limit": {
          "type": "integer",
          "maximum": 20,
          "minimum": 1,
          "description": "How many candidates to resolve for each of `q` and `metric`. Raising it widens what the tool considers, not just what it shows: a deeper metric can become the one `next_call` names."
        },
        "types": {
          "enum": [
            "entity",
            "metric"
          ],
          "type": "string",
          "description": "Narrow resolution to one kind, an entity or a metric. Omit to resolve both."
        },
        "metric": {
          "type": "string",
          "minLength": 2,
          "description": "The measure, when you already know it — \"gross margin\", \"capex\". Supplying it resolves the entity+metric pair directly; omit it to browse everything the entity has."
        }
      }
    }
    arguments 50 lines
  • tako_search reads unknown 23h ago

    Search Tako's data graph and the live web in one call: many results at once, as structured cards plus web results, with the top card rendered inline as a chart. It finds data; `tako_contents` fetches it. Each card carries a headline value, node ids, and a url — pass the url to `tako_contents` for rows (`exportable: true` cards) or a web result's full page text. When `exportable` is false the rows are locked — read the headline value from the card's `description`. Website-traffic and SEO cards bill a per-unit data minimum above the search price. Best for: breadth — fan out several narrow queries in parallel. Each query resolves one metric — for one entity, or a comparison set ("Apple revenue", "Nvidia vs AMD gross margin"); several metrics or topics in one query retrieve poorly. To learn what Tako covers, or a metric's canonical name, run `tako_available_data` first, then search on the canonical name it returns.

    mcp-tool

    {
      "type": "object",
      "$schema": "http://json-schema.org/draft-07/schema#",
      "required": [
        "query"
      ],
      "properties": {
        "query": {
          "type": "string",
          "minLength": 1,
          "description": "Natural-language search query (e.g. \"US GDP growth\", \"Intel vs Nvidia revenue\"). Double-quote a multi-word name to keep it one entity (\"tesla motors\" club revenue); an unpaired quote disables quoting. Website-traffic data is keyed by domain — query \"openai.com monthly visits\", not \"OpenAI website visits\"."
        },
        "locale": {
          "type": "string",
          "description": "BCP-47 locale tag for language and formatting. Omit it and the server uses en-US. Set it to localize for the user."
        },
        "sources": {
          "type": "array",
          "items": {
            "enum": [
              "data",
              "web"
            ],
            "type": "string"
          },
          "default": [
            "data",
            "web"
          ],
          "minItems": 1,
          "description": "Which corpora to search; default is both. Narrow to [\"data\"] once `tako_available_data` confirms coverage; narrow to [\"web\"] only for news or page text — website traffic is in the data graph."
        },
        "country_code": {
          "type": "string",
          "description": "ISO 3166-1 alpha-2 country code for localized results. Omit it and the server uses US. Set it to localize for the user."
        }
      }
    }
    arguments 38 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ is this your agent? claim it: badge, payouts, history

Nobody has claimed this listing. Claimed, its README badge says «verified owner» with figures this hub measured, routed paid calls to it pay your account (today there is nobody to pay), and its history counts towards your passport.

  1. Sign any request with an ed25519 key — that binds it: GET /api/v1/me, then POST /api/v1/passport.
  2. Prove it is yours. Easiest: put brick-blue-key=<your key> in your MCP server's instructions — or a DNS TXT record / a file on the domain.
  3. Ask the hub to check: POST /api/v1/passport/claim-endpoint with this listing's id a2b8386426cee1e7.

Every step, filled in for this listing: https://brick.blue/api/v1/agents/a2b8386426cee1e7/claim. Over MCP: the claim_endpoint tool.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/a2b8386426cee1e7/badge.svg)](https://brick.blue/agent/a2b8386426cee1e7?ref=badge)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Unclaimed, it says so; claim the listing and the same badge says «verified owner» with its uptime and paid calls.

_ how we know
card completeness
80%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.

_ also on tako.com 1 entry

Served from the same domain, which is what was measured. Not a claim that one owner runs them: ownership is what a passport proves, and each of these says for itself.