Agentic Dev Wiki

MCP

7 min read

Українська версія

Author: abavyka

So what kind of Pokémon is MCP

What it is

MCP (Model Context Protocol) is an open standard for hooking AI apps up to outside systems. Anthropic built it and shipped it in November 2024, and in December 2025 handed it over to the Agentic AI Foundation under the Linux Foundation (founders: Anthropic, Block and OpenAI). That’s why MCP is now supported not just by Claude, but by ChatGPT, VS Code, Cursor too.

Basically it’s a wrapper over an API in a format that’s handy for the model. The server describes each tool: a name, a plain-words description of what it does and when to grab it, and a JSON Schema for the params. The model reads the description, decides on its own when to call the tool, and Claude Code passes the call to the server and drops the result back into the conversation. Under the hood the server makes ordinary requests to an API, a database or files.

Here’s the setup:

  • host — the app with the model, here that’s Claude Code
  • client — a connection to one server, the host creates one per server
  • server — the program that provides tools. Local (runs as a process on your machine) or remote (over HTTP, everyone knows what HTTP is, right?)

Besides tools, a server can provide resources (data you can pull into the context) and prompts (ready-made request templates), more on those below.

The docs give a simple signal: if you’re copying data into the chat from another tool (a ticket from the tracker, a graph from monitoring), it’s time to hook up a server. Then Claude reads and does stuff there itself, instead of working off whatever you pasted.

What a tool looks like

Take DeepWiki as an example — a free remote server with no auth that answers questions from the docs of public GitHub repos. Here’s one of its tools, the way the server returns it in tools/list (I stripped outputSchema and _meta):

{
  "name": "read_wiki_structure",
  "description": "Get a list of documentation topics for a GitHub repository.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "repoName": {
        "type": "string",
        "description": "GitHub repository in owner/repo format (e.g. \"facebook/react\")."
      }
    },
    "required": ["repoName"]
  }
}

Two more:

  • read_wiki_contents — “View documentation about a GitHub repository.”
  • ask_wiki_question — “Ask any question about a GitHub repository’s codebase and get an AI-powered answer grounded in its DeepWiki.” Params: repoName and question

That’s all the model knows about a tool: the name, the description and the params. You type “how is the reconciler set up in facebook/react?” — Claude picks ask_wiki_question on its own and plugs in repoName: "facebook/react".

And that’s everything Claude can do through this server. MCP doesn’t give you the full API of a service or everything you can click through by hand in the UI, only what the server’s author wrote tools for. No tool — Claude won’t do it, even if the service itself has it.

Mine

  • claude-in-chrome and chrome-devtools — browser
  • phpstorm — IDE
  • code-review-graph
  • excalidraw — diagrams
  • atlassian — Jira and Confluence at work
  • Claude Docs — a connector from claude.ai

(MCP isn’t only about code, there’s also Booking.com, Kiwi.com, Tripadvisor, garmin mcp etc)

Connectors you added in claude.ai show up in Claude Code on their own, if you’re logged in through your subscription.

How to hook one up

A remote server, the same DeepWiki (you can try it right away, no login needed):

claude mcp add --transport http deepwiki https://mcp.deepwiki.com/mcp

A local one that runs as a process on your machine (everything after -- is the server’s command):

claude mcp add airtable -- npx -y airtable-mcp-server

http is the recommended transport, sse is deprecated.

Where to look for servers:

  • Anthropic Directory — vetted connectors. You add them in claude.ai, or any remote one from there via claude mcp add
  • plugins — can bring MCP servers along, they switch on together with the plugin

Then:

  • claude mcp list — a list with statuses: connected, needs login, failed to connect
  • /mcp — OAuth login, switch a server off without deleting its config

Scope

  • local — the default: only you and only this project, lives in ~/.claude.json
  • project — .mcp.json in the repo root, gets committed, the whole team gets the same servers
  • user — you, but across all your projects

We don’t write keys into .mcp.json as plain text, ${API_KEY} and ${VAR:-default} work there.

How much context it eats

At first I hooked up everything that looked cool, and then switched off what I wasn’t using: Uber, Uber Eats, Gmail, Google Calendar, Strava.

Tool search is on by default now: at startup only tool names and server instructions go into the context, and a tool’s full description gets loaded when Claude decides to use it (before, the descriptions of all tools from all servers got loaded into the context at startup and hung there the whole session, so every connected server took up space, even if you weren’t using it; since 2.1.7, January 2026, Claude Code started hiding them behind search once they took up more than 10% of the context). So a dozen servers barely eat any context up front.

What eats it is the result of every call. It lands in the context and then flies along with every request:

  • from 10,000 tokens — a warning
  • 25,000 — the default limit, changed via MAX_MCP_OUTPUT_TOKENS
  • a bigger result (or over 50,000 characters) Claude Code saves to a file and drops the path to it into the conversation

How much each server ate, /usage shows. What’s in the context right now — /context.

MCP or CLI

For GitHub and AWS I use the gh and aws CLIs. The docs say it straight: a CLI is leaner, it adds no tool list to the context at all, Claude just runs the command. MCP — when there’s no CLI or it’s awkward: browser, IDE.

Permissions

Every MCP tool is named mcp__<server>__<tool>. To allow a whole server — mcp__deepwiki__* in allow.

An allow rule with * only works with a server name: mcp__* without one gets skipped with a warning and allows nothing.

Security

  • Only hook up servers you trust. A server that pulls in outside content is a door for prompt injection
  • For a database — a read-only user in the connection string, so Claude can’t change anything
  • Claude Code won’t start .mcp.json from a repo in an interactive session without your confirmation. But in claude -p and cloud sessions it loads the servers from it without asking

Resources and prompts

Resources are server data you pull into the context yourself, like files. You type @, and the autocomplete shows resources from all connected servers right next to files. The format is @server:protocol://path, e.g. from the GitHub MCP @github:repo://abavyka/agentic-dev-wiki/refs/heads/main/contents — the repo contents from the main branch. Claude Code fetches the resource itself and attaches it to the message.

Prompts are ready-made request templates from the server that turn into commands. You type /, and they’re in the list as /servername:promptname (MCP). Args go space-separated, in the GitHub MCP that’s e.g. /mcp__github__issue_to_fix_workflow owner repo title description labels assignees. The prompt’s result goes straight into the conversation.

The difference from tools: Claude calls a tool on its own, while a resource or a prompt is something you kick off.

Read more

Graph View

Backlinks