Jeff Bruchado
Volver al blog

MCP (Model Context Protocol): El Estándar de Anthropic Que Está Unificando Agentes de IA

Hola HaWkers, en 2026 estamos presenciando algo raro en la industria tecnológica: empresas competidoras adoptando el mismo estándar abierto. El Model Context Protocol (MCP), creado por Anthropic, está siendo llamado el "USB-C de la IA" y ya ha sido adoptado por OpenAI, Microsoft y Google.

¿Por qué es tan importante este protocolo? ¿Y cómo cambia la forma de construir aplicaciones con agentes de IA?

El Problema de la Fragmentación

Cada empresa tenía su propia solución.

Antes de MCP

Cómo era conectar IA a herramientas:

OpenAI Function Calling:

// Formato específico de OpenAI
const tools = [{
  type: "function",
  function: {
    name: "get_weather",
    description: "Get weather for a location",
    parameters: {
      type: "object",
      properties: {
        location: { type: "string" }
      }
    }
  }
}];

Anthropic Tool Use:

// Formato específico de Anthropic
const tools = [{
  name: "get_weather",
  description: "Get weather for a location",
  input_schema: {
    type: "object",
    properties: {
      location: { type: "string" }
    }
  }
}];

Google Gemini Functions:

// Otro formato diferente
const tools = [{
  functionDeclarations: [{
    name: "get_weather",
    description: "Get weather for a location",
    parameters: {
      type: "OBJECT",
      properties: {
        location: { type: "STRING" }
      }
    }
  }]
}];

Tres formatos diferentes para hacer lo mismo. Los desarrolladores necesitaban mantener código separado para cada proveedor.

Qué es MCP

Protocolo abierto y universal.

Arquitectura de MCP

Cómo funciona:

┌─────────────────────────────────────────────────────────┐
│                    MCP Host (Client)                     │
│              (Claude, GPT, Gemini, etc.)                │
└────────────────────────┬────────────────────────────────┘
                         │
                    MCP Protocol
                    (JSON-RPC 2.0)
                         │
         ┌───────────────┼───────────────┐
         ▼               ▼               ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│  MCP Server  │ │  MCP Server  │ │  MCP Server  │
│   (GitHub)   │ │   (Slack)    │ │  (Database)  │
└──────────────┘ └──────────────┘ └──────────────┘

Conceptos Fundamentales

Tres tipos de recursos:

1. Tools (Herramientas):

// Acciones que el agente puede ejecutar
{
  "name": "create_issue",
  "description": "Create a GitHub issue",
  "inputSchema": {
    "type": "object",
    "properties": {
      "title": { "type": "string" },
      "body": { "type": "string" },
      "repo": { "type": "string" }
    },
    "required": ["title", "repo"]
  }
}

2. Resources (Recursos):

// Datos que el agente puede acceder
{
  "uri": "github://repos/user/project/issues",
  "name": "Project Issues",
  "mimeType": "application/json",
  "description": "List of open issues in the project"
}

3. Prompts (Plantillas):

// Plantillas de interacción predefinidas
{
  "name": "code_review",
  "description": "Review code changes",
  "arguments": [
    {
      "name": "pr_url",
      "description": "Pull request URL",
      "required": true
    }
  ]
}

Implementando un MCP Server

Creando tu propia integración.

Servidor Básico

Estructura de un MCP Server:

// mcp-server.js
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

const server = new Server({
  name: 'my-mcp-server',
  version: '1.0.0',
}, {
  capabilities: {
    tools: {},
    resources: {},
  },
});

// Definir herramientas disponibles
server.setRequestHandler('tools/list', async () => {
  return {
    tools: [
      {
        name: 'search_database',
        description: 'Search records in the database',
        inputSchema: {
          type: 'object',
          properties: {
            query: {
              type: 'string',
              description: 'Search query'
            },
            limit: {
              type: 'number',
              description: 'Max results',
              default: 10
            }
          },
          required: ['query']
        }
      }
    ]
  };
});

// Implementar ejecución de herramienta
server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params;

  if (name === 'search_database') {
    const results = await searchDB(args.query, args.limit);
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(results, null, 2)
        }
      ]
    };
  }

  throw new Error(`Unknown tool: ${name}`);
});

// Iniciar servidor
const transport = new StdioServerTransport();
await server.connect(transport);

Servidor con Resources

Exponiendo datos al agente:

// Listar recursos disponibles
server.setRequestHandler('resources/list', async () => {
  return {
    resources: [
      {
        uri: 'myapp://users/active',
        name: 'Active Users',
        description: 'List of currently active users',
        mimeType: 'application/json'
      },
      {
        uri: 'myapp://metrics/daily',
        name: 'Daily Metrics',
        description: 'Today\'s application metrics',
        mimeType: 'application/json'
      }
    ]
  };
});

// Leer contenido de un recurso
server.setRequestHandler('resources/read', async (request) => {
  const { uri } = request.params;

  if (uri === 'myapp://users/active') {
    const users = await getActiveUsers();
    return {
      contents: [
        {
          uri,
          mimeType: 'application/json',
          text: JSON.stringify(users)
        }
      ]
    };
  }

  if (uri === 'myapp://metrics/daily') {
    const metrics = await getDailyMetrics();
    return {
      contents: [
        {
          uri,
          mimeType: 'application/json',
          text: JSON.stringify(metrics)
        }
      ]
    };
  }

  throw new Error(`Resource not found: ${uri}`);
});

Servidores MCP Populares

Integraciones listas para usar.

Servidores Oficiales

Disponibles de Anthropic:

GitHub:

npx @anthropic/mcp-server-github
  • Crear/editar issues y PRs
  • Buscar código en repositorio
  • Acceder historial de commits

Slack:

npx @anthropic/mcp-server-slack
  • Enviar mensajes
  • Listar canales
  • Buscar historial

PostgreSQL:

npx @anthropic/mcp-server-postgres
  • Ejecutar queries
  • Listar tablas
  • Acceder schema

Filesystem:

npx @anthropic/mcp-server-filesystem
  • Leer/escribir archivos
  • Listar directorios
  • Buscar contenido

Configuración en Claude Desktop

Cómo conectar servidores:

// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["@anthropic/mcp-server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_xxxxxxxxxxxx"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["@anthropic/mcp-server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost/db"
      }
    },
    "custom": {
      "command": "node",
      "args": ["/path/to/my-mcp-server.js"]
    }
  }
}

Adopción por la Industria

Quién está usando MCP.

OpenAI y Microsoft

Anuncio oficial en enero 2026:

  • OpenAI adoptó MCP para GPT-4 y GPT-5
  • Microsoft lo integró en Copilot
  • Azure AI Services soporta MCP nativamente

Beneficios inmediatos:

  • Desarrolladores escriben una integración, funciona en todos los modelos
  • Ecosistema compartido de servidores MCP
  • Reducción del 70% en código de integración

Google

Implementación gradual:

  • Gemini Pro soporta MCP desde diciembre 2025
  • Google Cloud ofrece servidores MCP gestionados
  • Vertex AI tiene soporte nativo

Comunidad Open Source

Crecimiento explosivo:

Estadísticas GitHub (Enero 2026):

  • 500+ servidores MCP públicos
  • 12k+ stars en repositorio principal
  • 200+ contribuidores activos

Servidores populares de la comunidad:

  • Notion MCP Server
  • Jira MCP Server
  • AWS MCP Server
  • Linear MCP Server
  • Figma MCP Server

Casos de Uso Avanzados

Aplicaciones prácticas de MCP.

Agente de DevOps

Workflow automatizado:

// El agente puede usar múltiples servidores MCP
// para crear un workflow completo

// 1. Recibe alerta de PagerDuty (MCP Server)
// 2. Busca logs en DataDog (MCP Server)
// 3. Identifica el problema
// 4. Crea issue en GitHub (MCP Server)
// 5. Notifica en Slack (MCP Server)
// 6. Sugiere fix y abre PR (MCP Server)

// Prompt del usuario:
// "Investiga la alerta de alta latencia y crea
// un issue con tu análisis"

// El agente automáticamente:
// - Consulta métricas
// - Analiza logs
// - Correlaciona eventos
// - Documenta findings
// - Notifica equipo

Agente de Análisis de Datos

Acceso a múltiples fuentes:

// Servidores MCP conectados:
// - PostgreSQL (datos transaccionales)
// - BigQuery (datos analíticos)
// - Notion (documentación)
// - Slack (contexto de negocio)

// Prompt: "Analiza las ventas del último trimestre
// y compara con las metas definidas en Notion"

// El agente:
// 1. Busca metas en Notion
// 2. Query ventas en PostgreSQL
// 3. Agregaciones en BigQuery
// 4. Genera reporte
// 5. Publica resumen en Slack

Seguridad y Buenas Prácticas

Cómo implementar con seguridad.

Control de Acceso

Limitando permisos:

// Definir alcance de permisos
const server = new Server({
  name: 'secure-mcp-server',
  version: '1.0.0',
}, {
  capabilities: {
    tools: {
      // Solo herramientas de lectura
      allowedOperations: ['read', 'search']
    },
    resources: {
      // Recursos específicos
      allowedPatterns: ['myapp://public/*']
    },
  },
});

// Validar inputs
server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params;

  // Sanitizar inputs
  const sanitizedArgs = sanitize(args);

  // Verificar rate limits
  await checkRateLimit(request.context.clientId);

  // Audit log
  await logAccess({
    tool: name,
    args: sanitizedArgs,
    client: request.context.clientId,
    timestamp: new Date()
  });

  return executeTool(name, sanitizedArgs);
});

El Model Context Protocol representa un cambio fundamental en cómo construimos aplicaciones con IA. Por primera vez, tenemos un estándar abierto adoptado por todos los principales jugadores. Esto reduce la fragmentación, acelera el desarrollo y crea un ecosistema robusto de integraciones.

Si quieres entender más sobre agentes de IA en la práctica, te recomiendo ver otro artículo: n8n y Workflows de Agentes IA donde descubrirás cómo crear automatizaciones inteligentes sin código.

¡Vamos con todo! 🦅

🎯 Únete a los Desarrolladores que Están Evolucionando

Miles de desarrolladores ya usan nuestro material para acelerar sus estudios y conquistar mejores posiciones en el mercado.

¿Por qué invertir en conocimiento estructurado?

Aprender de forma organizada y con ejemplos prácticos hace toda la diferencia en tu camino como desarrollador.

Comienza ahora:

  • 1x de $4.90 con tarjeta
  • o $4.90 al contado

🚀 Acceder a la Guía Completa

"¡Material excelente para quienes quieren profundizar!" - Juan, Desarrollador

Comentarios (0)

Este artículo aún no tiene comentarios 😢. ¡Sé el primero! 🚀🦅

Añadir comentarios