Connect your agent with MCP

Connect your AI agent to SeeRepo and it can read your project's map while it works: what a module does, where a part lives, what changed since yesterday and the project's figures. It reads; with a key you let write, it also makes four small changes, each one only after you say yes. It comes with every plan.

Connect with an API key

The server's address is:

https://seerepo.com/api/mcp

It uses Streamable HTTP, and every request carries an API key as a Bearer token.

1. Create a key

In Settings → API / MCP, give the key a name (like "Claude Code") and create it. Copy it: it's shown only once. Keep it in an environment variable, for example in your shell profile:

export SEEREPO_KEY="sr_…"

2. Add SeeRepo to your client

For Claude Code:

claude mcp add --transport http seerepo https://seerepo.com/api/mcp \
  --header "Authorization: Bearer $SEEREPO_KEY"

Run claude mcp list and SeeRepo shows as connected.

For Codex, in ~/.codex/config.toml (Codex and MCP):

[mcp_servers.seerepo]
url = "https://seerepo.com/api/mcp"
bearer_token_env_var = "SEEREPO_KEY"

For Cursor, in ~/.cursor/mcp.json, or .cursor/mcp.json inside a project (Cursor and MCP):

{
  "mcpServers": {
    "seerepo": {
      "url": "https://seerepo.com/api/mcp",
      "headers": { "Authorization": "Bearer ${env:SEEREPO_KEY}" }
    }
  }
}

3. Try it

Start a conversation and ask:

The agent lists your maps, opens the first level and follows the paths down to the module it needs.

4. Tell your agent to use it

An agent goes to what it already knows: without being told, most reach for search first. Add this line to your project's CLAUDE.md or AGENTS.md:

Tools

Tool	What it does	Takes
list_projects	Your maps, and the ones shared with you, in the order of your panel, each with its branch and the id of its second branch's map	—
explain	One module: what it does, its parts with a one-line phrase and the path to go inside, and the modules it connects to. At /, also how the product runs: who comes in, its processes, where they live and what each one really uses; and, when more than 30 % of its files sit in boxes the map didn't design, that the map is half made	repo, path (by default /)
search	Parts by name or phrase in every module, and files by path	repo, query
impact	What breaks if you touch a file: who names it, how many depend on it, which pages and processes it gets to	repo, path, name, to
what_changed	The commits since a date, in plain words: when, which agent or person, and the modules each touched	repo, since (by default the last 24 hours)
figures	Commits, the share written with AI and by which agents, lines and files, the last 24 hours, 7 and 30 days	repo
pages	Every page of the app: its name, route, who gets in and the states it handles or misses, by the map's top-level modules. It opens with what the app says: how many screens and how many are ready. Where SeeRepo can't read the door, it says so instead of «anyone»; a page that only takes you somewhere else says so, with the line; Python has no Pages yet. The list also says which page files aren't counted as pages and why, what's half done, when who gets in was read by the AI, and how much of what the AI said was thrown out for lack of a line that proves it. Ask for one page by its route for everything about it: what it does, who gets in with its proof, each state with the line that proves it, what it reads and its last change	repo, page (optional)
found	How search engines and AI see each public page, and on top, as Visibilidad's ring, how many can be found of the ones that want to be on Google: each signal with its honest label and its proof, and, once a day, what the published site answered where it disagrees with the code; with Search Console connected, each page's clicks, impressions, position and whether Google indexed it	repo
health	What's worth fixing: the score out of 100 with how it moved in the week and what each dimension takes, whether it can ship and what stops it, and the open tasks, each with the points fixing it gains (or, past its dimension's ceiling, why it gains none yet), the first one with its prompt for your agent. Ask for another one's prompt by its number	repo, task (optional) On a free repo, how many are open and the title of the first.
history	The project's journey (the Journey folder): what happened in the last 7 days (commits, who wrote them, where, how many times it reached production and whether the last push arrived, and the week told in words), how it's worked against its usual, and its moments, the biggest first.
docs	The repo's wiki: without a page, its tree; with a page's key, its recorded version, document date, language and authorship, full markdown, outline, Mermaid diagram and linked sources	repo, page
prepare_ignore · apply_ignore	Leave paths out of the map (generated code, experiments, vendored files), as Settings → Ignore does	repo, paths · id
prepare_mark_false · apply_mark_false	Say a task in Salud is wrong, whole or only some of its files, and why	repo, task, files (optional), why · id
prepare_set_aside · apply_set_aside	Put a task off for 1 to 90 days, or accept it as it is and say why	repo, task, how (snooze or accept), days or why · id
prepare_claim · apply_claim	Say which agent made commits it didn't sign, each by its whole hash, as the agent's session recorded it: they count as its own in Journey and the AI share	repo, agent, shas · id

repo is the repo's id, or owner/name as on GitHub. task is a task's number in health's list, or its key. The first ten tools only read; the last eight are the writes below.

What an answer looks like

Short text an agent reads, with the path to go one level down. Never your code:

Checkout (/checkout) in ana/tienda
Takes the payment.
Inside: ana/tienda › Checkout

Parts (2):
- Pricing page [screen]: Where the plans are picked. (app/pricing/page.tsx)
- Stripe webhook [action]: Turns the plan on once Stripe confirms. (app/api/stripe/route.ts)
Comes from:
- Engine (uses, 2) → /engine

Next: search by name, or what_changed to see what moved.

Changes, with your yes

Four changes and no more: ignore paths, mark a finding false, set a task aside, and claim commits for the agent that made them without signing. Everything else (payments, keys, sharing, deleting a repo) stays in the web.

• A key reads unless you let it write. Turn writing on when you create the key, or later, in Settings → API / MCP. Turning it off stops what it left halfway.
• Two steps. prepare_… changes nothing: it says what will happen and gives an id. Your client asks you, and apply_… with that id, within 5 minutes, makes it so. The same id applied twice does it once.
• Never security. No path that would hide a secret, an .env with values or an open security finding can be ignored, and security findings can't be marked false nor set aside. An agent that writes may be following something written in the code it read.
• A signature wins. A commit that already carries an agent's signature keeps it, even if you claim it.
• Within limits. Never more than half of your product's files out of the map (that's done in Settings), up to 100 ignored paths, and 20 changes a day per project.
• Each one logged, each one undone. Who made it, how and when, in Settings → API / MCP, where you undo it. The API undoes it too.
• What's marked stays in sight. Salud shows it apart with its mark, and it takes no points. Your public page shows it too, without the why or who.

A finding you mark false tells us where the engine got it wrong: we look at each one, and the fix reaches every project.

How access is limited

• Your maps only. The key reads what your account reads: your repos and the ones shared with you. Anyone else's repo answers as not found.
• Reads, unless you say so. A key writes only if you let it, and each change waits for your yes.
• Your plan applies. A repo on the free look reads as it does in the app: whole up to 300,000 written lines, without what its parts do except its sample; above that, only its first level, with a 402 going inside.
• 60 requests a minute per key.
• Revoke a key in Settings → API / MCP and it stops at once.

The same key works for the API and the CLI.