Nivel inicial16 min de lectura · Revisado el

Qué es MCP (Model Context Protocol) y cómo funciona

Qué es MCP: un agente conectado a una regleta común, MCP, en la que se enchufan tres servicios: stock, archivos y correo. Qué es MCPrubentejera.com Tu agenteStockArchivosCorreoMCPUn enchufe comúnpara todo
Cada servicio se enchufa una vez a la misma regleta, y cualquier agente que la tenga puede usarlo.

MCP (Model Context Protocol, en español «protocolo de contexto del modelo») es un protocolo abierto que define cómo una aplicación de IA se conecta con herramientas y datos externos: un repositorio, una base de datos, un calendario o el inventario de una tienda. Sin un estándar, cada aplicación tendría que programar su propia integración con cada servicio. Con MCP, el servicio se expone una vez, como servidor MCP, y cualquier aplicación que hable el protocolo puede usarlo.

Si usas un agente de IA para programar, MCP es lo que le permite consultar tu repositorio o tu inventario en lugar de trabajar solo con lo que tiene en el contexto. Y también es una puerta: cada servidor que conectas es una capacidad que el agente puede usar por su cuenta. Aquí verás cómo funciona por dentro, cómo se escribe y se prueba un servidor MCP mínimo sin ningún modelo, con el código ejecutado, y qué riesgos asumes al conectarlo. Con la mirada de la IA Limpia, el enfoque de esta web: un servidor MCP es una pieza de software como cualquier otra, que se diseña, se prueba y se protege igual.

Un enchufe común para la IA

Piensa en los enchufes de los hoteles. Si cada país tiene uno distinto, cada aparato necesita un cable para cada país. Con diez aparatos y diez países, cien cables. Si todos los hoteles tuvieran la misma regleta, cada fabricante haría una sola clavija y cada hotel pondría una sola regleta: diez más diez.

MCP es esa regleta común. Cada aplicación de IA (Claude Code, un editor, un chat) aprende a hablar MCP una vez, y cada servicio (tu inventario, tu repositorio, tu correo) se expone como servidor MCP una vez. La documentación oficial de MCP usa un símil parecido: compara MCP con un puerto USB-C para las aplicaciones de IA.

El símil se queda corto en dos cosas importantes. Un aparato enchufado no decide nada; con MCP, es el modelo quien decide qué herramienta usar y con qué datos, así que lo que enchufas es algo que el agente puede usar por su cuenta. Y enchufar algo a una regleta que te ha dado un desconocido puede salir caro: un servidor MCP de terceros es código que se ejecuta en tu máquina o datos que llegan a tu agente. Las dos cosas se ven más abajo.

Para qué sirve MCP: ejemplos de servidores

MCP sirve para que un agente use algo que no está en su modelo ni en su contexto: consultar una base de datos, leer incidencias, mover un navegador o mirar el stock de una tienda. Un ejemplo real es chrome-devtools-mcp, un servidor MCP que publica Google para que un agente de programación controle Chrome, lea la consola y las peticiones y pase auditorías de Lighthouse; se cuenta en el artículo sobre Chrome DevTools. Más abajo se construye uno desde cero.

Quién creó MCP y quién lo mantiene

Anthropic publicó MCP como código abierto el 25 de noviembre de 2024, con la especificación, los SDK (las bibliotecas para escribir clientes y servidores en varios lenguajes) y un repositorio de servidores de ejemplo. El 9 de diciembre de 2025, la Linux Foundation anunció la Agentic AI Foundation (AAIF), con MCP como uno de sus proyectos fundadores, donado por Anthropic. Es la misma fundación que mantiene el formato AGENTS.md.

Hoy el proyecto se organiza como Model Context Protocol a Series of LF Projects, LLC, con licencia Apache 2.0 para el código y la especificación. Las decisiones técnicas las toman sus mantenedores, que lo son a título personal y no en nombre de su empresa: según su página de gobierno, no hay puestos reservados para ninguna compañía.

La especificación lleva por versión una fecha. La vigente a 14 de noviembre de 2026 es la 2026-07-28, que cambió algo importante: MCP pasó a ser un protocolo sin estado (stateless). Antes, cliente y servidor abrían una sesión con un saludo inicial (initialize); ahora, cada petición viaja sola y lleva dentro la versión del protocolo y lo que sabe hacer el cliente. Para un servidor sencillo como el de este artículo, la diferencia apenas se nota; en uno en internet, cualquier máquina puede atender cualquier petición, sin tener que recordar una sesión.

Cómo funciona MCP: host, cliente y servidor

La especificación define tres papeles:

  • Host: la aplicación que tiene el modelo y con la que hablas, como Claude Code o un editor con un asistente. Crea los clientes, decide a qué servidores se conectan y pide tu permiso.
  • Cliente: el conector que el host crea para hablar con un servidor. Si el host usa tres servidores, tiene tres clientes, uno por servidor.
  • Servidor: el programa que ofrece algo concreto, como consultar el stock de una tienda. Puede ser un proceso en tu máquina o un servicio en internet.

Una de sus reglas de diseño explica mucho del protocolo: un servidor no debe poder leer la conversación entera ni «ver» lo que hacen los demás servidores. Recibe solo lo que necesita para cada petición, y la conversación se queda en el host. Encaja con que haya un cliente por servidor: cada conexión está aislada de las demás.

Por debajo, los mensajes son JSON-RPC 2.0: texto en formato JSON con un método (tools/list, tools/call), sus parámetros y un número para casar cada respuesta con su petición. Según la propia especificación, toma parte de su inspiración del Language Server Protocol, el estándar que permite que un mismo plugin de un lenguaje de programación funcione en muchos editores.

MCP, API, RAG y tool calling: en qué se diferencian

Son cuatro cosas que se confunden a menudo:

  • Tool calling (llamada a herramientas) es cómo un modelo pide usar una herramienta: en lugar de responder con texto, devuelve el nombre de la herramienta y sus argumentos, y el programa que lo rodea la ejecuta.
  • MCP es cómo ese programa, el host, descubre qué herramientas ofrece un servidor y las llama. La guía del SDK de TypeScript lo deja claro: la lista que devuelve un servidor MCP (nombre, descripción y esquema de cada herramienta) encaja tal cual con la definición de herramientas que aceptan las API de modelos con tool calling.
  • Una API es lo que el servidor MCP puede tener detrás: la de tu tienda, la de GitHub o una base de datos. MCP no la sustituye; la envuelve para que cualquier agente pueda usarla.
  • RAG (generación aumentada por recuperación) es una técnica: buscar documentos relevantes y añadirlos al contexto del modelo antes de que responda. No compite con MCP. Un servidor MCP puede ser la vía por la que el agente hace esa búsqueda, y además puede ofrecer herramientas que actúan, no solo datos que se leen; esta comparación es interpretación nuestra.

Transportes: stdio y HTTP

El transporte es el camino por el que viajan esos mensajes. La especificación vigente define dos:

  • stdio: el cliente arranca el servidor como un proceso hijo y le habla por su entrada y su salida estándar, un mensaje JSON por línea. Es lo habitual para servidores locales. Tiene una regla que conviene saber: el servidor no puede escribir en su salida estándar nada que no sea un mensaje MCP. Un console.log de depuración rompe la conexión; los mensajes para personas van a la salida de errores (stderr).
  • Streamable HTTP: el servidor es un servicio aparte, con una única dirección (por ejemplo, https://ejemplo.com/mcp) a la que el cliente envía cada mensaje con un POST. Es lo que se usa para servidores remotos y puede atender a muchos clientes. La especificación exige comprobar la cabecera Origin de cada petición y recomienda, en local, escuchar solo en 127.0.0.1 y pedir autenticación siempre.

El transporte antiguo HTTP+SSE, de la primera versión, está obsoleto desde la versión 2025-03-26.

Qué ofrece un servidor: herramientas, recursos y prompts

Un servidor puede ofrecer tres tipos de cosas, que la especificación llama primitivas y distingue por quién decide usarlas:

Primitiva Quién decide Ejemplo
Herramientas (tools) El modelo Consultar el stock, crear una incidencia, escribir un fichero
Recursos (resources) La aplicación El contenido de un fichero o el historial de git, que la aplicación añade al contexto
Prompts La persona Plantillas que eliges tú, como un comando /revisar en un menú

Las herramientas son las más usadas y las más delicadas, porque es el modelo quien decide cuándo llamarlas. El cliente también puede ofrecer algo al servidor: la elicitación, que permite al servidor pedirte un dato que le falta a mitad de una operación. Otras dos funciones del cliente, sampling (que el servidor pida una respuesta al modelo del host) y roots (que el cliente le diga al servidor qué carpetas puede tocar), quedaron obsoletas en la versión 2026-07-28, igual que el envío de registros por el protocolo (en stdio, se escriben en stderr). Pueden desaparecer en la primera revisión que salga a partir del 28 de julio de 2027.

Cómo crear un servidor MCP en TypeScript

El ejemplo es inventado: una tienda de bicis quiere que su agente pueda consultar cuántas unidades quedan de un producto. Tiene tres ficheros:

  • inventario.ts: la regla de negocio, sin nada de MCP. Devuelve datos, no frases.
  • servidor.ts: el servidor MCP, que traduce cada petición a una llamada a esa regla, y su resultado, a un texto para el modelo.
  • cliente.ts: un cliente MCP sin modelo, para probar el servidor.

Usa el SDK oficial de TypeScript en su versión 2, que separa el servidor y el cliente en dos paquetes y es la que implementa la especificación 2026-07-28. La versión 1, el paquete @modelcontextprotocol/sdk, sigue publicada y recibe correcciones durante al menos seis meses tras la llegada de la 2; si ves ejemplos con importaciones distintas, suelen ser de ella.

Node 24 ejecuta TypeScript directamente: quita los tipos y ejecuta el resultado, sin comprobarlos. Para comprobarlos aparte está tsc, el compilador de TypeScript. En una carpeta nueva, con un package.json que tenga "type": "module" (los ejemplos usan import y await fuera de funciones, y Node decide por ese campo cómo cargar los ficheros .ts):

npm install --save-exact \
  @modelcontextprotocol/[email protected] \
  @modelcontextprotocol/[email protected] \
  [email protected]

La regla de negocio, sin MCP

// inventario.ts: el dominio. No sabe nada de MCP ni de modelos de IA.
export type Inventario = ReadonlyMap<string, number>;

export type Stock =
  | { estado: 'no-existe' }
  | { estado: 'agotado' }
  | { estado: 'disponible'; unidades: number };

export function consultarStock(inventario: Inventario, referencia: string): Stock {
  const unidades = inventario.get(referencia);
  if (unidades === undefined) return { estado: 'no-existe' };
  if (unidades === 0) return { estado: 'agotado' };
  return { estado: 'disponible', unidades };
}

Se prueba con el ejecutor de tests de Node, sin servidor y sin modelo:

// inventario.test.ts
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { consultarStock } from './inventario.ts';

const inventario = new Map([['CASCO-M', 4], ['TIMBRE', 0]]);

test('dice cuántas unidades quedan', () => {
  assert.deepEqual(
    consultarStock(inventario, 'CASCO-M'),
    { estado: 'disponible', unidades: 4 }
  );
});

test('avisa de un producto agotado', () => {
  assert.deepEqual(consultarStock(inventario, 'TIMBRE'), { estado: 'agotado' });
});

test('avisa de una referencia que no existe', () => {
  assert.deepEqual(consultarStock(inventario, 'SILLIN'), { estado: 'no-existe' });
});
node --test
✔ dice cuántas unidades quedan (1.390453ms)
✔ avisa de un producto agotado (0.130767ms)
✔ avisa de una referencia que no existe (0.135946ms)
ℹ tests 3

El servidor MCP

// servidor.ts: el adaptador. Traduce MCP a una llamada al dominio,
// y el resultado, a un texto para el modelo.
import { McpServer } from '@modelcontextprotocol/server';
import { serveStdio } from '@modelcontextprotocol/server/stdio';
import * as z from 'zod/v4';
import { consultarStock, type Inventario, type Stock } from './inventario.ts';

function describir(referencia: string, stock: Stock): string {
  switch (stock.estado) {
    case 'no-existe': return `No existe la referencia ${referencia}.`;
    case 'agotado': return `${referencia}: agotado.`;
    case 'disponible': return `${referencia}: quedan ${stock.unidades} unidades.`;
  }
}

function crearServidor(inventario: Inventario): McpServer {
  const servidor = new McpServer({ name: 'stock-tienda', version: '1.0.0' });

  servidor.registerTool(
    'consultar_stock',
    {
      // Lo que lee el modelo para decidir si la usa
      description:
        'Dice cuántas unidades quedan de un producto de la tienda de bicis',
      // El SDK valida los argumentos con este esquema
      inputSchema: z.object({
        referencia: z.string()
          .describe('Referencia del producto, por ejemplo CASCO-M')
      }),
      // Una pista para el cliente: esta herramienta no cambia nada
      annotations: { readOnlyHint: true }
    },
    async ({ referencia }) => {
      const stock = consultarStock(inventario, referencia);
      return { content: [{ type: 'text', text: describir(referencia, stock) }] };
    }
  );

  return servidor;
}

// Punto de montaje: aquí se decide de dónde salen los datos
const inventario = new Map([['CASCO-M', 4], ['TIMBRE', 0], ['LUZ-LED', 12]]);
serveStdio(() => crearServidor(inventario));
// A stderr: la salida estándar es solo para mensajes MCP
console.error('stock-tienda: servidor MCP escuchando por stdio');

Cuatro cosas que mirar:

  • La descripción es para el modelo. Es lo que lee para decidir si esta herramienta le sirve. Una descripción vaga hace que la use cuando no toca, o que no la use.
  • El esquema de entrada (con Zod, una biblioteca de validación) se convierte en el JSON Schema que ve el modelo y, además, el SDK lo usa para rechazar argumentos inválidos antes de que lleguen a tu código.
  • El texto para el modelo lo escribe el adaptador. El dominio devuelve un dato ({ estado: 'agotado' }) y describir lo convierte en la frase que lee el modelo. Otra entrada, como una API REST, devolvería el mismo dato en JSON.
  • No hay console.log. El mensaje de arranque va a stderr, como pide el transporte stdio.

En una tienda real, el inventario vendría de una base de datos; aquí es un Map para que el ejemplo quepa en pantalla.

Un cliente que lo prueba, sin modelo

// cliente.ts: un cliente MCP sin modelo. Lista las herramientas y llama a una.
import { Client } from '@modelcontextprotocol/client';
import { StdioClientTransport } from '@modelcontextprotocol/client/stdio';

const cliente = new Client(
  { name: 'cliente-de-prueba', version: '1.0.0' },
  // Hablar la versión 2026-07-28 de la especificación
  { versionNegotiation: { mode: { pin: '2026-07-28' } } }
);
// El cliente arranca el servidor como proceso hijo
const transporte = new StdioClientTransport({
  command: 'node',
  args: ['servidor.ts']
});

try {
  await cliente.connect(transporte);

  const { tools } = await cliente.listTools();
  for (const herramienta of tools) {
    console.log(herramienta.name, '—', herramienta.description);
  }

  const resultado = await cliente.callTool({
    name: 'consultar_stock',
    arguments: { referencia: 'CASCO-M' }
  });
  for (const bloque of resultado.content) {
    if (bloque.type === 'text') console.log(bloque.text);
  }
} finally {
  await cliente.close(); // cierra la conexión y el servidor
}
node cliente.ts
stock-tienda: servidor MCP escuchando por stdio
consultar_stock — Dice cuántas unidades quedan de un producto de la tienda de bicis
CASCO-M: quedan 4 unidades.

La primera línea es el aviso que el servidor escribe en stderr y que, con el cliente del SDK, sale por defecto en la misma terminal. Las otras dos son lo que hace un host con un modelo, pero sin el modelo: pedir la lista de herramientas y llamar a una.

Un detalle que no está a la vista: sin la opción versionNegotiation, el cliente del SDK de TypeScript 2.4.0 sigue hablando por defecto la versión anterior, la 2025-11-25, con su saludo inicial, para no romper con servidores antiguos. Se comprobó capturando los mensajes. Sin la opción, el primero es un initialize. Con ella, el cliente arranca primero una copia del servidor solo para preguntarle con server/discover qué versiones admite y qué sabe hacer; después arranca el servidor de verdad y le envía tools/list y tools/call, cada uno con la versión dentro.

Lo que viaja por debajo

Como el transporte stdio es texto, se puede hablar con el servidor sin ningún cliente: basta con escribirle un mensaje JSON-RPC en una línea. En un fichero peticion.jsonl:

{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"consultar_stock","arguments":{"referencia":"TIMBRE"},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientCapabilities":{}}}}

La misma petición, formateada para leerla (en el fichero va en una sola línea):

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "consultar_stock",
    "arguments": { "referencia": "TIMBRE" },
    "_meta": {
      "io.modelcontextprotocol/protocolVersion": "2026-07-28",
      "io.modelcontextprotocol/clientCapabilities": {}
    }
  }
}
node servidor.ts < peticion.jsonl
stock-tienda: servidor MCP escuchando por stdio
{"result":{"content":[{"type":"text","text":"TIMBRE: agotado."}],"resultType":"complete","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"stock-tienda","version":"1.0.0"}}},"jsonrpc":"2.0","id":1}

La petición lleva en _meta la versión del protocolo y lo que sabe hacer el cliente: es lo que significa que la versión 2026-07-28 sea sin estado. Si en lugar de una referencia se envía un número ("referencia":42), el dominio ni se entera: la respuesta lleva "isError":true y el texto Input validation error: Invalid arguments for tool consultar_stock: referencia: Invalid input: expected string, received number. El modelo lee ese error y puede corregir la llamada.

Si prefieres una herramienta ya hecha, el proyecto mantiene el MCP Inspector, con una interfaz web, otra de terminal y un modo de línea de comandos. Contra este servidor:

npx @modelcontextprotocol/[email protected] --cli \
  node servidor.ts \
  --method tools/call \
  --tool-name consultar_stock \
  --tool-arg referencia=TIMBRE
stock-tienda: servidor MCP escuchando por stdio
{
  "content": [
    {
      "type": "text",
      "text": "TIMBRE: agotado."
    }
  ]
}

Probado el 14 de noviembre de 2026 con Node.js 24.22.3, @modelcontextprotocol/server y @modelcontextprotocol/client 2.4.0, Zod 4.6.7, MCP Inspector 2.15.0 y TypeScript 7.0.2 (tsc sin errores de tipos).

Cómo conectar un servidor MCP a Claude Code

Si nunca has usado Claude Code, el tutorial de cómo usar Claude Code explica cómo instalarlo y trabajar con él paso a paso.

Con el servidor probado, conectarlo a un host es darle el comando que lo arranca. En Claude Code, desde la carpeta del proyecto:

claude mcp add --scope project --transport stdio \
  stock-tienda -- node servidor.ts
Added stdio MCP server stock-tienda with command: node servidor.ts to project config
File modified: …/.mcp.json

Todo lo que va después de -- es el comando del servidor, tal cual; lo de antes son opciones de Claude Code. Con --scope project, la configuración se guarda en un fichero .mcp.json en la raíz del proyecto, que se sube al repositorio y comparte todo el equipo:

{
  "mcpServers": {
    "stock-tienda": {
      "type": "stdio",
      "command": "node",
      "args": [
        "servidor.ts"
      ],
      "env": {}
    }
  }
}

Sin --scope, el ámbito por defecto es local: solo para ti y solo en ese proyecto. Con --scope user, para ti en todos tus proyectos. Para un servidor remoto se usa --transport http y su dirección, por ejemplo claude mcp add --transport http mi-servidor https://ejemplo.com/mcp.

Para ver los servidores configurados y si responden, claude mcp list. Recién añadido, el de la tienda aparece así:

stock-tienda: node servidor.ts - ⏸ Pending approval (run `claude` to approve)

En la terminal, delante de Pending approval aparece un icono de pausa. Es una medida de seguridad: los servidores que llegan en el .mcp.json de un proyecto no se usan hasta que los apruebas en una sesión interactiva. Ojo: según la documentación, en las ejecuciones sin interfaz (claude -p), en las sesiones del Agent SDK y en algunas sesiones en la nube no hay a quién preguntar, y se cargan sin pedir aprobación. Si no quieres que un servidor del proyecto se cargue nunca, la documentación da varias formas, como añadirlo a disabledMcpjsonServers o arrancar con --strict-mcp-config, que solo carga los servidores que le pasas con --mcp-config.

Dentro de la sesión, /mcp muestra el estado de cada servidor. Y sus herramientas se pueden controlar con las mismas reglas de permisos que el resto: mcp__stock-tienda__consultar_stock es esta herramienta y mcp__stock-tienda__*, todas las de ese servidor.

Comprobado con Claude Code 2.1.323 y su documentación del 14 de noviembre de 2026 (última versión publicada, 2.1.325). La aprobación y el uso de la herramienta desde una sesión no se han probado aquí.

En las aplicaciones de Claude (la web y la de escritorio) también se pueden añadir servidores MCP remotos como conectores personalizados; según la ayuda de Anthropic, consultada el 15 de noviembre de 2026, el plan gratuito permite uno. Otros hosts también lo admiten. La web oficial de MCP cita, entre otros, Claude, ChatGPT, Visual Studio Code y Cursor, y la guía del SDK de TypeScript explica cómo registrar el mismo servidor en VS Code y en Cursor: cambia dónde y cómo se escribe la configuración, no el comando que arranca el servidor.

Un servidor MCP es un adaptador

Lo que sigue es interpretación nuestra, no algo que diga la especificación.

En la arquitectura hexagonal, también llamada de puertos y adaptadores, la lógica de negocio no depende de cómo le llegan las peticiones de fuera: de esa traducción se encargan los adaptadores. El ejemplo tiene justo esa forma. El dominio (consultarStock) no sabe que existe MCP y devuelve un dato, no una frase. El servidor es un adaptador: recibe una petición en el formato de fuera, la traduce a una llamada al dominio y traduce la respuesta de vuelta. Mañana la misma regla puede estar detrás de una API REST o de un comando de terminal sin tocar una línea de inventario.ts.

Eso tiene tres consecuencias prácticas:

  1. La lógica se prueba sin el modelo. Los tests del inventario no arrancan ningún servidor ni llaman a ninguna IA, así que son rápidos y dan siempre el mismo resultado.
  2. El adaptador se prueba sin el modelo. El cliente de prueba y la petición a mano comprueban que el servidor habla MCP bien: que lista la herramienta, que la llama y que rechaza un argumento inválido. Ninguna de esas pruebas depende de lo que decida un modelo ese día.
  3. El servidor se mantiene fino. Si un servidor MCP empieza a acumular reglas de negocio, esas reglas quedan atadas al protocolo y solo se pueden probar a través de él. Y si el protocolo cambia, como cambió con la versión 2026-07-28, se toca el adaptador y no la regla de negocio.

Lo único que no se prueba sin modelo es si el modelo elige bien la herramienta, y eso depende sobre todo de su nombre y su descripción, y en Claude Code también de las instrucciones del servidor.

Cada herramienta es un permiso: los riesgos

La especificación de MCP lo dice sin rodeos: una herramienta equivale a ejecutar código arbitrario y hay que tratarla con cautela, y el host debe pedir el consentimiento explícito del usuario antes de invocar cualquiera. También recomienda que siempre haya una persona que pueda denegar una llamada. Pero aclara que el protocolo no puede imponer nada de esto por sí mismo: depende de cómo esté hecho cada host y cada servidor.

En la práctica, al conectar un servidor le das al agente una capacidad nueva que puede usar por su cuenta. Tres riesgos merecen atención:

  • Inyección de instrucciones (prompt injection). Lo que devuelve una herramienta entra en el contexto del modelo. Si un servidor trae contenido de fuera (páginas web, incidencias, correos), ese contenido puede llevar instrucciones escondidas que el modelo confunda con las tuyas. Y no solo lo que devuelve: la descripción de cada herramienta también la escribe el servidor y la lee el modelo, así que un servidor malicioso puede esconder instrucciones ahí. La especificación pide no fiarse de lo que un servidor que no es de confianza dice de sus herramientas. La documentación de Claude Code avisa de lo mismo: comprueba que confías en cada servidor, porque los que traen contenido externo te exponen a la inyección de instrucciones. Simon Willison llama «trifecta letal» a la combinación más peligrosa: un agente que puede leer datos privados, recibe contenido no confiable y puede enviar algo hacia fuera.
  • Herramientas con demasiado alcance. consultar_stock solo puede leer una cifra. Una herramienta ejecutar_sql que acepta cualquier consulta puede leer o borrar la base de datos entera. La especificación pide a los servidores validar todas las entradas y controlar el acceso, y su guía de seguridad recomienda, para la autorización de los servidores remotos, pedir los permisos mínimos y ampliarlos solo cuando hagan falta. Aplicado al diseño de herramientas (interpretación nuestra): mejor herramientas con un propósito concreto y un alcance acotado, como consultar_stock o buscar_pedido, que una genérica como ejecutar_sql que puede hacerlo todo.
  • Servidores de terceros. Un servidor local se ejecuta con tus permisos: puede leer tus ficheros y tus claves. La guía de seguridad de MCP describe el ataque de un comando de arranque malicioso escondido en una configuración, y pide que un cliente que permita añadir un servidor con un clic enseñe antes el comando completo y espere tu aprobación. También recomienda arrancar los servidores aislados, con acceso limitado a ficheros y red. Antes de añadir uno, lee su comando y su código, o úsalo dentro de un contenedor.

Una advertencia sobre el ejemplo: readOnlyHint: true es una pista, no una garantía. La especificación pide a los clientes que no se fíen de esas anotaciones si el servidor no es de confianza. La herramienta del ejemplo solo lee porque su código solo lee, no porque lo diga la anotación.

Límites

  • MCP cambia deprisa. La versión 2026-07-28 rompió con la anterior (sin estado, sin sesiones en HTTP) y el cliente del SDK de TypeScript sigue usando la 2025-11-25 por defecto para no romper con servidores antiguos. Lo que lees aquí corresponde a noviembre de 2026.
  • El ejemplo es local y sin autenticación. Un servidor remoto necesita autorización (MCP la define sobre OAuth) y las comprobaciones de HTTP que se mencionan arriba. Eso queda fuera de un artículo de iniciación.
  • Que un servidor funcione con el cliente de prueba no asegura que el modelo lo use bien. Si la descripción es ambigua, el modelo puede no llamarlo o llamarlo con argumentos que no tocan.
  • Más servidores no es mejor. Cada herramienta conectada es un permiso más y ocupa algo de contexto. En Claude Code, con la búsqueda de herramientas activada por defecto, al empezar la sesión solo se cargan los nombres de las herramientas y las instrucciones de cada servidor; la definición completa, cuando el modelo la necesita. Por qué el contexto de un agente es un recurso limitado se explica en cómo funciona un agente de IA para programar.

Tu siguiente paso

Antes de conectar tu primer servidor MCP, o si ya tienes alguno:

  1. Haz la lista de los servidores que tiene tu agente y quita los que no uses. En Claude Code, con claude mcp list.
  2. Para cada uno, pregúntate qué es lo peor que puede hacer su herramienta más potente, y si trae contenido de fuera.
  3. Si escribes uno, separa la lógica del servidor y pruébalo con un cliente sin modelo antes de conectarlo a un agente.

Siguiente lectura: dónde dejar escrito qué servidores usa el agente y por qué, para que todo el equipo lo sepa, en AGENTS.md y CLAUDE.md: qué son y qué poner.

El contenido sobre IA envejece rápido. Última revisión: 14 de noviembre de 2026.

Fuentes

Consultadas el 14 de noviembre de 2026.