MCP: De Function Calling a un Estándar Universal para IA

TL;DR: Los LLMs pasaron de responder preguntas a poder interactuar con el mundo real mediante function calling. Pero escalar estas integraciones se volvió un problema. MCP (Model Context Protocol) de Anthropic es el estándar abierto que está cambiando el juego, y empresas como OpenAI y Google ya lo adoptaron.

El problema que nadie veía venir

Cuando ChatGPT explotó en noviembre de 2022, millones de personas descubrimos que podíamos tener conversaciones sorprendentemente naturales con una IA. En marzo de 2023, GPT-4 elevó la apuesta. De repente, empresas cambiaron prioridades, cientos de startups nacieron, y entendimos que esto no era "solo otra herramienta".

Pero había un límite frustrante: los modelos vivían en una caja.

Podían razonar, explicar, generar código... pero no podían enviar un email, crear un evento en tu calendario, o consultar tu base de datos. El potencial era enorme, pero quedaba atrapado dentro del modelo.

Function Calling: La primera gran evolución

En julio de 2022, OpenAI anunció function calling: la capacidad de darle herramientas al modelo para interactuar con sistemas externos.

// Antes: El modelo solo podía responder
const respuesta = await openai.chat.completions.create({
  model: "gpt-4",
  messages: [{ role: "user", content: "¿Qué tiempo hace en Buenos Aires?" }]
});
// Respuesta: "No tengo acceso a datos en tiempo real..."

// Después: El modelo puede USAR herramientas
const respuesta = await openai.chat.completions.create({
  model: "gpt-4",
  messages: [{ role: "user", content: "¿Qué tiempo hace en Buenos Aires?" }],
  functions: [{
    name: "obtener_clima",
    description: "Obtiene el clima actual de una ciudad",
    parameters: {
      type: "object",
      properties: {
        ciudad: { type: "string" }
      }
    }
  }]
});
// El modelo decide: "Necesito llamar a obtener_clima('Buenos Aires')"

Esto cambió todo. Los modelos podían:

Responder preguntas llamando APIs externas
Convertir lenguaje natural en queries SQL o llamadas a servicios
Ejecutar acciones reales: enviar emails, crear tareas, actualizar CRMs

Sin darnos cuenta, le estábamos abriendo la puerta de nuestra realidad digital a estos modelos.

El problema de escalar herramientas

Function calling resolvió el "qué", pero creó un nuevo problema: el "cómo escalamos esto".

Imagina este escenario:

// Bot 1: Asistente de ventas
const salesBot = {
  functions: [
    { name: "buscar_cliente", description: "Busca cliente por email...", parameters: {...} },
    { name: "obtener_ordenes", description: "Obtiene órdenes del cliente...", parameters: {...} }
  ]
};

// Bot 2: Asistente de soporte
const supportBot = {
  functions: [
    { name: "buscar_cliente", description: "Busca cliente por email...", parameters: {...} }, // ¡DUPLICADO!
    { name: "obtener_ordenes", description: "Obtiene órdenes del cliente...", parameters: {...} } // ¡DUPLICADO!
  ]
};

// Bot 3: Asistente de facturación
// ... ¿Otra vez copiar y pegar las mismas funciones?

Los problemas eran evidentes:

Duplicación masiva: Cada cliente (bot/app) tenía que configurar las mismas herramientas
Mantenimiento: Un cambio en la API requería actualizar N configuraciones
Errores de copy-paste: ¿Te acordás exactamente cómo describir cada función?
No hay single source of truth: Si la descripción difiere entre bots, el comportamiento también

Era el clásico problema N×M: N clientes × M herramientas = caos de mantenimiento.

MCP: La solución con responsabilidades claras

En noviembre de 2024, Anthropic anunció MCP (Model Context Protocol): un estándar abierto para que los LLMs descubran e interactúen con herramientas.

La idea es brillantemente simple: invertir la responsabilidad.

Antes (Function Calling tradicional)

Cliente → Tiene que saber cómo configurar CADA herramienta
         → Mantiene las definiciones
         → Se rompe si cambia la herramienta

Después (MCP)

Cliente → Solo pregunta: "¿Qué herramientas tenés?"
Servidor MCP → Responde con sus capacidades
               → Mantiene sus propias definiciones
               → Se actualiza sin romper clientes

Cómo funciona MCP

MCP define una arquitectura cliente-servidor con un flujo de descubrimiento:

// 1. El cliente (Claude Desktop, tu app, etc.) inicia
const client = new MCPClient();

// 2. Conecta a servidores MCP configurados
await client.connect('weather-mcp', 'database-mcp', 'gmail-mcp');

// 3. El cliente pregunta a cada servidor
const capabilities = await client.listTools();
// Respuesta:
// [
//   { name: "get_weather", description: "...", server: "weather-mcp" },
//   { name: "query_db", description: "...", server: "database-mcp" },
//   { name: "send_email", description: "...", server: "gmail-mcp" }
// ]

// 4. Durante la conversación, el modelo decide qué tool usar
// El cliente ejecuta la tool en el servidor correcto
const resultado = await client.callTool('get_weather', { city: 'Buenos Aires' });

Los tres primitivos de MCP

MCP define tres tipos de capacidades:

Tools (controladas por el modelo): Acciones que el modelo puede invocar

{
  "name": "buscar_cliente",
  "description": "Busca cliente por email",
  "inputSchema": { ... }
}

Resources (controladas por la app): Datos que la app puede proveer

{
  "uri": "client://12345/profile",
  "name": "Perfil de cliente",
  "mimeType": "application/json"
}

Prompts (controlados por el usuario): Templates de prompts reutilizables

{
  "name": "resumir_orden",
  "description": "Resume una orden de compra",
  "arguments": ["order_id"]
}

El impacto: De "API first" a "MCP first"

La adopción ha sido meteórica:

Noviembre 2024: Anthropic lanza MCP con SDKs en Python y TypeScript
Marzo 2025: OpenAI adopta MCP oficialmente en ChatGPT Desktop
Abril 2025: Google confirma soporte en Gemini
Diciembre 2025: MCP se dona a la Agentic AI Foundation (Linux Foundation)

Hoy, cientos de MCP servers públicos están disponibles:

GitHub MCP: Interactúa con repos, issues, PRs
Postgres MCP: Ejecuta queries en bases de datos
Slack MCP: Lee y envía mensajes
Google Drive MCP: Accede a documentos

Las empresas están viendo el potencial:

Atención al cliente: Bots que consultan CRMs y resuelven casos
Desarrollo: Agentes que leen código, ejecutan tests, crean PRs
Análisis: LLMs que consultan métricas y generan reportes

Y está emergiendo un nuevo paradigma: MCP first.

Así como hace años pensábamos "¿nuestra plataforma expone APIs?" ahora preguntamos "¿nuestro sistema tiene un MCP server?".

Ejemplo práctico: Tu propio MCP Server

Crear un MCP server es sorprendentemente simple:

// weather-mcp-server.ts
import { MCPServer } from '@modelcontextprotocol/sdk';

const server = new MCPServer({
  name: 'weather-service',
  version: '1.0.0'
});

// Definir una tool
server.tool({
  name: 'get_weather',
  description: 'Obtiene el clima actual de una ciudad',
  inputSchema: {
    type: 'object',
    properties: {
      city: { type: 'string', description: 'Nombre de la ciudad' }
    },
    required: ['city']
  },
  async handler({ city }) {
    const data = await fetch(`https://api.weather.com/${city}`);
    return data.json();
  }
});

server.listen();

Ahora cualquier cliente MCP (Claude Desktop, tu app, etc.) puede descubrir y usar esta herramienta sin configuración manual.

Consideraciones de seguridad

No todo es perfecto. En abril de 2025, investigadores de seguridad identificaron riesgos:

Prompt injection: Herramientas maliciosas pueden manipular al modelo
Permisos de tools: Combinar herramientas puede filtrar datos
Lookalike tools: Servers maliciosos pueden suplantar herramientas legítimas

MCP crea una "frontera de confianza" entre el modelo y los sistemas. Es crucial:

Validar servidores antes de conectarlos
Implementar permisos granulares
Auditar las llamadas a tools

Conclusión: El futuro es modular

MCP no solo resuelve un problema técnico de escalabilidad. Está redefiniendo cómo construimos sistemas con IA.

Pasamos de:

LLMs aislados → Solo texto
Function calling → Integraciones N×M caóticas
MCP → Ecosistema estandarizado y componible

El próximo paso es tuyo:

Si eres desarrollador: Explora los MCP servers existentes o crea el tuyo
Si lideras producto: Pregúntate qué valor agregaría un MCP server a tu plataforma
Si construyes con IA: Considera MCP antes de escribir otra integración custom

La era de los agentes autónomos está aquí. MCP es el protocolo que los hace posible.

Referencias

¿Estás usando MCP en tu proyecto? ¿Qué servidor MCP te gustaría que existiera? Comparte en los comentarios.