Model Context Protocol (MCP): Dándole a la IA Herramientas que Realmente Puede Usar

Hay un momento en cada proyecto de IA donde alguien dice, "¿La IA puede simplemente buscar eso en nuestra base de datos?" Y la respuesta tradicionalmente ha sido: más o menos, si entrecierras los ojos, y además podría alucinar la respuesta de todos modos.

Eso cambió para mí cuando empecé a construir con el Model Context Protocol. MCP es una de esas cosas que suena aburrida en un título de blog pero es genuinamente transformadora en la práctica. Es la diferencia entre una IA que adivina sobre tus datos y una IA que realmente consulta tus datos.

Déjame mostrarte a qué me refiero.

El Problema que MCP Resuelve

Antes de MCP, darle a un LLM acceso a herramientas externas se veía así:

┌─────────────────────────────────────────────────────────────────┐
│                  La Forma Vieja (Frágil)                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Usuario: "¿Cuántos clientes activos tenemos?"                   │
│                                                                  │
│  El desarrollador tiene que:                                     │
│  1. Definir el schema de la herramienta inline con el prompt     │
│  2. Escribir un handler que parsee la llamada del LLM            │
│  3. Ejecutar la consulta a la base de datos                      │
│  4. Formatear el resultado y alimentarlo de vuelta al LLM        │
│  5. Repetir para CADA herramienta, en CADA app                   │
│                                                                  │
│  Problemas:                                                      │
│  • Las definiciones de herramientas se duplican entre apps        │
│  • Sin estándar para auth, rate limiting o logging               │
│  • Cada proveedor de LLM tiene un formato diferente              │
│  • Agregar una herramienta nueva significa cambiar cada cliente   │
│  • La IA no puede "descubrir" herramientas disponibles           │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

MCP invierte esto. En vez de embeber lógica de herramientas en cada aplicación de IA, construyes un servidor que expone herramientas. Cualquier cliente MCP puede descubrirlas y usarlas:

┌─────────────────────────────────────────────────────────────────┐
│                  La Forma MCP (Limpia)                            │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────┐     ┌──────────────┐     ┌──────────────┐         │
│  │  Claude   │────>│ Servidor MCP │────>│  Base de Datos│         │
│  │  Desktop  │     │  (tu código) │     │  CRM          │         │
│  └──────────┘     └──────────────┘     │  APIs         │         │
│                                         └──────────────┘         │
│  ┌──────────┐     ┌──────────────┐                               │
│  │  VS Code  │────>│  Mismo       │  ← Mismo servidor,           │
│  │  + Claude │     │  Servidor    │    diferentes clientes        │
│  └──────────┘     └──────────────┘                               │
│                                                                  │
│  Beneficios:                                                     │
│  • Define herramientas UNA VEZ, úsalas en todos lados            │
│  • Auth, logging, rate limiting estandarizado                    │
│  • Los clientes auto-descubren herramientas disponibles          │
│  • Agrega herramientas sin cambiar clientes                      │
│  • Funciona entre proveedores de LLM                             │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Piénsalo como USB-C para la IA. Antes de USB-C, cada dispositivo tenía su propio cable. MCP es el conector universal entre la IA y tus herramientas de negocio.

Construyendo Tu Primer Servidor MCP

Te muestro un servidor MCP real que construí — uno que le da a Claude acceso a una base de datos de clientes. Esto está simplificado de un sistema de producción, pero los patrones son reales.

// mcp-server/src/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { db } from "./database.js";
 
const server = new McpServer({
  name: "customer-database",
  version: "1.0.0",
});
 
// Herramienta: Buscar un cliente por email
server.tool(
  "get_customer",
  "Buscar un cliente por su dirección de email. Retorna perfil, estado de suscripción y actividad reciente.",
  {
    email: z.string().email().describe("La dirección de email del cliente"),
  },
  async ({ email }) => {
    const customer = await db.customers.findByEmail(email);
    if (!customer) {
      return {
        content: [{ type: "text", text: `No se encontró cliente con email: ${email}` }],
      };
    }
 
    return {
      content: [{
        type: "text",
        text: JSON.stringify({
          id: customer.id,
          name: customer.name,
          email: customer.email,
          plan: customer.plan,
          status: customer.status,
          mrr: customer.mrr,
          signupDate: customer.createdAt,
          lastActive: customer.lastActiveAt,
        }, null, 2),
      }],
    };
  }
);
 
// Herramienta: Obtener métricas de clientes
server.tool(
  "get_customer_metrics",
  "Obtener métricas agregadas: total de clientes, MRR, tasa de churn y tasa de crecimiento.",
  {
    period: z.enum(["7d", "30d", "90d", "1y"]).describe("Período de tiempo"),
  },
  async ({ period }) => {
    const metrics = await db.metrics.getCustomerMetrics(period);
    return {
      content: [{
        type: "text",
        text: JSON.stringify(metrics, null, 2),
      }],
    };
  }
);
 
// Iniciar el servidor
const transport = new StdioServerTransport();
await server.connect(transport);

Eso es todo. Tres herramientas, unas 80 líneas de código, y ahora Claude puede responder preguntas como:

• "¿Cuántos clientes enterprise tenemos?"
• "¿Cuál es el crecimiento de MRR en los últimos 90 días?"
• "Busca la cuenta de jane@acme.com — ¿siguen en el plan gratuito?"

Sin alucinaciones. Datos reales. Siempre.

Patrones de Producción

Después de construir servidores MCP para múltiples sistemas en producción, estos son los patrones que importan:

Autenticación y Autorización

server.tool(
  "get_sensitive_data",
  "Obtener datos financieros sensibles del cliente (requiere rol admin)",
  { customerId: z.string() },
  async ({ customerId }, context) => {
    const user = await validateAuth(context.meta?.authToken);
    if (!user.roles.includes("admin")) {
      return {
        content: [{ type: "text", text: "No autorizado: se requiere rol admin" }],
        isError: true,
      };
    }
 
    // Log de auditoría en cada acceso a datos sensibles
    await auditLog.record({
      action: "get_sensitive_data",
      user: user.id,
      resource: customerId,
      timestamp: new Date(),
    });
 
    const data = await db.customers.getFinancials(customerId);
    return { content: [{ type: "text", text: JSON.stringify(data) }] };
  }
);

Rate Limiting

import { RateLimiter } from "./rate-limiter.js";
 
const limiter = new RateLimiter({
  maxRequests: 100,
  windowMs: 60_000, // 100 requests por minuto
});
 
server.tool(
  "run_analytics_query",
  "Ejecutar consulta analítica personalizada (con rate limit)",
  { query: z.string() },
  async ({ query }) => {
    if (!limiter.allow("analytics")) {
      return {
        content: [{ type: "text", text: "Límite de rate excedido. Intenta en un minuto." }],
        isError: true,
      };
    }
 
    const results = await analytics.query(query);
    return { content: [{ type: "text", text: JSON.stringify(results) }] };
  }
);

Arquitectura: Dónde Encaja MCP

┌─────────────────────────────────────────────────────────────────┐
│                MCP en un Stack de Producción                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌─────────────────────────────────────────────┐                 │
│  │           Clientes MCP                       │                │
│  │  ┌─────────┐ ┌──────────┐ ┌──────────────┐  │                │
│  │  │ Claude   │ │ VS Code  │ │ App Interna  │  │                │
│  │  │ Desktop  │ │ + Copilot│ │ (UI custom)  │  │                │
│  │  └────┬─────┘ └────┬─────┘ └──────┬───────┘  │                │
│  └───────┼──────────────┼─────────────┼──────────┘                │
│          │              │             │                           │
│          ▼              ▼             ▼                           │
│  ┌─────────────────────────────────────────────┐                 │
│  │        Servidores MCP (tu código)            │                │
│  │  ┌──────────┐ ┌──────────┐ ┌──────────────┐ │                │
│  │  │ BD de    │ │ Motor de │ │ Gestor de    │  │                │
│  │  │ Clientes │ │ Analytics│ │ Deployments  │  │                │
│  │  └────┬─────┘ └────┬─────┘ └──────┬───────┘ │                │
│  └───────┼──────────────┼─────────────┼─────────┘                │
│          │              │             │                           │
│          ▼              ▼             ▼                           │
│  ┌──────────┐  ┌──────────┐  ┌──────────────┐                   │
│  │PostgreSQL│  │ClickHouse│  │ GitHub API   │                    │
│  │  Redis   │  │ Grafana  │  │ Vercel API   │                    │
│  └──────────┘  └──────────┘  └──────────────┘                    │
│                                                                  │
│  Cada servidor MCP es un microservicio enfocado que expone       │
│  las herramientas de UN dominio. Mantenlos pequeños.             │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Lo Que Estoy Construyendo con MCP Ahora

En TheGreyMatter.ai, estoy construyendo servidores MCP que le dan a nuestro cerebro de IA acceso a todo el ecosistema de productos de forma segura. Claude puede obtener datos de Snapshot9, Measurement13 y 9Vectors a través de MCP — respondiendo preguntas sobre evaluaciones organizacionales, métricas estratégicas y evaluaciones de liderazgo con datos reales.

El patrón: cada producto tiene su propio servidor MCP. Los servidores MCP comparten una capa de auth común (nuestro TGM Auth Service valida tokens JWT). Claude descubre qué herramientas están disponibles y las usa según lo que el usuario pregunte.

El insight clave: MCP no se trata solo de hacer la IA más inteligente. Se trata de hacerla confiable. Cuando Claude responde "Tu organización obtuvo 7.2 en alineamiento de liderazgo," no está generando ese número — consultó el score real a través de un servidor MCP validado, loggeado y con rate limit. Esa es la diferencia entre un demo y un sistema de producción.

Para Empezar

Si quieres empezar a construir con MCP:

1. Instala el SDK: npm install @modelcontextprotocol/sdk
2. Empieza con una herramienta de solo lectura que consulte tu necesidad de datos más común
3. Prueba con Claude Desktop — tiene soporte nativo de MCP, solo agrega tu servidor a la config
4. Agrega auth y logging antes de exponerlo a tu equipo
5. Expande gradualmente — una herramienta a la vez, cada una revisada y testeada

MCP todavía es temprano, pero es el patrón más prometedor que he visto para cerrar la brecha entre "IA que suena inteligente" e "IA que es realmente útil." Y en producción, útil es lo único que importa.