El Protocolo de Contexto de Modelo (MCP) es un estándar abierto que permite que modelos como Claude de Anthropic y herramientas para desarrolladores como Claude Code llamen a herramientas externas, fuentes de datos y prompts de forma segura y estandarizada.
Esta guía le explicará cómo crear su propio servidor MCP desde cero, permitiendo que Claude Code acceda a funciones personalizadas y, así, amplíe enormemente su funcionalidad más allá de las capacidades integradas.
¿Qué es el Protocolo de Contexto de Modelo (MCP)?
MCP (Model Context Protocol) es una especificación abierta diseñada para estandarizar cómo los clientes de modelos de lenguaje (como Claude, Claude Code u otros frontends de LLM) se conectan a servidores de herramientas y fuentes de datos. Piense en MCP como un “puerto USB-C para los LLM”: define un transporte/esquema JSON-RPC y una forma común para que los servidores publiquen tres tipos de capacidades:
- Resources (Recursos): datos tipo archivo o documento que un cliente puede leer (p. ej., una fila de base de datos, un archivo de texto, una carga útil JSON).
- Tools (Herramientas): funciones invocables que el modelo puede pedir al host que ejecute (con la aprobación del usuario).
- Prompts: plantillas de prompts reutilizables o flujos de trabajo que el modelo/cliente puede invocar.
MCP admite múltiples transportes (stdio, HTTP, SSE) y proporciona esquemas, SDKs y servidores de ejemplo para que no tenga que inventar usted mismo el formato “sobre el cable”. El protocolo se mantiene públicamente (spec + SDKs) y cuenta con tutoriales y una galería de servidores de ejemplo para acelerar la adopción.
¿Cómo está diseñado MCP?
La arquitectura de MCP es intencionalmente simple y modular: las piezas centrales son los servidores MCP, los clientes MCP y los transportes que llevan mensajes enmarcados JSON-RPC entre ellos. A continuación se muestran los componentes principales con los que interactuará al crear un servidor para Claude Code (u otros clientes MCP).
Servidor, cliente y el protocolo
- Servidor MCP: un servicio que publica herramientas, recursos y prompts. Las herramientas pueden ejecutar efectos secundarios u obtener datos; los recursos exponen contenido de solo lectura; los prompts son plantillas reutilizables que el cliente puede pedir al modelo que muestree.
- Cliente MCP (host): normalmente parte del host del LLM (p. ej., Claude Code, complemento de VS Code, un cliente de navegador). Descubre los servidores disponibles, presenta descripciones de herramientas al modelo y enruta las llamadas iniciadas por el modelo hacia los servidores.
- Protocolo: los mensajes se codifican como JSON-RPC; la especificación define eventos de ciclo de vida, descubrimiento de herramientas, invocación, “completions/sampling” y cómo se transportan los resultados estructurados de vuelta al cliente y al modelo.
Patrón de comunicación (qué ocurre cuando se usa una herramienta)
- El cliente envía el mensaje del usuario al modelo.
- El modelo analiza el contexto y decide llamar a una herramienta expuesta por MCP (o a múltiples herramientas).
- El cliente reenvía la llamada de herramienta al servidor MCP a través del transporte elegido.
- El servidor ejecuta la herramienta y devuelve los resultados.
- El modelo recibe la salida de la herramienta y compone la respuesta final para el usuario.
Primitivas de implementación
- Los mensajes JSON-RPC siguen el esquema MCP.
- Las definiciones de herramientas se publican en las respuestas de descubrimiento del servidor para que los clientes puedan presentarlas en la interfaz.
- Los recursos son referenciados por los clientes mediante la sintaxis
@source:path(p. ej.,@postgres:...), permitiendo que los modelos se refieran a contenido externo sin incrustar grandes volúmenes de datos en el prompt.
¿Por qué integrar Claude Code con servidores MCP?
Claude Code es la oferta de Anthropic enfocada en flujos de trabajo de código y para desarrolladores (integración con editores/IDE, comprensión de código, etc.). Exponer sus herramientas internas (búsqueda en el código fuente, ejecutor de CI, sistema de tickets, registros privados) a través de servidores MCP permite que Claude Code las invoque como herramientas de primera clase dentro de conversaciones de codificación y flujos de agentes.
Integrar Claude Code con servidores MCP desbloquea capacidades prácticas y relevantes para producción en un agente de codificación:
1. Permita que el modelo actúe en sistemas reales
Claude Code puede pedir a un servidor MCP que consulte rastreadores de incidencias, ejecute consultas de base de datos, lea documentos extensos o produzca PRs en GitHub, habilitando la automatización de extremo a extremo dentro de la sesión de codificación. Esto está explícitamente soportado por la documentación de Claude Code (ejemplos: consultar Postgres, Sentry o crear PRs).
2. Delegue datos voluminosos y lógica especializada
En lugar de incrustar cada fuente de datos en el prompt (lo cual consume tokens), publique datos y herramientas mediante MCP. El modelo llama a la herramienta, recibe una respuesta estructurada y razona con ella; esto reduce el uso de tokens y permite que los servidores manejen el trabajo pesado (consultas a BD, lecturas de archivos extensos, autenticación).
3. Seguridad y gobernanza
MCP centraliza el control de acceso y la auditoría en la capa del servidor, permitiendo a las organizaciones incluir en lista blanca los servidores aprobados, controlar qué herramientas están disponibles y limitar salidas. Claude Code también admite configuración de MCP empresarial y consentimiento por alcance.
4. Reutilización y ecosistema
Los servidores MCP son reutilizables entre clientes y equipos. Cree una vez y muchos clientes Claude/LLM pueden usar los mismos servicios (o intercambiar implementaciones).
¿Qué necesita antes de comenzar?
Requisitos mínimos
- Una máquina de desarrollo con Python 3.10+ (usaremos Python en el ejemplo). Alternativamente, los SDK de MCP también admiten Node u otros lenguajes.
uv(la herramienta de Astral) u otro ejecutor equivalente para ejecutar servidores MCP por stdio (el tutorial de MCP usauv). Pasos de instalación a continuación.- Claude Code instalado o acceso al cliente de Claude (escritorio o CLI) para registrar y probar su servidor; o cualquier cliente compatible con MCP. Claude Code admite servidores locales por HTTP, SSE y stdio.
- Nota de seguridad: agregue solo servidores MCP de confianza a Claude Code en entornos de equipo o empresa: MCP brinda a los servidores acceso a datos sensibles y existen riesgos de inyección de prompts si un servidor devuelve contenido malicioso.
Cómo instalar y verificar la CLI de Claude Code
Esta es la Guía de instalación y uso de Claude Code.
1) Resumen rápido — métodos de instalación recomendados
Use el instalador nativo (recomendado) o Homebrew en macOS/Linux. NPM está disponible si necesita una instalación basada en Node. Windows dispone de instaladores para PowerShell / CMD. Fuente: documentación oficial de Claude Code y GitHub.
2) Requisitos previos
- macOS 10.15+, Ubuntu 20.04+/Debian 10+, o Windows 10+ (se recomienda WSL en Windows).
- Node.js 18+ solo necesario para el método de instalación con NPM.
3) Comandos de instalación (elija uno)
Nativo (recomendado — sin dependencia de Node), macOS / Linux / WSL:
curl -fsSL https://claude.ai/install.sh | bash
# optional: install latest explicitly
curl -fsSL https://claude.ai/install.sh | bash -s latest
# or install a specific version
curl -fsSL https://claude.ai/install.sh | bash -s 1.0.58
Windows PowerShell:
irm https://claude.ai/install.ps1 | iex
# or for latest: & (::Create((irm https://claude.ai/install.ps1))) latest
(Estos son los scripts oficiales del instalador nativo).
NPM (si desea una instalación global basada en Node):
# requires Node.js 18+
npm install -g @anthropic-ai/claude-code
No use sudo npm install -g — evite instalar globalmente con sudo (problemas de permisos/seguridad). Si encuentra errores de permisos, use nvm o corrija su prefijo global de npm en lugar de usar sudo.
4) Verifique que el binario se haya instalado (comprobaciones básicas)
Ejecute esto localmente inmediatamente después de la instalación:
# is the command on PATH?
which claude
# version (or -v)
claude --version
# or
claude -v
# help (sanity check)
claude --help
Se espera: which muestra una ruta (p. ej., /usr/local/bin/claude o ~/.nvm/.../bin/claude) y claude --version imprime una cadena tipo semver. La documentación y el README muestran claude como el punto de entrada principal de la CLI.
5) Verifique el estado de la instalación y la configuración (pruebas recomendadas)
a) claude doctor, ejecute:
claude doctor
Este diagnóstico integrado verifica su tipo de instalación, problemas comunes (como problemas de permisos de npm), dependencias como ripgrep y sugiere correcciones. La documentación recomienda ejecutar claude doctor después de instalar.
b) Ejecute una prueba “smoke” (no interactiva)
Desde el directorio de su proyecto:
cd /path/to/your/project
claude -p "Explain this project in 3 sentences"
Esto usa el modo print (-p) para enviar un único prompt y salir; es útil para CI o comprobaciones funcionales rápidas.
c) Verificación de autenticación (asegúrese de que la CLI puede comunicarse con Anthropic)
Claude Code admite varios flujos de autenticación (OAuth por consola, clave de API, integraciones de proveedor). Comprobaciones comunes:
- Si usa una clave de API (CI / sin interfaz / variable de entorno local):
export ANTHROPIC_API_KEY="sk-..."
# then
claude auth status
claude auth whoami # or `claude auth whoami` / `claude whoami` depending on version
Puede usar la clave de API de CometAPI para usar Claude Code. Usar la API de Claude a través de CometAPI le dará un 20% de descuento.
- Si usó OAuth a través de la consola — ejecute:
claude auth status
claude auth whoami
Debería ver información de cuenta/plan o una confirmación de que está autenticado.
Preparación del entorno paso a paso
A continuación se muestran pasos concretos para preparar dos stacks de desarrollador comunes (TypeScript y Python), seguidos de comprobaciones rápidas para asegurar que todo funcione.
H3 — A. Configuración de TypeScript / Node (ruta más rápida)
- Cree el proyecto e instale el SDK:
mkdir mcp-demo && cd mcp-demo
npm init -y
npm install @modelcontextprotocol/sdk express zod
npm install --save-dev typescript tsx @types/node @types/express
- Cree
server.ts. (Proporcionamos un ejemplo completo en la sección “Cómo crear rápidamente…”.) - Ejecute:
npx -y tsx server.ts
- Pruebe localmente con MCP Inspector o agrégalo a Claude Code:
npx @modelcontextprotocol/inspector
# or (for Claude Code)
claude mcp add --transport http my-server http://localhost:3000/mcp
(Los comandos del Inspector y de Claude le permiten validar el descubrimiento e invocar herramientas).
¿Cómo crear rápidamente un servidor MCP para Claude Code?
Lista de comprobación rápida
-
Inicie su servidor (se recomienda HTTP con streaming):
node server.tsouvicorn server:app. -
Desde su máquina de desarrollo, haga una de las siguientes:
- Use MCP Inspector para validar (
npx @modelcontextprotocol/inspector) y confirmartools/listyresources/list; o - Agregue el servidor a Claude Code:
claude mcp add --transport http <name> http://<host>:<port>/mcp(o siga los flujos de la interfaz web si su cliente admite MCP remoto).
Si planea usar el conector de Messages API de Anthropic para MCP remoto (sin cliente separado), lea la documentación de Claude: puede requerir un encabezado beta (consulte la documentación para conocer el encabezado exacto y el estado de soporte actual).
A continuación se muestran dos ejemplos completos pero compactos de servidores que puede copiar, ejecutar y conectar a Claude Code (o al MCP Inspector). El ejemplo en TypeScript usa Express + el SDK de TypeScript; el ejemplo en Python muestra un montaje con FastAPI.
Nota: el código a continuación sigue los ejemplos públicos del SDK y es intencionalmente mínimo para mayor claridad. En producción, agregue autenticación, registro, limitación de velocidad y validación de entrada más allá de los valores predeterminados del SDK.
Ejemplo 1: TypeScript + Express (HTTP con streaming)
Cree server.ts (completo):
// server.ts
import express from "express";
import * as z from "zod/v4";
import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
const server = new McpServer({ name: "claude-code-demo", version: "0.1.0" });
// Register a simple tool: add two numbers
server.registerTool(
"add",
{
title: "Add",
description: "Add two numbers a and b",
inputSchema: { a: z.number(), b: z.number() },
outputSchema: { result: z.number() }
},
async ({ a, b }) => {
const output = { result: a + b };
return {
content: ,
structuredContent: output
};
}
);
// Register a resource: greet user (dynamic)
server.registerResource(
"greeting",
new ResourceTemplate("greeting://{name}", { list: undefined }),
{ title: "Greeting", description: "Return a greeting for the name" },
async (uri, params) => {
return {
contents:
};
}
);
// Express + Streamable HTTP transport
const app = express();
app.use(express.json());
app.post("/mcp", async (req, res) => {
const transport = new StreamableHTTPServerTransport({ enableJsonResponse: true });
// Close transport when connection closes
res.on("close", () => transport.close());
await server.connect(transport);
await transport.handleRequest(req, res, req.body);
});
const port = parseInt(process.env.PORT || "3000", 10);
app.listen(port, () => console.log(`MCP server listening: http://localhost:${port}/mcp`));
Ejecute:
npm install
npx -y tsx server.ts
Luego conéctelo en Claude Code (ejemplo):
# Add the remote server to your Claude Code MCP list (local dev)
claude mcp add --transport http my-demo http://localhost:3000/mcp
Este ejemplo está adaptado del Quick Start del SDK de TypeScript oficial y demuestra cómo registrar herramientas y recursos, y exponerlos por HTTP con streaming.
Ejemplo 2: Python + FastAPI (FastMCP + HTTP con streaming)
Cree server.py (completo):
# server.py
from fastapi import FastAPI
from mcp.server.fastmcp import FastMCP
app = FastAPI()
mcp = FastMCP("claude-python-demo", stateless_http=True)
# tool: simple sum
@mcp.tool()
def add(a: int, b: int) -> dict:
"""Add two integers"""
return {"result": a + b}
# resource: simple greeting resource template
@mcp.resource("greeting://{name}")
def greeting(name: str):
return {"contents": }
# mount the streamable-http MCP endpoint (FastMCP exposes an ASGI app)
app.mount("/mcp", mcp.streamable_http_app())
# optional endpoint to demonstrate other API routes
@app.get("/")
async def root():
return {"status": "OK"}
Ejecute:
uvicorn server:app --reload --port 8000
Conéctese con el Inspector:
npx @modelcontextprotocol/inspector
# In Inspector select Streamable HTTP and enter http://localhost:8000/mcp
Los ejemplos del SDK de Python y las utilidades FastMCP facilitan registrar funciones decoradas con @mcp.tool() y @mcp.resource() que el LLM puede descubrir e invocar.
¿Cómo llama realmente Claude Code a sus herramientas?
Cuando un LLM decide usar una herramienta, el cliente envía una invocación JSON-RPC al servidor MCP. El servidor ejecuta la herramienta solicitada (por ejemplo, consulta una BD, ejecuta pruebas o llama a una API externa) y devuelve contenido estructurado y contenido presentable. El cliente (Claude Code) puede incluir la salida estructurada en el contexto del modelo para que este continúe razonando con esos datos confiables, y no solo con la salida textual del servidor. El SDK de TypeScript permite registrar inputSchema y outputSchema (zod) para que los argumentos y salidas se validen y tipen de forma automática.
¿Qué herramientas de prueba y depuración debería usar?
MCP Inspector
MCP Inspector es la herramienta visual oficial para desarrolladores para probar servidores MCP. Le permite conectarse a un servidor (stdio, SSE o HTTP con streaming), listar herramientas, invocarlas manualmente e inspeccionar el ciclo de vida de los mensajes JSON-RPC, algo muy valioso durante el desarrollo. Inícielo con npx @modelcontextprotocol/inspector.
Pruebas locales vs remotas
- Local (stdio): ciclo de iteración rápido para aplicaciones de escritorio y depuración sin conexión.
- HTTP con streaming: pruebe con el Inspector o conéctese a Claude Code usando el CLI
claude mcp addo el conector MCP en Messages API para pruebas remotas. Asegúrese de proporcionar cualquier encabezado de autenticación que su servidor requiera.
Conclusión
MCP es el puente práctico entre los LLM modernos y los sistemas que realmente contienen los datos y ejecutan acciones. Para flujos de trabajo de código, integrar Claude Code con un servidor MCP proporciona al modelo acceso estructurado y auditable a repositorios, CI, rastreadores de incidencias y herramientas personalizadas, lo que se traduce en una automatización más precisa y efectos secundarios más seguros. Con SDKs oficiales en TypeScript y Python, HTTP con streaming para hosting remoto y herramientas como MCP Inspector, puede crear un servidor mínimo en minutos e iterar hacia un despliegue de producción.
Los desarrolladores pueden acceder a la Claude Sonnet 4.5 API y a la Claude Opus 4.1 API, etc., a través de CometAPI; la versión más reciente del modelo siempre se actualiza con respecto al sitio oficial. Para comenzar, explore las capacidades del modelo en el Playground y consulte la guía de la API para instrucciones detalladas. Antes de acceder, asegúrese de haber iniciado sesión en CometAPI y obtenido la clave de API. CometAPI ofrece un precio muy inferior al precio oficial para ayudarle a integrar.
¿Listo para empezar? → Regístrese en CometAPI hoy
Si desea conocer más consejos, guías y noticias sobre IA, síganos en VK, X y Discord.