Skip to main content

The Kinn MCP

Most products that ship an MCP server expose their API through it: forty narrow tools for listing, filtering, and fetching records. Your AI assistant then has to figure out how to assemble those calls into an answer — and it's usually not very good at that, because it doesn't know your data.

Kinn takes the opposite approach. The MCP server exposes essentially one tool that runs the entire Kinn agent — the same agent behind Kinn chat, with the same research pipeline, the same charts, and the same permissions. Your AI tool doesn't query Kinn's database. It asks Kinn a question, and Kinn does the analysis.

That difference is the whole point, and it shows up in four ways.

What makes it different​

You get an analyst, not an API. When Claude or ChatGPT calls Kinn, the full agent runs: semantic search across your sources, deep-research investigations with real denominators, chart generation, report writing. A question like "how widespread is the save-corruption bug, broken down by platform?" runs the same bounded investigation it would run in Kinn chat. An MCP that only exposed endpoints could never do that — the calling model would have to invent the methodology itself.

Conversations are durable and resumable. Every call creates a real Kinn thread and returns its thread_id. Pass that ID on a later call and you resume with the entire research history intact — including the evidence from an earlier investigation. This means a long analysis can span many turns, or even many sessions, without re-running the expensive work.

Charts come back as images. When an answer includes a chart, Kinn renders it and returns native MCP image content, so it appears inline in your AI tool rather than as a wall of numbers.

It can act, not just read. This is the part most people miss. Subject to your Kinn role, the MCP can save notes, create reports and exports, manage sources, and write to your product's connected trusted connectors — so an assistant can go from "is this bug widespread?" all the way to "file it" without leaving the conversation.

caution

The MCP is not read-only. It grants the same role-dependent capabilities you already have in Kinn chat. Writes only happen when explicitly requested — Kinn won't change anything on its own — but you should authorize it accordingly. See Connect Kinn to an AI tool for exactly what each role can do.

What's exposed​

ask_kinn — the main tool. Takes your question, optionally a product_id, and optionally a thread_id to continue an existing conversation. Returns the answer plus the thread ID in structured content.

list_products — lists the products your token covers, with their IDs and connected sources. Only needed when an account has more than one product; with a single product you can omit product_id entirely.

kinn://products — the same product information as an MCP resource, for tools that prefer resources over tool calls.

Suggested prompts — the suggested prompts for your products are exposed as MCP prompts, so they show up as ready-made options in tools that surface a prompt picker.

Using it well​

Ask questions, not queries. The instinct with most MCP servers is to ask for data — "get me all Discord messages from last week." That's the wrong shape here and will give you a worse answer. Ask the way you'd ask an analyst: "what changed in Discord sentiment after Tuesday's patch, and what's driving it?"

Hold onto the thread ID. If you're doing anything multi-step, passing the thread_id back is the difference between a coherent investigation and a series of disconnected questions. When you supply a thread_id, the product is inferred — leave product_id out.

Everything from Writing good queries still applies. Context, specificity, naming the version and window — these matter just as much through MCP as they do in chat. Your AI tool won't add them for you.

Be explicit about actions. Kinn acts only when asked. "File this as a bug in Linear" works; hoping it infers that from context does not.

Kinn as a client, not just a server​

There are two directions here, and they're easy to confuse:

  • Kinn as an MCP server — your AI tool connects to Kinn. That's this page.
  • Kinn as an MCP client — Kinn connects out to other tools' official MCP servers, currently Atlassian (Jira, Confluence), Linear, and Sentry. Once one is connected to a product, the Kinn agent can use it while answering — searching your backlog for duplicates, then filing an issue with the supporting evidence attached. Jira and Linear accept writes; Sentry is read-only, so Kinn investigates there but files nothing.

These compose. An assistant talking to Kinn over MCP can reach through Kinn into Linear or Jira, all gated by your Kinn role.

See Linear, Sentry, and Jira for what each one can do and how to connect it.

Limits worth knowing​

  • File attachments aren't supported over MCP. If you need Kinn to read a CSV or spreadsheet, use Kinn chat — see Analyzing your files.
  • MCP threads are separate from web chat. They don't appear in your Kinn chat history and can't be picked up in the web UI. Continue them by passing the thread_id through MCP.
  • Usage is billed to the selected product, the same as a chat conversation.
  • One account per authorization. A token covers a single Kinn account. Connect again to reach a different one.

Next​