# MCP servers for Claude Code and every agent: set up and inspect them per repo

> MCP server setup for Claude Code and other coding agents happens in the agent's own config, usually a `.mcp.json` file at the repository root. Tallos does not ship MCP servers; it inspects them. Settings → Projects → your repo → **MCP Configs** lists every server defined in `.mcp.json`, `.cursor/mcp.json`, `.claude.json` and `.claude/mcp.json`, with transport, status and masked secrets.

- Canonical: https://runtallos.com/features/mcp
- Português: https://runtallos.com/pt/recursos/mcp.md
- Author: [Roberto Rocha](https://www.instagram.com/robertorochamkt/)
- Updated: 2026-09-30
- Section: Features

## Key facts

- Checks `.mcp.json`, `.cursor/mcp.json`, `.claude.json` and `.claude/mcp.json`
- Transport (`stdio` / `http`) and status (`enabled` / `disabled` / `invalid`) per server
- Sensitive `env` values shown as `••••••••`
- Creates an empty `.mcp.json` when a repo has none
- Reads SSH repos through the remote filesystem

## What is MCP?

**MCP (Model Context Protocol)** is an open protocol, introduced by Anthropic, that lets AI agents call external tools and data sources through one standard interface. Each integration runs as an **MCP server**: a small program or remote endpoint that exposes tools such as querying a database, reading an issue tracker or searching internal docs. An agent that supports MCP connects to the servers listed in its config and calls their tools during a task.

Two transports cover most setups. With **stdio**, the agent starts the server as a local process and talks to it over standard input and output. With **HTTP**, the server runs somewhere else and the agent connects to a URL. The [glossary](https://runtallos.com/glossary) has short definitions of the related terms.

## How do coding agents like Claude Code use MCP servers?

Each agent reads MCP servers from its own config files and starts or connects to them itself. A project-level file, most commonly `.mcp.json` at the repository root, gives everyone who clones the repo the same servers. Agents can also keep personal servers in user-level settings outside the repo.

Tallos does not ship its own MCP servers and does not change how agents load them. When you start [Claude Code](https://runtallos.com/integrations/claude-code) or another MCP-capable agent in a Tallos workspace, it reads its configs exactly as it would in any terminal. What Tallos adds is visibility: for each repository, you can see which servers your agents will find before you start them.

Every Tallos workspace is a git worktree of the same repo, so a committed `.mcp.json` exists in all of them and [parallel workspaces](https://runtallos.com/features/parallel-workspaces) get the same servers. An uncommitted file exists only in the workspace where you created it.

## What does the MCP Configs inspector in Tallos show?

**MCP Configs** is a section in Settings → Projects → *your repo* that inspects the MCP server definitions agents can use in that repository. It reads the root of the repo's active workspace (or its main worktree when no workspace of that repo is active), checks four known config files and lists every server under their `mcpServers` object.

| Config source | Where | What Tallos shows |
| --- | --- | --- |
| Workspace | `.mcp.json` | File status and each server's name, transport, command or URL, `env` and status. **Add MCP config** creates this file when no config exists |
| Cursor | `.cursor/mcp.json` | The same server details, labeled Cursor, with an **Open** button |
| Claude | `.claude.json` | Servers under the file's top-level `mcpServers` object |
| Claude workspace | `.claude/mcp.json` | The same server details, labeled Claude workspace |

_Config files MCP Configs checks, relative to the workspace root_

- **Per file:** a status of not found, invalid JSON, unreadable, no servers, or the server count, plus **Open** to edit the file in the Tallos editor.
- **Per server:** name, transport (`stdio` or `http`), the command or URL, the `env` block, and a status of `enabled`, `disabled` or `invalid`.
- **Invalid servers** say why, for example *Missing command or URL* or *Missing URL*.
- **Checked files** that don't exist are listed under *Checked*, so you know exactly what was looked for.

The inspector understands the common dialects: `command` as a string or an array, `url` or `httpUrl`, and `type` values such as `http`, `remote` and `local`. A server marked `"disabled": true` or `"enabled": false` shows as `disabled`. Files over 256 KB, or with more than 256 servers, are reported as invalid instead of being parsed.

## How do I set up an MCP server for Claude Code in my repo?

Add the server to a `.mcp.json` file at the repository root, check it in MCP Configs, commit it, and start your agent in a workspace. The example uses the standard `mcpServers` format.

1. **Open MCP Configs** — In Tallos, go to Settings → Projects, pick the repository and scroll to **MCP Configs**. Searching settings for `mcp` or `.mcp.json` jumps there too.
2. **Create the file** — If the repo has no MCP config, click **Add MCP config**, then **Create empty config** to confirm. Tallos writes `.mcp.json` with an empty `mcpServers` object and opens it in the editor.
3. **Add your servers** — Add one entry per server under `mcpServers`. Local servers use `command`, `args` and optional `env`. Remote servers use `"type": "http"` and a `url`.
4. **Refresh and check** — Click refresh in MCP Configs. Each server should show the right transport and `enabled`. Fix anything marked `invalid` before you start an agent.
5. **Commit and run** — Commit `.mcp.json` so every workspace and teammate gets it, then start Claude Code or another MCP-capable agent in a workspace. The agent loads the servers itself.

```json
{
  "mcpServers": {
    "internal-docs": {
      "command": "node",
      "args": ["./tools/mcp/docs-server.js"],
      "env": {
        "DOCS_DIR": "./docs"
      }
    },
    "issue-tracker": {
      "type": "http",
      "url": "https://mcp.example.com/mcp"
    }
  }
}
```

In MCP Configs, `internal-docs` appears as `stdio` with the command `node`, and `issue-tracker` as `http` with its URL. Both show `enabled`.

> **One file per agent** — `.mcp.json` is the project file Claude Code reads. Other agents may use a different path or format, so check each agent's docs. Cursor, for example, reads `.cursor/mcp.json`, which Tallos also inspects.

## See what your agents will load

> Install Tallos, add your repo and check its MCP Configs before you start your agents. → https://runtallos.com/signup

## How do I keep MCP secrets out of git?

Keep API keys and tokens out of any MCP config you commit. A committed `.mcp.json` is readable by everyone with access to the repo and by every agent working in it.

- **Don't commit literal secrets.** Put servers that need personal tokens in your agent's user-level config, outside the repo, or use environment-variable references if your agent supports them. Check its docs for the syntax.
- **Masking is for the screen, not the file.** Tallos masks an `env` value when its key looks sensitive (`token`, `secret`, `password`, `api_key`, `auth`, `bearer`, `cookie`, `session`, `credential`, `private_key`) or when the value looks like a known token format such as `sk-…` or `ghp_…`. It shows `••••••••`; the file on disk is unchanged.
- **Ignore personal files.** If you keep a personal MCP file inside the repo folder, add it to `.gitignore`.
- **Read before you run.** A stdio server is a program the agent starts on your machine. Check the commands in MCP Configs before you open an agent in a repo you just cloned.

## Does MCP Configs work with SSH repos?

Yes. For a repository on a [remote workspace](https://runtallos.com/features/remote-workspaces), Tallos reads the config files through the remote filesystem over SSH. The repo has to be connected; if it isn't, MCP Configs asks you to connect it first. Creating a starter config on a remote repo is limited to the workspace root `.mcp.json`.

MCP Configs appears for git repositories. Plain folder projects don't have the section.

## How do MCP servers relate to the tallos CLI and skills?

They solve different problems and work side by side. MCP servers give an agent tools from outside systems. The [tallos CLI and bundled skills](https://runtallos.com/features/tallos-cli-and-skills) let the agent drive Tallos itself: create workspaces, read terminals, use the built-in browser. [Agent skills](https://runtallos.com/features/agent-skills) are the instructions that tell an agent when to use which.

## Frequently asked questions

### How do I add an MCP server to Claude Code?

Add it under `mcpServers` in a `.mcp.json` file at the repository root, with `command` and `args` for a local server or `"type": "http"` and `url` for a remote one. In Tallos, Settings → Projects → your repo → MCP Configs can create the empty file and confirm the server is detected.

### Does Tallos include its own MCP servers?

No. Tallos does not ship MCP servers. Agents use the servers defined in their own configs, and Tallos shows you what each repository defines.

### Which MCP config files does Tallos read?

Four files at the workspace root: `.mcp.json`, `.cursor/mcp.json`, `.claude.json` and `.claude/mcp.json`. Servers are read from the `mcpServers` object in each one.

### Will Tallos show my MCP API keys on screen?

No. `env` values whose name or format looks sensitive, such as `API_KEY` or `GITHUB_TOKEN`, are shown as `••••••••`. Masking only affects the display, so still keep secrets out of files you commit.

### What does invalid mean next to an MCP server?

The entry is missing something the agent needs, such as a command for a stdio server or a URL for an HTTP server. Tallos shows the reason under the server name.

### Do MCP servers work in every parallel workspace?

A committed `.mcp.json` is part of the repo, so it exists in every workspace Tallos creates from that repo. An uncommitted file exists only in the workspace where you created it.

### Can I inspect MCP configs on a remote machine over SSH?

Yes. Tallos reads SSH repos through the remote filesystem once the connection is up, and can create a starter `.mcp.json` at the workspace root.

## Sources

1. [What is the Model Context Protocol (MCP)?](https://modelcontextprotocol.io/docs/getting-started/intro) — Model Context Protocol
2. [Connect Claude Code to tools via MCP](https://code.claude.com/docs/en/mcp) — Anthropic
3. [Model Context Protocol specification](https://modelcontextprotocol.io/specification/latest) — Model Context Protocol

---

**Run your agents in parallel with Tallos** — Claude Code, Codex, Gemini and 30+ agents — each in its own workspace, with squads, chat, terminals and review in one app. Uses the subscriptions you already have.

https://runtallos.com/signup (macOS 13+ · Windows 10+)