MCP Servers con Claude Code 2026: El USB-C de la IA (Guía Práctica)

Qué son los MCP Servers (y por qué cambian todo)

Si usás Claude Code, en algún momento te preguntaste: ¿cómo le doy acceso a mi base de datos? ¿A mis archivos? ¿A una API externa?

La respuesta es MCP — Model Context Protocol.

Lo pienso como el USB-C de la IA: un estándar universal que permite a los modelos de lenguaje conectarse con herramientas, datos y servicios externos de forma segura y estructurada.

Sin MCP, tu agente de IA está encerrado. Con MCP, puede leer tu base de datos, ejecutar queries, llamar APIs, y actuar en tu sistema — todo con tu control explícito.

La arquitectura en 60 segundos

MCP usa una arquitectura cliente-servidor:

┌─────────────────────────────┐
│    Claude Code (cliente)    │
│                             │
│  ← lee contexto             │
│  → ejecuta herramientas     │
└──────────┬──────────────────┘
           │ MCP Protocol
┌──────────▼──────────────────┐
│    Tu MCP Server            │
│                             │
│  → Tools (funciones)        │
│  → Resources (datos)        │
│  → Prompts (templates)      │
└──────────┬──────────────────┘
           │
┌──────────▼──────────────────┐
│    Tu sistema               │
│  (DB, APIs, archivos)       │
└─────────────────────────────┘

Tres primitivas que necesitás entender:

Tools: funciones que Claude puede ejecutar (query_database, send_email, create_ticket)
Resources: datos que Claude puede leer (tu schema, documentación, archivos)
Prompts: templates reutilizables con contexto pre-armado

¿Por qué importa esto ahora?

En 2024, cada equipo conectaba sus agentes de IA con integraciones custom y frágiles. Mantenimiento permanente, breaking changes constantes.

En 2026, MCP es el estándar que adoptó Anthropic, y que están adoptando otros labs. Una vez que montás tu servidor MCP, funciona con cualquier cliente compatible.

Eso es exactamente el valor del USB-C: un puerto, todos los dispositivos.

MCP servers pre-built que podés usar hoy

Antes de montar el tuyo, revisá lo que ya existe:

Server	Qué hace
`@modelcontextprotocol/server-filesystem`	Acceso a archivos locales
`@modelcontextprotocol/server-postgres`	Queries a PostgreSQL
`@modelcontextprotocol/server-github`	Issues, PRs, repos
`@modelcontextprotocol/server-brave-search`	Búsqueda web
`@modelcontextprotocol/server-sqlite`	Base de datos SQLite
`mcp-server-fetch`	Fetch HTTP / web scraping

Para instalarlos en Claude Code, editá tu claude_desktop_config.json:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tu/directorio"]
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_URL": "postgresql://usuario:pass@localhost:5432/tu_db"
      }
    }
  }
}

Reiniciá Claude Code y ya tenés acceso a esos servidores.

Cómo montar tu primer MCP server (paso a paso)

Vamos a crear un MCP server simple que conecte Claude con una API externa — en este caso, un servicio de tickets interno.

1. Setup del proyecto

mkdir mi-mcp-server && cd mi-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk

2. El servidor básico

// index.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  ListToolsRequestSchema,
  CallToolRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
 
const server = new Server(
  {
    name: "mi-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);
 
// Definí tus herramientas
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "get_ticket",
        description: "Obtiene información de un ticket por ID",
        inputSchema: {
          type: "object",
          properties: {
            ticket_id: {
              type: "string",
              description: "El ID del ticket",
            },
          },
          required: ["ticket_id"],
        },
      },
      {
        name: "list_open_tickets",
        description: "Lista todos los tickets abiertos",
        inputSchema: {
          type: "object",
          properties: {
            limit: {
              type: "number",
              description: "Máximo de tickets a retornar",
              default: 10,
            },
          },
        },
      },
    ],
  };
});
 
// Implementá la lógica
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;
 
  if (name === "get_ticket") {
    // Tu lógica real acá — llamada a DB, API, etc.
    const ticket = await fetchTicket(args.ticket_id as string);
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(ticket, null, 2),
        },
      ],
    };
  }
 
  if (name === "list_open_tickets") {
    const tickets = await listTickets(args.limit as number);
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(tickets, null, 2),
        },
      ],
    };
  }
 
  throw new Error(`Herramienta desconocida: ${name}`);
});
 
// Arrancá el servidor
const transport = new StdioServerTransport();
await server.connect(transport);

3. Funciones de negocio

// Reemplazá con tu lógica real
async function fetchTicket(id: string) {
  // Llamada a tu API, DB, Linear, Jira, etc.
  const response = await fetch(`https://tu-api.com/tickets/${id}`, {
    headers: { Authorization: `Bearer ${process.env.API_TOKEN}` },
  });
  return response.json();
}
 
async function listTickets(limit = 10) {
  const response = await fetch(
    `https://tu-api.com/tickets?status=open&limit=${limit}`,
    { headers: { Authorization: `Bearer ${process.env.API_TOKEN}` } }
  );
  return response.json();
}

4. Registralo en Claude Code

// claude_desktop_config.json
{
  "mcpServers": {
    "mi-server": {
      "command": "npx",
      "args": ["tsx", "/ruta/a/mi-mcp-server/index.ts"],
      "env": {
        "API_TOKEN": "tu-token-aqui"
      }
    }
  }
}

Reiniciá Claude Code. Ahora podés decirle:

"Revisar el ticket #234 y crear un summary de lo que necesita para cerrarse"

Y Claude va a usar tus herramientas para ejecutarlo.

Patrones que aprendí en producción

Después de correr MCP servers en proyectos reales, estos son los patrones que más me ayudaron:

1. Describí bien tus herramientas

La descripción es lo que Claude usa para decidir CUÁNDO usar cada tool. Sé específico:

// ❌ Malo
{ name: "query", description: "Hace queries" }
 
// ✅ Bueno  
{
  name: "query_active_users",
  description: "Obtiene usuarios activos en los últimos 30 días. " +
               "Ideal para reportes de engagement y análisis de retención. " +
               "Retorna email, última actividad y plan."
}

2. Maneja errores con contexto

if (name === "get_ticket") {
  try {
    const ticket = await fetchTicket(args.ticket_id);
    return { content: [{ type: "text", text: JSON.stringify(ticket) }] };
  } catch (error) {
    return {
      content: [{
        type: "text",
        text: `Error obteniendo ticket ${args.ticket_id}: ${error.message}. ` +
              `Verificá que el ID exista y que el token tenga permisos.`
      }],
      isError: true,
    };
  }
}

3. Limitá el scope por defecto

Nunca expongas más de lo necesario. Si tu server tiene acceso de escritura, asegurate de que sea explícito y controlado:

// Solo lectura por defecto
{
  name: "query_database",
  description: "Ejecuta queries de SOLO LECTURA. Para escritura, usar write_database."
}

MCP en producción: el checklist de seguridad

Antes de apuntar a datos reales de producción:

Tokens con mínimo privilegio: el token del MCP server no debería tener más acceso del que necesita
Variables de entorno, no hardcoded: nunca metas secrets directamente en el código
Logging de todas las llamadas: sabé qué hizo Claude y cuándo
Rate limiting: si el server llama APIs externas, protegete de loops accidentales
Timeout explícito: ponele un timeout a cada operación para no bloquear indefinidamente
Validación de inputs: no confíes en que Claude siempre manda los tipos correctos

El estado actual del ecosistema

A principios de 2026, el ecosistema MCP está creciendo rápido:

Anthropic tiene el spec y lo mantiene activamente
Cursor, Windsurf y otros IDEs de IA están adoptando MCP
La comunidad ya tiene más de 200 servers públicos en el registry

Lo que falta: tooling para testing y debugging de MCP servers. Si querés probar tu server sin levantar Claude, podés usar el MCP Inspector.

Lo que los devs de NODO están haciendo con MCP

En los últimos meses, en la newsletter NODO cubrimos MCP a fondo en el episodio #003. Algunos resultados reales:

Un dev de fintech montó un MCP server que le da a Claude acceso de solo lectura a su producción para debugging — sin exponer credentials
Un equipo de 3 usa MCP para que Claude tenga contexto de todos sus tickets de Linear automáticamente
Un dev de Buenos Aires conectó su knowledge base de Notion con Claude via MCP — ahora Claude escribe PRs con contexto de la arquitectura real

Siguiente paso

Si esto te pareció útil, probablemente también te sirva:

Tutorial Claude Code Completo 2026 — de cero a productivo
Claude Code vs Cursor: Mi Veredicto — después de 3 meses usando los dos
Cómo Instalar Claude Code 2026 — paso a paso

Y si querés patrones más avanzados — multi-agentes, seguridad en producción, arquitecturas que escalan — los cubro cada semana en NODO, mi newsletter en español para devs que construyen AI en serio.

Gratis. Una vez por semana. Sin spam.