---
title: "Dieta de MCPs · cuando tus herramientas pesan más que tu trabajo"
description: "Cada servidor MCP que conectas a Claude Code entrega una lista de herramientas, y cada herramienta es un bloque de texto (nombre, descripción, esquema JSON) que el modelo tiene que leer. Con tres servidores no se nota. Con quince, medí 651 herramientas y 462 KB de esquemas: alrededor de 115 mil toke"
url: https://www.davidiriza.com/lab/dieta-de-mcps
author: David Iriza
level: Intermedio
category: MCP
tags: ["mcp", "claude code", "tokens", "contexto", "configuración"]
tools: ["Claude Code", "MCP", "Node.js"]
published: 2026-08-28
---
# Dieta de MCPs: cuando tus herramientas pesan más que tu trabajo

Los MCPs se acumulan igual que las extensiones del navegador: cada uno te resolvió algo un día y ninguno te avisa cuánto cuesta seguir ahí. La diferencia es que una extensión ociosa gasta RAM y un MCP ocioso gasta tokens en cada mensaje que mandas, aunque no lo uses. Cuando revisé el consumo de dos semanas buscando por qué se iba el presupuesto, la conversación larga era la causa principal, pero el segundo hallazgo fue este: la lista de herramientas MCP pesaba unos 19 mil tokens en cada arranque, y más de la mitad venía de servidores que no había tocado. Esta guía es la poda que hice después, con los números y los comandos.

**Ficha:** Para quien ya tiene varios conectores · Herramientas: Claude Code, MCP, Node.js · Te llevas: 13 comandos · Lectura: 22 min · Verificado 28-ago-2026

> Para agentes: esta guía describe pasos ejecutables. Sigue los bloques de comando y código en orden; pregunta al usuario solo lo que no puedas inferir (rutas, nombres de proyecto). Repositorio y contexto del sitio: https://www.davidiriza.com/llms.txt

## De un vistazo

1. Por qué una herramienta que no usas te cobra igual
2. El inventario que justificó la poda
3. Cómo medir cuánto pesan los tuyos
4. Cuatro criterios para podar
5. Local, project y user: elegir bien el scope es media dieta
6. La poda, comando por comando
7. Trampas que me costaron una tarde
8. La misma lista, vista como riesgo

## 01 · Por qué una herramienta que no usas te cobra igual

_el mecanismo_

Cuando Claude Code arranca, se conecta a cada servidor MCP y le manda una petición tools/list. El servidor responde con la definición de cada herramienta: nombre, descripción y un inputSchema en JSON Schema que describe los parámetros. Esa definición es lo que el modelo lee para decidir si la herramienta sirve y cómo llamarla. Es texto, y el texto que el modelo lee es contexto, y el contexto se cobra en cada petición.

**Atajo: clonar el repo de esta guía (terminal)**

```bash
git clone https://github.com/davidiriza-lab/dieta-de-mcps.git
```

> Repo público con licencia MIT: github.com/davidiriza-lab/dieta-de-mcps. Trae el medidor (medir-mcps.mjs, sin dependencias) y el checklist de poda listos para usar.

**Lo que devuelve un servidor en tools/list (una sola herramienta)**

```json
{
  "name": "search_contacts",
  "description": "Busca contactos por nombre, correo o teléfono. Soporta paginación con startAfterId.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string", "description": "Texto a buscar" },
      "limit": { "type": "number", "description": "Máximo de resultados (1-100)" },
      "startAfterId": { "type": "string", "description": "Cursor para la siguiente página" }
    },
    "required": ["query"]
  }
}
```

Multiplica eso por 200 herramientas de un CRM y te salen 130 KB. Hay dos modos en que ese texto llega al modelo, y conviene saber en cuál estás:

- **Carga completa (modo viejo o forzado)** — Todas las definiciones entran al prompt del sistema desde el primer mensaje. Con mis 13 servidores serían ~115k tokens antes de escribir una palabra. Es lo que pasa si desactivas la búsqueda de herramientas (ENABLE_TOOL_SEARCH=false) o usas un modelo anterior a la generación 4.5.
- **Carga diferida (default hoy)** — Claude Code carga al inicio solo los nombres de las herramientas y las instrucciones del servidor; la definición completa se trae cuando Claude la busca o la llama. Reduce el problema, no lo elimina: la lista de nombres sigue entrando en cada arranque y, por la mecánica del caché, se relee en cada petición.

> Aunque la carga diferida te salve de los esquemas, hay tres costos que no difiere: el arranque de cada proceso (un npx por servidor, cada uno con su tiempo de conexión), las instrucciones que algunos servidores mandan como texto libre (las de un servidor de generación de video pesan más que sus herramientas), y la confusión: dos servidores con herramientas de nombre parecido hacen que Claude elija mal o pregunte.

## 02 · El inventario que justificó la poda

_lo que medí_

Antes de tocar nada medí lo que había. El diagnóstico de dos semanas de transcripts (23,804 peticiones, 63 conversaciones) dejó dos cifras sobre los MCPs: la lista de nombres pesaba ~19k tokens por arranque, y la distribución de llamadas era absurda. Esto había en scope user, es decir, cargado en todos los proyectos:

| Servidor | Herramientas | Llamadas en 14 días | Decisión |
| --- | --- | --- | --- |
| Panel de hosting | 281 | 0 | Quitar. Su CLI y su API hacen lo mismo |
| CRM, 4 instancias (una por cuenta) | 1,012 en total | 48 | Dejar 1 dedicada + 1 multicuenta; quitar 3 |
| Diseño (conector) | 32 | 0 | Desactivar |
| Análisis estático de código | 7 | 0 | Desactivar; activar solo en auditorías |
| Docs de librerías | 2 | 0 | Se queda: 2 herramientas no pesan |
| Automatización, 2 instancias | 25 + 25 | pocas | Se quedan, pero una debería ser scope project |
| Navegador, 3 instancias | ~25 cada una | regulares | Quitar 1: dos ya se pisaban |
| Base de datos, 2 instancias | 29 + 29 | regulares | Se quedan; candidatas a scope project |

El patrón se repite en cualquier stack: los servidores más pesados son los que envuelven una API grande (CRM, hosting, generación de media) y son justo los que menos se usan desde el chat, porque para operaciones masivas terminas escribiendo un script. Las tres instancias del CRM que quité duplicaban cuentas que el servidor multicuenta ya cubría con un selector de cuenta: cero pérdida de acceso, 759 herramientas menos, ~9.5k tokens menos en cada arranque.

> Hubo un caso aparte: un MCP de base de datos que no era pesado en herramientas pero sí en latencia. Cada arranque esperaba a que respondiera. Lo desconecté por velocidad, no por tokens, y quedó la regla de reconectarlo solo cuando alguien lo pida por su nombre. Peso no es solo contexto.

## 03 · Cómo medir cuánto pesan los tuyos

_hazlo tú_

Claude Code trae dos vistas útiles: /context muestra qué ocupa la ventana (incluida la parte de MCP) y /usage atribuye el consumo reciente por servidor, contando solo las peticiones que consumieron un resultado de ese servidor. Sirven para ver el efecto. Para ver la causa, lo que yo quería era el número por servidor antes de arrancar nada: cuántas herramientas expone y cuántos bytes de esquema devuelve. Este script lee tu configuración, levanta cada servidor stdio, le pide tools/list y te lo tabula.

**Preparar la carpeta del medidor (terminal)**

```bash
mkdir -p ~/mcp-medidor && cd ~/mcp-medidor && npm init -y >/dev/null && npm i @modelcontextprotocol/sdk
```

> El SDK oficial de MCP trae el cliente stdio. No necesitas nada más. Si clonaste el repo, sáltate este paso: su medir-mcps.mjs habla JSON-RPC directo y no necesita el SDK.

**~/mcp-medidor/medir.mjs**

```javascript
import { readFileSync } from "node:fs";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

// Lee los servidores de scope user y los de scope local de cada proyecto
const cfg = JSON.parse(readFileSync(process.env.HOME + "/.claude.json", "utf8"));
const servers = { ...(cfg.mcpServers ?? {}) };
for (const p of Object.values(cfg.projects ?? {})) Object.assign(servers, p.mcpServers ?? {});

const rows = [];
for (const [name, s] of Object.entries(servers)) {
  if (s.type && s.type !== "stdio") { rows.push([name, "(remoto)", "-", "-"]); continue; }
  const transport = new StdioClientTransport({
    command: s.command,
    args: s.args ?? [],
    env: { ...process.env, ...(s.env ?? {}) },
    stderr: "ignore",
  });
  const client = new Client({ name: "medidor", version: "0" });
  try {
    await Promise.race([
      client.connect(transport),
      new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 45000)),
    ]);
    const tools = [];
    let cursor;
    do {
      const r = await client.listTools({ cursor });
      tools.push(...r.tools);
      cursor = r.nextCursor;
    } while (cursor);
    const bytes = JSON.stringify(tools).length;
    rows.push([name, tools.length, bytes, Math.round(bytes / 4)]);
  } catch (e) {
    rows.push([name, "ERR " + e.message.slice(0, 40), "-", "-"]);
  }
  try { await client.close(); } catch {}
}
console.log("servidor\ttools\tbytes\t~tokens");
for (const r of rows) console.log(r.join("\t"));
```

**Correrlo (terminal)**

```bash
cd ~/mcp-medidor && node medir.mjs 2>/dev/null | column -t -s $'\t'
```

> Tarda lo que tarden en arrancar tus servidores (un npx frío puede ser 20 segundos). Los remotos con OAuth salen como (remoto); mídelos con /context dentro de Claude Code.

La columna ~tokens es bytes entre cuatro: una aproximación gruesa pero suficiente para ordenar. Esto fue lo que salió en mi máquina el día que escribí la guía, ya después de la primera poda:

**Salida real (nombres genéricos)**

```text
servidor           tools  bytes    ~tokens
crm-comunitario    253    132088   33022
crm-propio         211    78524    19631
analisis-estatico  7      53855    13464
automatizacion-a   25     40358    10090
automatizacion-b   25     40358    10090
navegador-devtools 29     25160    6290
base-datos-a       29     21104    5276
base-datos-b       29     21104    5276
navegador-e2e      24     18502    4626
imagen-a           6      17893    4473
diseno-decks       5      5512     1378
docs-librerias     2      4860     1215
imagen-b           6      2576     644
video-gen          (remoto)
anuncios           (remoto)
```

- El número de herramientas engaña. El servidor de análisis estático tiene 7 y pesa 53 KB: casi 2 mil tokens por herramienta, porque cada una lleva el esquema completo de reglas en la descripción. Mide bytes, no cuenta.
- Dos instancias del mismo paquete devuelven exactamente los mismos bytes (40,358 y 40,358). Es esquema duplicado: la segunda instancia no aporta capacidad nueva, solo otra credencial.
- Los dos CRM suman 464 herramientas y 210 KB. Son la mitad del inventario. Si un día dejo de trabajar desde el chat con ese CRM, con quitar dos líneas de config bajo el peso a la mitad.
- El mismo servidor puede pesar distinto según cómo lo configures. El de automatización (n8n-mcp) expone 7 herramientas y 12 KB si lo arrancas sin credenciales de instancia (solo documentación de nodos y plantillas), y 25 herramientas y 40 KB en cuanto le das N8N_API_URL y N8N_API_KEY, porque agrega las de administrar workflows. Lo medí con el script: si en un proyecto solo consultas cómo se configura un nodo, no le des la llave ahí.

> El medidor arranca cada servidor de verdad: ejecuta su command igual que lo haría Claude Code. Leer un .mcp.json no corre nada; medirlo sí. No lo apuntes a la configuración de un repo que acabas de clonar sin leerla antes. Más sobre esto en la sección de seguridad.

## 04 · Cuatro criterios para podar

_qué se queda y qué no_

- **1. Tiene CLI: fuera** — Un CLI no agrega ninguna lista de herramientas al contexto; Claude lo corre con Bash cuando hace falta y lee solo la salida. gh, vercel, supabase, gcloud, aws, o el CLI de tu hosting. Mi MCP de hosting de 281 herramientas se fue por esto: la API tiene CLI y cero llamadas en dos semanas.
- **2. Se usa en un proyecto: scope project** — Un MCP de base de datos que solo tiene sentido dentro del repo de esa app no debería cargarse cuando escribes copy en otra carpeta. En scope project vive en .mcp.json del repo, se carga solo ahí y viaja con el equipo.
- **3. Una instancia por cuenta: solo si se usa** — El reflejo es instalar una copia del MCP por cada cuenta o cliente. Cada copia duplica todo el esquema. Prefiere un servidor multicuenta con selector, y si el servidor no lo soporta, instala la instancia el día que la necesitas y quítala al terminar.
- **4. Pesado y ocasional: desactivado, no borrado** — Auditorías de seguridad, generación de video, diseño. Los usas una vez al mes y pesan como diez servidores normales. Déjalos configurados pero apagados desde /mcp, y préndelos ese día. Conservas credenciales y config sin pagarlas a diario.

La regla que resume las cuatro: un MCP se justifica si Claude lo llama varias veces por semana desde el chat y no hay un CLI que haga lo mismo. Todo lo demás es peso.

Vas a encontrar cifras redondas por ahí: que no pases de tantos servidores prendidos, que más de tantas herramientas activas confunden al modelo. No salen de la documentación, que dice explícitamente que no hay tope por servidor y que el límite práctico es tu ventana de contexto. Yo no uso un número: uso bytes (el medidor), llamadas (/usage) y la pregunta del CLI. Con eso, trece servidores pueden estar bien y cuatro pueden ser demasiados.

| MCP que tenía | Alternativa sin lista de herramientas | Qué perdí |
| --- | --- | --- |
| Panel de hosting (281 tools) | CLI oficial + curl a la API | Nada |
| Tres copias del CRM por cuenta | Un servidor multicuenta con selector de cuenta | 78 herramientas raras (recursos de calendario, plantillas de facturas); se reinstalan puntualmente si hacen falta |
| Tercer MCP de navegador | Los otros dos: uno para pruebas headless, otro para sesión real con cookies | Nada; se pisaban entre sí |
| Base de datos lenta | Su CLI de migraciones y SQL directo | La comodidad de preguntarle al chat por el esquema |
| Docs de librerías (2 tools) | Se queda | No aplica: dos herramientas no pesan |

## 05 · Local, project y user: elegir bien el scope es media dieta

_dónde vive cada uno_

Claude Code guarda los servidores en tres lugares, y de dónde los guardes depende en qué conversaciones se cargan. El default de claude mcp add es local, que es el más conservador. El error común es agregar todo con --scope user porque 'así lo tengo en todos lados', y así es como terminas con 15 servidores en una carpeta de contenido que no necesita ninguno.

| Scope | Archivo | Se carga en | Se comparte | Úsalo para |
| --- | --- | --- | --- | --- |
| local (default) | ~/.claude.json, bajo la ruta del proyecto | Solo ese proyecto, solo en tu máquina | No | Credenciales personales de un proyecto; pruebas de un MCP nuevo |
| project | .mcp.json en la raíz del repo | Solo ese proyecto | Sí, por git | Lo que el proyecto necesita y el equipo también: la DB de esa app, su automatización |
| user | ~/.claude.json, nivel superior | Todos tus proyectos | No | Lo transversal de verdad: navegador, docs de librerías, tu CRM si lo usas desde cualquier carpeta |

Si un nombre existe en dos scopes, gana el más específico: local sobre project sobre user. Eso te deja un truco: el mismo nombre en scope local con otra credencial anula al de user solo en ese proyecto, sin duplicar la instancia global. Y los servidores de .mcp.json piden aprobación la primera vez que abres el proyecto; si en un repo ajeno rechazaste uno y quieres volver a decidir, claude mcp reset-project-choices.

Hay una cuarta palanca que no es scope pero se le parece: el apagado desde /mcp también es por proyecto. Un CRM en scope user puede estar prendido en la carpeta donde vendes y apagado en la carpeta donde escribes, sin moverlo de scope ni duplicarlo. Muchos configurados, pocos prendidos en cada carpeta: eso es lo que de verdad baja el arranque.

## 06 · La poda, comando por comando

_paso a paso_

1. Inventario: claude mcp list te da cada servidor con su estado de conexión. Corre además el medidor de arriba para tener herramientas y bytes por servidor.
2. Uso real: abre Claude Code y escribe /usage; la sección de atribución muestra el porcentaje reciente por servidor MCP (últimas 24 h o 7 días). Un servidor pesado con 0% es candidato inmediato.
3. Respalda la configuración antes de tocar: cp ~/.claude.json ~/.claude.json.bak-$(date +%Y%m%d). El remove no pregunta y las variables de entorno (tokens) se van con él.
4. Quita lo que tiene CLI o está duplicado con claude mcp remove <nombre> -s user. Si el nombre existe en varios scopes, el flag -s te obliga a decir cuál.
5. Mueve a scope project lo que solo usa un repo: claude mcp get <nombre> para ver su comando y variables, remove del scope user, y add con --scope project desde la carpeta del repo. Las credenciales no van en .mcp.json si el repo se comparte: usa variables de entorno referenciadas.
6. Desactiva sin borrar lo pesado y ocasional: abre Claude Code en la carpeta del proyecto, escribe /mcp y apaga el servidor con el toggle. Claude Code lo anota en disabledMcpServers de ese proyecto dentro de ~/.claude.json; en otra carpeta sigue prendido. Si prefieres hacerlo desde la terminal para varios proyectos, el repo trae ejemplos/desactivar-sin-borrar.mjs, que escribe la misma lista.
7. Vuelve a medir: claude mcp list, medidor y /context en una conversación nueva. Anota los números; la próxima poda se compara contra estos.

**Paso 1: inventario con estado de conexión**

```bash
claude mcp list
```

> Marca cada servidor como conectado, fallido, pendiente de autenticación, pendiente de aprobación (.mcp.json) o desactivado. Un servidor que lleva semanas en 'Needs authentication' es un servidor que no usas.

**Paso 3: respaldo**

```bash
cp ~/.claude.json ~/.claude.json.bak-$(date +%Y%m%d)
```

**Paso 4: quitar duplicados y lo que tiene CLI**

```bash
claude mcp remove hosting -s user && claude mcp remove crm-cuenta-b -s user && claude mcp remove crm-cuenta-c -s user
```

> Esto fue literal en mi poda: un servidor de hosting con CLI propio y dos copias del CRM que el servidor multicuenta ya cubría.

**Paso 5: mover un MCP de base de datos de user a project**

```bash
# Ver cómo está configurado hoy (comando, args, variables)
claude mcp get base-datos-app

# Quitarlo del scope global
claude mcp remove base-datos-app -s user

# Volver a agregarlo solo en el repo que lo usa
cd ~/proyectos/mi-app
claude mcp add base-datos-app --scope project \
  -e SUPABASE_ACCESS_TOKEN=${SUPABASE_ACCESS_TOKEN} \
  -- npx -y @supabase/mcp-server-supabase@latest --project-ref=<ref-del-proyecto>

# Verificar que quedó en .mcp.json y no en ~/.claude.json
cat .mcp.json
```

> Sobre las credenciales en .mcp.json: si el repo es privado y solo tuyo, puedes dejarlas; si lo comparte alguien, referencia una variable de entorno en vez del valor y que cada quien la tenga en su shell. Lo que nunca: un token real en un .mcp.json que sube a un repo público.

**Paso 6: así queda en ~/.claude.json después del toggle de /mcp**

```json
{
  "projects": {
    "/Users/tu-usuario/proyectos/contenido": {
      "disabledMcpServers": ["analisis-estatico", "diseno-decks", "video-gen"]
    }
  }
}
```

**Paso 6, alternativa desde la terminal (repo de la guía)**

```bash
cd ~/proyectos/contenido && node ~/dieta-de-mcps/ejemplos/desactivar-sin-borrar.mjs analisis-estatico diseno-decks video-gen
```

> Escribe la misma lista que el toggle, para la carpeta donde lo corres, y deja un respaldo de ~/.claude.json al lado. Con --prender hace lo contrario. Aplica en la siguiente conversación.

Cuando llegue el día de la auditoría, lo prendes en /mcp, trabajas, y lo vuelves a apagar. La configuración, el OAuth y las variables siguen ahí. Tres cosas que confunden: disabledMcpServers no es una clave de settings.json (ahí no hace nada); tiene una hermana, enabledMcpServers, que solo sirve para prender servidores integrados que vienen apagados de fábrica; y enabledMcpjsonServers / disabledMcpjsonServers son otra cosa: controlan la aprobación de servidores definidos en el .mcp.json de un proyecto, no el encendido de los tuyos.

## 07 · Trampas que me costaron una tarde

_lo que no dice la tabla_

- Dos MCPs de navegador se pisan. Tenía tres (Playwright, DevTools y Puppeteer). Claude alternaba entre ellos según el nombre de la herramienta que le sonaba, y cada uno abría su propio navegador. Quedaron dos con reparto explícito: uno para pruebas y capturas headless, otro cuando necesito la sesión real con cookies. Puppeteer se fue: solo Chromium y selectores CSS en vez de árbol de accesibilidad.
- Quitar una instancia también quita sus variables. Guarda los tokens en otro lado (un gestor de contraseñas o una memoria privada) antes del remove, y deja escrito el comando exacto de reinstalación. El mío para reinstalar una cuenta del CRM cabe en dos líneas y está en una nota, no en la cabeza.
- Un servidor lento pesa aunque no pese. Si un MCP tarda en arrancar o en responder, cada conversación lo espera. MCP_TIMEOUT controla el arranque, MCP_TOOL_TIMEOUT cada llamada, y hay un idle timeout por default (30 minutos para stdio, 5 para HTTP). Si lo desconectas 'por velocidad', anótalo como decisión para no reinstalarlo por reflejo.
- El resultado de una herramienta también es contexto. Por default se corta a 25,000 tokens (MAX_MCP_OUTPUT_TOKENS). Un MCP que devuelve listas enormes (contactos, logs) mete todo eso en la conversación. Pide siempre paginado o filtra en la propia llamada.
- Los conectores de claude.ai cuentan igual. Aparecen en /mcp junto con los tuyos y están al final de la precedencia. Si tienes un conector de diseño con 32 herramientas y cero llamadas, se apaga desde la configuración de conectores, no desde claude mcp.
- La atribución en /usage antes contaba mal: hasta la versión 2.1.222, tras una llamada a un servidor, todas las peticiones siguientes se le atribuían. Si tus números de atribución son de antes, no los uses para podar; vuelve a medir.
- Ni /compact ni cambiar de modelo adelgazan los MCPs. Compactar resume la conversación; la lista de herramientas se vuelve a inyectar completa en la siguiente petición. Cambiar a un modelo más barato cobra menos por el mismo peso, no lo quita. La única forma de que un servidor deje de costar es que no se conecte.

## 08 · La misma lista, vista como riesgo

_el otro lente_

Cuando terminé el inventario me di cuenta de que era también un inventario de procesos que arrancan en mi máquina con mis credenciales cada vez que abro una conversación. Un MCP no es una extensión que lee: es un comando que se ejecuta, y que Claude puede invocar. Eso convierte la lista de la dieta en la lista de una auditoría, y conviene pasarla dos veces: una por peso y otra por riesgo.

- Un .mcp.json en un repo clonado es código que corre. Claude Code por eso pide aprobación servidor por servidor la primera vez, y en carpetas que no has marcado como confiables ignora cualquier auto-aprobación que venga en el repo. No te saltes eso: enableAllProjectMcpServers en true en tu configuración global convierte cualquier clon en un vector.
- Tokens en claro dentro de ~/.claude.json o .mcp.json. Es cómodo y es el hallazgo más común. Referencia una variable de entorno y que cada máquina la tenga en su shell.
- MCPs de shell o de sistema de archivos sin allowlist: le dan a Claude lo mismo que Bash pero sin pasar por tus permisos de Claude Code. Si ya tienes Bash con reglas, no necesitas otro camino sin reglas.
- En equipo, allowedMcpServers y deniedMcpServers en settings.json (o en configuración administrada) fijan qué servidores puede usar cada quien, por nombre, comando o URL. Es la dieta impuesta, y para un equipo es la única que se cumple.

**Escanear tu configuración de Claude Code (terminal)**

```bash
npx ecc-agentshield scan
```

> Herramienta de terceros (MIT). Lee ~/.claude, .claude.json y .mcp.json, y califica secretos, permisos, hooks, servidores MCP y agentes. Con --format markdown o html deja un reporte; con --fix aplica las correcciones seguras (por ejemplo, sacar un token a variable). No te la vendo como verdad absoluta: es un checklist automatizado, y en mi config real marcó cosas de permisos y skills que sí quería revisar.

Para probar qué detecta, le armé una configuración con los tres errores de arriba: un servidor con token pegado en env, un MCP de shell y enableAllProjectMcpServers en true. Salió con calificación C, categoría de servidores MCP en 35 de 100, y las tres cosas marcadas como críticas con archivo, evidencia y corrección sugerida. Existe también un escáner de Snyk (agent-scan) que descubre agentes y MCPs de varias herramientas a la vez y busca inyección de prompts; no lo probé porque pide cuenta y token de Snyk, y aviso que, igual que mi medidor, conecta con los servidores y por lo tanto los ejecuta.

> Sobre la afirmación de que tal o cual servidor está 'en el registro oficial': el registro de MCP es del proyecto open source, no de Anthropic, y estar listado no audita el código. Un servidor con muchas estrellas sigue siendo un paquete que corre en tu máquina con tus llaves. La pregunta de la dieta y la de la seguridad son la misma: ¿lo necesitas prendido aquí, hoy?

## Preguntas frecuentes

**Si Claude Code ya difiere la carga de herramientas, ¿para qué podar?**

Porque la carga diferida difiere los esquemas, no los nombres ni las instrucciones del servidor, y no difiere el arranque de cada proceso ni la confusión entre herramientas parecidas. Además, si algún día trabajas con un endpoint propio o desactivas la búsqueda de herramientas, vuelves al modo de carga completa y ahí sí entra todo. Podar es barato; medirlo primero te dice cuánto.

**¿Cuántos MCPs es 'demasiados'?**

No hay número: hay bytes y uso. Dos herramientas de docs no pesan; siete herramientas de análisis estático pesan 53 KB. La pregunta correcta es si el servidor se llama varias veces por semana desde el chat. En mi caso 13 servidores en scope user era demasiado no por el número sino porque cuatro eran copias y uno tenía CLI.

**¿Puedo tener el mismo servidor con dos credenciales sin duplicar el esquema?**

Solo si el servidor soporta multicuenta con una herramienta de selección; entonces es una instancia con N cuentas. Si no lo soporta, cada credencial es una instancia y duplica los bytes completos. Alternativa: instancia por cuenta en scope local del proyecto que la usa, para que solo cargue ahí.

**¿Qué diferencia hay entre remove y disabledMcpServers?**

remove borra la entrada de la configuración, con sus variables y su OAuth; para volver tienes que reinstalar. El toggle de /mcp deja todo configurado y solo evita que se conecte en ese proyecto (queda anotado en disabledMcpServers dentro de ~/.claude.json); lo prendes desde el mismo panel. Usa remove para lo que no vuelve y el toggle para lo ocasional o lo que solo sobra en algunas carpetas.

**¿Apagar un servidor en un proyecto lo apaga en todos?**

No. El toggle de /mcp se guarda por proyecto, así que un servidor de scope user puede estar apagado en tu carpeta de contenido y prendido en la de la app. Es la forma más barata de tener muchos configurados y pocos activos sin andar moviendo scopes. Si quieres apagarlo en todos lados, o lo apagas carpeta por carpeta (el script del repo lo hace desde la terminal) o lo quitas con remove.

**¿No basta con /compact o con usar un modelo más barato?**

Para la conversación larga, sí ayudan; para los MCPs, no. La lista de herramientas se inyecta en cada petición sin importar cuánto hayas compactado, y un modelo más barato paga menos por el mismo peso. Las dos cosas se atacan por separado: compacta y cierra sesiones para la conversación, poda y apaga por proyecto para las herramientas.

**¿Un MCP que no uso puede ser un problema de seguridad además de peso?**

Sí, y por la misma razón por la que pesa: es un proceso que arranca con tus credenciales en cada conversación. Un servidor con token en claro, un MCP de shell sin allowlist o la auto-aprobación de .mcp.json en repos clonados son los tres hallazgos típicos. Pasa tu configuración por un escáner (npx ecc-agentshield scan) después de la poda; lo que quitaste por peso ya no aparece, y lo que quedó lo revisas con ojos de riesgo.

**¿Cómo veo cuánto contexto ocupan los MCPs en una conversación?**

Escribe /context en Claude Code: desglosa la ventana por tipo, incluida la parte de herramientas MCP. Para el consumo acumulado por servidor, /usage muestra la atribución de las últimas 24 horas o 7 días. Para el peso en frío por servidor, el script de esta guía.

## Cierre de la guía

La poda no es una decisión de una vez: cada MCP nuevo que instales entra con la misma pregunta de si tiene CLI, si es de un solo proyecto, si lo vas a usar esta semana y con qué llaves arranca. Mide con el script, decide con la tabla de uso, apaga por proyecto lo que solo sobra en algunas carpetas, y deja anotado el comando de reinstalación de lo que quites. Un inventario que se revisa cada mes se queda ligero solo. Esta guía vive en el Lab de David Iriza.

## Fuentes oficiales

- [Conectar Claude Code a herramientas vía MCP (Docs de Claude Code)](https://code.claude.com/docs/en/mcp): Scopes local, project y user, subcomandos de claude mcp, disabledMcpServers, la búsqueda diferida de herramientas y las variables de timeout y de tamaño de salida.
- [Manejar costos (Docs de Claude Code)](https://code.claude.com/docs/en/costs): La sección 'Reduce MCP server overhead': preferir CLIs, desactivar servidores sin uso, y qué muestran /context y la atribución por servidor de /usage.
- [Especificación MCP: Tools (Model Context Protocol)](https://modelcontextprotocol.io/specification/2025-06-18/server/tools): Qué contiene una definición de herramienta (name, description, inputSchema) y cómo funciona tools/list con paginación, que es lo que usa el script de medición.
- [Introducción a MCP (Model Context Protocol)](https://modelcontextprotocol.io/introduction): Qué es el protocolo y por qué el mismo servidor sirve a distintos clientes.
- [Referencia de settings (Docs de Claude Code)](https://code.claude.com/docs/en/settings-reference): allowedMcpServers, deniedMcpServers, enableAllProjectMcpServers y las claves de aprobación de .mcp.json; confirma que disabledMcpServers no es una clave de settings.json.
- [AgentShield (repositorio en GitHub)](https://github.com/affaan-m/agentshield): Escáner de configuraciones de Claude Code: secretos, permisos, hooks y servidores MCP. Se corre con npx ecc-agentshield scan; herramienta de terceros con licencia MIT.

## Repositorios

- [davidiriza-lab/dieta-de-mcps](https://github.com/davidiriza-lab/dieta-de-mcps): Medidor sin dependencias de cuánto pesa cada MCP de Claude Code (tools, bytes, tokens) y checklist de poda por scope. (MIT)

## Guías que se conectan con esta

- [vigia-de-contexto](https://www.davidiriza.com/lab/vigia-de-contexto): El hook que avisa cuando la conversación pasa de 200k y 400k tokens: la otra mitad del mismo diagnóstico de consumo.
- [inicio-y-cierre-de-sesion](https://www.davidiriza.com/lab/inicio-y-cierre-de-sesion): La causa principal del gasto medido eran las conversaciones de varios días; esta guía ataca la segunda.

---

Guía escrita con la información oficial disponible al 28 de agosto de 2026. Esta página no está afiliada a Anthropic. Ante la duda, revisa la documentación oficial de Claude Code sobre MCP: https://code.claude.com/docs/en/mcp

---

Versión markdown de https://www.davidiriza.com/lab/dieta-de-mcps — el sitio negocia por `Accept: text/markdown` y por sufijo `.md`. Índice para agentes: https://www.davidiriza.com/llms.txt