Conecta Claude a herramientas y agentes locales con MCP

Intermedio

Quieres que Claude sea el cerebro y que tu máquina aporte las manos — leer tus archivos, consultar tu base de datos, ejecutar tu script, incluso llamar a un modelo local o a un agente local, todo sin que tus datos salgan del portátil. Esa sinergia ya tiene un estándar: el Model Context Protocol (MCP). En una sola frase: MCP es un estándar abierto que permite a un cliente de IA llamar a herramientas y datos externos a través de pequeños programas llamados servidores MCP — y esos servidores pueden ejecutarse de forma privada, localmente, en tu propia máquina. Esta página muestra qué es MCP, cómo encaja la arquitectura local, cómo añadir un servidor local a Claude y cómo construir uno propio, minúsculo.

What you'll learn

• Explicar MCP en una frase — un estándar abierto para que un cliente de IA pueda llamar a herramientas y datos externos a través de servidores MCP
• Ver la arquitectura local: un cliente MCP (Claude Code / Claude Desktop) hablando con un servidor MCP local por stdio
• Entender por qué ESTA es la sinergia Claude-como-cerebro + capacidades-locales que quieres
• Añadir un servidor MCP local a Claude con un solo comando
• Construir un servidor MCP minúsculo que exponga una herramienta
• Conocer el límite de confianza — los servidores MCP actúan con TUS privilegios, así que instala solo lo que confíes

Qué es MCP (en una sola frase)

MCP es un estándar abierto para conectar aplicaciones de IA con sistemas externos. Un cliente de IA (como Claude) habla un protocolo; cualquier servidor MCP que lo hable puede conectarse y ofrecer al cliente nuevas capacidades. La analogía oficial es un puerto USB-C para la IA: en lugar de una integración a medida por herramienta, construyes hacia un único conector y funciona en todas partes.

Anthropic introdujo y liberó MCP como código abierto, y desde el primer día venía con soporte para servidores MCP locales para que Claude pudiera conectarse a sistemas internos y conjuntos de datos que se ejecutan en tu propia máquina.

Última verificación: 2026-06-28.

Las cifras de adopción, la fecha de revisión de la especificación, la gobernanza (la administración de MCP) y la lista exacta de clientes que soportan MCP cambian con frecuencia. Trata cualquier cifra concreta como perecedera y confírmala en modelcontextprotocol.io y en el anuncio de Anthropic. Los hechos duraderos — MCP es un estándar abierto, cliente ↔ servidor, los servidores pueden ejecutarse localmente, ampliamente adoptado entre clientes — son estables.

Confirma con la fuente oficial.

Un servidor MCP puede exponer tres tipos de cosas al cliente:

• Herramientas (Tools) — acciones que el modelo puede invocar (leer un archivo, ejecutar una consulta, llamar a una API). Tiene la misma forma que el uso de herramientas nativo del modelo: una capacidad con nombre y entradas tipadas.
• Recursos (Resources) — datos que el cliente puede leer (archivos, registros, documentos).
• Prompts — plantillas de prompt reutilizables y parametrizadas que el servidor ofrece.

Para esta página lo destacado son las herramientas: un servidor MCP local es la forma de entregarle a Claude una nueva capacidad privada.

Por qué esta es la sinergia que quieres

Lo que la gente quiere decir con "Claude como cerebro, mi ordenador como cuerpo" es exactamente la división cliente/servidor de MCP:

• Claude es el orquestador. Lee tu objetivo, decide qué herramienta llamar, la llama, lee el resultado y decide el siguiente paso.
• Los servidores MCP locales son las capacidades. Cada uno es un pequeño programa que tú ejecutas en tu máquina: un servidor de sistema de archivos, un servidor de base de datos, un envoltorio alrededor de un script local, incluso un servidor que llama a un modelo local o delega el trabajo a un agente local.

Como el servidor se ejecuta localmente y Claude le habla a través de la entrada/salida estándar de tu propia máquina, tus datos y acciones permanecen en tu hardware — el modelo orquesta, pero las lecturas de archivos, el SQL y la ejecución de scripts ocurren localmente. Esa es la versión que preserva la privacidad del trabajo agéntico: el cerebro en la nube (o también local), las manos estrictamente en tu equipo.

Y como MCP es un único estándar abierto adoptado por muchos clientes, un servidor que construyas no queda atado a una sola aplicación. El mismo servidor local que conectas a Claude Code puede ser usado por otros clientes que hablen MCP — constrúyelo una vez, reutilízalo en todas partes.

La arquitectura local

La imagen útil más pequeña tiene dos partes y un canal:

• Cliente MCP (host). La aplicación de IA — por ejemplo Claude Code o Claude Desktop. Contiene el modelo y decide qué herramientas llamar.
• Servidor MCP. Un proceso separado que anuncia herramientas/recursos/prompts y los ejecuta cuando se le pide.
• Transporte. Para servidores locales, el cliente lanza el servidor como un subproceso y se comunican por stdio (entrada/salida estándar) usando mensajes JSON-RPC. Sin red, sin puerto — solo una tubería local entre dos procesos de tu máquina. (También existen servidores remotos, sobre HTTP; esta página trata el caso local, por stdio.)

┌─────────────────────────┐         stdio (JSON-RPC)        ┌──────────────────────────┐
│  MCP CLIENT / HOST       │ ──── launches as subprocess ──▶ │  LOCAL MCP SERVER         │
│  Claude Code / Desktop   │ ◀── tools/resources/prompts ─── │  filesystem · db · script │
│  (the model = the brain) │                                 │  · local model / agent    │
└─────────────────────────┘                                  └──────────────────────────┘
                                                              runs on YOUR machine, YOUR data

El modelo nunca toca tu disco directamente — le pide al servidor local, y el servidor (ejecutándose con tus permisos) hace el trabajo y devuelve un resultado.

Añade un servidor MCP local a Claude

La vía más rápida es el comando claude mcp add de Claude Code, que registra un servidor que el cliente lanzará por stdio. La forma general es un nombre, seguido del comando que arranca el servidor.

Guided walkthrough1 of 4

1. Empieza con un servidor de referencia oficial (por ejemplo, el servidor de sistema de archivos) para que el comportamiento sea conocido. Anthropic mantiene una colección de servidores MCP de referencia que puedes ejecutar localmente — filesystem, git, memory, fetch y más.

Un claude mcp add mínimo para un servidor local de sistema de archivos (todo lo que va después de -- es el comando de lanzamiento):

Añadir un servidor MCP local de sistema de archivos a Claude Code

claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/dir

Si prefieres editar la configuración directamente, un servidor stdio se declara con el comando que lo lanza. La forma es así:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"]
    }
  }
}

Última verificación: 2026-06-28.

Los subcomandos exactos de claude mcp, los ámbitos de configuración, la ubicación del archivo de configuración y los nombres precisos de los paquetes de los servidores de referencia evolucionan. Confirma la sintaxis actual en la guía de MCP de Claude Code y en el repositorio de servidores de referencia antes de depender de un flag o nombre de paquete concreto.

Confirma con la fuente oficial.

Construye un servidor MCP minúsculo

Un servidor es simplemente un programa que usa un SDK de MCP, declara una herramienta e inicia un transporte stdio. Aquí está la idea completa en TypeScript — una herramienta que suma dos números (cambia el cuerpo por "ejecuta mi script", "consulta mi BD", "llama a mi modelo local"):

npm install @modelcontextprotocol/sdk zod

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({ name: "my-local-tools", version: "0.1.0" });

// Declare ONE tool. Inputs are typed; the body runs locally with your privileges.
server.registerTool(
  "add",
  {
    description: "Add two numbers",
    inputSchema: { a: z.number(), b: z.number() },
  },
  async ({ a, b }) => ({
    content: [{ type: "text", text: String(a + b) }],
  }),
);

// Talk to the client over stdio — this is what makes it a LOCAL server.
await server.connect(new StdioServerTransport());

Regístralo con Claude exactamente igual que cualquier otro servidor stdio — apunta el comando de lanzamiento a tu archivo:

Añadir tu propio servidor local a Claude Code

claude mcp add my-local-tools -- node /abs/path/to/server.js

Ese es el bucle completo: Claude (cerebro) ve una nueva herramienta, la llama cuando es relevante, y tu código (manos) se ejecuta localmente y devuelve el resultado. Como habla el mismo protocolo abierto, este servidor también funciona en otros clientes MCP sin cambios.

Watch out

• Los servidores MCP se ejecutan con tus privilegios y pueden tomar acciones reales — instala solo servidores en los que confíes y vigila la inyección de prompts a través de los resultados de las herramientas.

Comprueba lo aprendido

Comprueba lo aprendido

0/4

1. 1En una frase, ¿qué es MCP?
2. 2Para un servidor MCP LOCAL, ¿cómo le habla normalmente el cliente?
3. 3¿Por qué construir un servidor MCP compensa en varias herramientas?
4. 4¿Cuál es la razón principal para revisar un servidor antes de instalarlo?

Pulsa Intro o Espacio para girar la tarjeta. Usa las flechas izquierda y derecha para moverte entre las tarjetas.Término mostrado.

1 / 8

Key takeaways

• MCP es un estándar abierto para que un cliente de IA pueda llamar a herramientas y datos externos a través de servidores MCP — Anthropic lo introdujo con soporte para servidores locales desde el principio.
• La arquitectura local es simple: un cliente MCP (Claude Code / Desktop) lanza un servidor MCP local como subproceso y le habla por stdio — tus datos permanecen en tu máquina.
• Esta es la sinergia Claude-como-cerebro + capacidades-locales: Claude orquesta; los servidores locales (sistema de archivos, BD, un script, incluso un modelo o agente local) aportan las manos.
• Añade un servidor con un solo comando (claude mcp add ... -- <comando de lanzamiento>); construye uno con un SDK de MCP registrando una herramienta y conectando un transporte stdio.
• MCP está ampliamente adoptado, así que un servidor local que construyas funciona en muchos clientes — constrúyelo una vez, reutilízalo en todas partes.
• Los servidores actúan con tus privilegios: instala solo lo que confíes y trata los resultados de las herramientas como un posible vector de inyección de prompts.

Siguiente

• Usa MCP desde la terminal en el día a día → Claude Code: MCP
• Qué es el orquestador → Qué es Claude Code
• La forma de llamada a herramientas que siguen las herramientas MCP → Uso de herramientas
• Ejecuta el modelo o agente local que un servidor puede envolver → Agentes de IA locales

Fuentes y lecturas adicionales

• Model Context Protocol — sitio oficial
• Arquitectura y conceptos de MCP
• Construye un servidor MCP (guía oficial)
• Presentación del Model Context Protocol — Anthropic
• Servidores MCP de referencia (filesystem, git, fetch, …)
• Model Context Protocol — Wikipedia (visión general y adopción)