MCP explicado: Crea un asistente de PostgreSQL en lenguaje natural para Claude.

El problema del código de unión

En algún momento, todo desarrollador que crea productos de IA se topa con el mismo obstáculo. El modelo es capaz, y existen datos útiles almacenados en una base de datos, un sistema de archivos o alguna API. Lo que falta es una forma limpia y estandarizada de combinar ambos elementos.

Así que surge el código de unión: un adaptador aquí, un envoltorio frágil allá. Funciona hasta que el modelo cambia, aparece otra fuente de datos o un nuevo compañero de equipo debe realizar ingeniería inversa de toda la capa de integración.

La solución de Anthropic llegó en noviembre de 2024 con el Model Context Protocol (MCP). En aproximadamente dos años pasó de ser un experimento de nicho a formar parte de la infraestructura principal para agentes: 97 millones de descargas de SDK al mes a mediados de 2026 y casi 10,000 servidores públicos activos en el registro oficial.

Imagínese un producto en el que los usuarios hacen preguntas sobre los datos de la empresa en un inglés sencillo. La idea es sencilla, pero su implementación resulta complicada. El sistema debe interpretar la pregunta, convertirla en una consulta a la base de datos, ejecutarla, devolver los resultados al modelo y formatear una respuesta. Si se multiplica esto por cada herramienta con la que debe interactuar la IA, como un calendario, un repositorio de GitHub o un espacio de trabajo de Slack, cada una se convierte en una integración única con sus propias estructuras de API, flujos de autenticación y formatos de errores.

Algunos ingenieros denominan este resultado “integración espagueti”. Si se cuentan los modelos como N y las herramientas como M, cada combinación requiere su propio código. La adición de un modelo más obliga a reprogramar todas las herramientas, mientras que la incorporación de una herramienta adicional implica actualizar las integraciones de cada modelo.

Qué es MCP

MCP es un estándar abierto, basado en JSON-RPC 2.0, que proporciona a los modelos un vocabulario común para acceder a herramientas y datos externos. El problema de N × M se reduce a N + M, ya que un único servidor sirve a cualquier cliente que siga el protocolo.

La analogía más utilizada es USB-C. Antes, los cargadores variaban según las computadoras portátiles, teléfonos, cámaras y auriculares, cada uno requiriendo su propio cable. USB-C cambió el conector, no la electricidad, y ahora un solo cable sirve para todo. MCP desempeña ese papel en el ámbito de la IA: un modelo que utiliza el protocolo puede acceder a cualquier herramienta que lo soporte, de modo que un servidor escrito una sola vez funciona con todos los modelos compatibles.

La gobernanza convirtió a 2026 en un punto de inflexión. Anthropic entregó MCP a la Agentic AI Foundation en diciembre de 2025, un fondo dirigido dentro de la Linux Foundation que Anthropic, Block y OpenAI cofundaron, lo que indicó que el protocolo ya no pertenecía únicamente a Anthropic. Seguidamente hubo apoyo público: el CEO de OpenAI lo respaldó y anunció su soporte a través del SDK de agentes y ChatGPT, mientras que Google DeepMind confirmó en pocos días que Gemini utilizaría MCP para sus herramientas. Actualmente, el protocolo es la vía predeterminada para que los modelos accedan a herramientas, datos y servicios externos.

Las tres partes

El anfitrión es la aplicación con la que interactúa realmente el usuario: Claude Desktop, una extensión de VS Code o un chatbot interno.

El cliente MCP se encuentra dentro del host. Mantiene conexiones abiertas con uno o más servidores MCP y dirige los mensajes entre el modelo y esos servidores, de modo que cuando el modelo decide llamar a una herramienta, el cliente transmite la solicitud.

El servidor MCP es donde reside la capacidad funcional. Cada servidor envuelve una herramienta o fuente de datos detrás de una interfaz estándar y puede ofrecer tres tipos de elementos:

• Herramientas son funciones llamables como run_sql_query, search_web o send_email. El modelo las utiliza para realizar acciones o obtener datos.
• Recursos son datos legibles, como archivos, filas de base de datos o documentos, que el modelo puede incluir en su ventana de contexto.
• Plantillas de prompts son plantillas reutilizables que el servidor entrega al host.

Los mensajes se codifican en JSON-RPC 2.0 y se transmiten a través de uno de dos métodos de transporte. stdio es adecuado para servidores que funcionan como procesos locales en la máquina del cliente. Streamable HTTP está dirigido a servidores remotos e implementaciones en la nube, utilizando solicitudes HTTP habituales y, opcionalmente, Server-Sent Events (SSE) para respuestas en flujo continuo y notificaciones de servidor a cliente. Debido a esta división, un protocolo abarca tanto el desarrollo local como los sistemas a escala de producción.

Una pregunta, paso a paso

Así es como ocurre todo desde que un usuario escribe una pregunta hasta que recibe una respuesta.

1. Un usuario pregunta: “¿Cuántos pedidos recibimos la semana pasada?”
2. El modelo ve la pregunta junto a la lista de herramientas disponibles, que se obtiene del servidor MCP al iniciar el programa.
3. Decide que se necesita query_database y emite una llamada a la herramienta estructurada.
4. El cliente MCP captura la llamada y la envía al servidor adecuado.
5. El servidor ejecuta la consulta y devuelve el resultado en formato JSON.
6. El modelo lee ese resultado y escribe una respuesta en lenguaje sencillo.

El modelo nunca interactúa directamente con la base de datos, ni necesita la cadena de conexión de antemano, ya que el servidor MCP se encarga de todo eso.

El proyecto: una interfaz de chat para PostgreSQL

Más allá de la teoría, aquí hay algo concreto. Un equipo almacena sus datos de pedidos en PostgreSQL, y los colegas no técnicos siguen pidiendo al único que sabe SQL que prepare informes. El objetivo es una interfaz de chat donde puedan hacer preguntas en inglés sencillo y obtener respuestas en tiempo real sin tener que escribir SQL alguno.

El plan consiste en un servidor MCP frente a la base de datos PostgreSQL, que ofrece una única herramienta query_database y está conectado a Claude. Cualquier miembro del equipo puede entonces hacer una pregunta en lenguaje cotidiano y recibir datos reales como respuesta.

Configuración

Comience con una nueva carpeta de proyecto e instale las dependencias necesarias.

mkdir nl-db-assistant
cd nl-db-assistant
npm init -y
npm install @modelcontextprotocol/sdk pg dotenv zod

Los paquetes dividen el trabajo. @modelcontextprotocol/sdk es el kit oficial de JavaScript y TypeScript de Anthropic para servidores MCP, pg es el cliente habitual de PostgreSQL para Node.js, y dotenv evita que las credenciales de la base de datos aparezcan en el código fuente. zod verifica los esquemas en tiempo de ejecución, y MCP depende de él para generar el esquema JSON a través del cual el modelo aprende cómo llamar a la herramienta.

Cree un archivo .env en la raíz del proyecto que contenga la cadena de conexión.

DATABASE_URL=postgresql://your_user:your_password@localhost:5432/your_database

Agregue inmediatamente .env a .gitignore, ya que las credenciales nunca deben ser commitadas.

El esqueleto del servidor

A continuación está server.js, que comienza con las importaciones, el nombre y la versión del servidor, además de un pool de bases de datos.

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import pg from "pg";
import dotenv from "dotenv";

dotenv.config();
// Set up the PostgreSQL connection pool
const pool = new pg.Pool({
  connectionString: process.env.DATABASE_URL,
});
// Create the MCP server instance
const server = new McpServer({
  name: "postgres-assistant",
  version: "1.0.0",
});

El nombre y la versión se comunican al cliente durante el proceso de negociación de capacidades al conectarse. El pool de conexiones se crea una sola vez y se reutiliza para cada consulta, lo cual es mucho más eficiente que abrir una nueva conexión cada vez.

Exposición del esquema

Para que el modelo pueda generar consultas útiles, debe saber qué tablas y columnas existen. El esquema en tiempo real se expone como un recurso MCP legible que puede incorporar al contexto.

server.resource(
  "database-schema",
  "schema://main",
  async (uri) => {
    const result = await pool.query(`
      SELECT
        table_name,
        column_name,
        data_type
      FROM information_schema.columns
      WHERE table_schema = 'public'
      ORDER BY table_name, ordinal_position
    `);

    const schema = result.rows.reduce((acc, row) => {
      if (!acc[row.table_name]) acc[row.table_name] = [];
      acc[row.table_name].push(`${row.column_name} (${row.data_type})`);
      return acc;
    }, {});
    const schemaText = Object.entries(schema)
      .map(([table, cols]) => `${table}:\n  ${cols.join("\n  ")}`)
      .join("\n\n");
    return {
      contents: [{
        uri: uri.href,
        text: schemaText,
      }],
    };
  }
);

information_schema.columns es una vista integrada de PostgreSQL que describe cada tabla y columna. El código la consulta, transforma las filas en texto legible y devuelve ese resultado como recurso. El modelo lo lee antes de decidir cómo formular una consulta, por lo que dispone del esquema completo y no tiene que adivinar qué SQL es válido.

La herramienta de consultas

Este es el corazón del servidor: la herramienta que el modelo utiliza para ejecutar SQL contra la base de datos.

server.tool(
  "query_database",
  "Run a read-only SQL query against the PostgreSQL database. Use this to answer questions about data, counts, trends, or summaries.",
  {
    sql: z.string().describe(
      "A valid PostgreSQL SELECT query. Only SELECT statements are allowed."
    ),
  },
  async ({ sql }) => {
    // Safety gate: only allow SELECT statements
    const trimmed = sql.trim().toUpperCase();
    if (!trimmed.startsWith("SELECT")) {
      return {
        content: [{
          type: "text",
          text: "Error: only SELECT queries are permitted through this interface.",
        }],
        isError: true,
      };
    }
    try {
      const result = await pool.query(sql);
      const output = JSON.stringify(result.rows, null, 2);
      return {
        content: [{
          type: "text",
          text: `Query returned ${result.rowCount} row(s):\n\n${output}`,
        }],
      };
    } catch (err) {
      return {
        content: [{
          type: "text",
          text: `Query failed: ${err.message}`,
        }],
        isError: true,
      };
    }
  }
);

Preste mucha atención a la cadena de descripción, el segundo argumento, ya que el modelo la lee al decidir si y cómo utilizar la herramienta. Escríbala como instrucciones para un pasante inexperto que nunca ha visto la base de datos. El esquema de Zod para el parámetro sql se convierte automáticamente en el esquema JSON que ve el modelo, el cual define la estructura del argumento. Una validación en la parte superior solo acepta sentencias SELECT, por lo que ninguna operación de escritura puede pasar, ya sea intencionadamente o por error.

Inicio del servidor

Finalmente, el servidor se inicia mediante el transporte stdio.

const transport = new StdioServerTransport();
await server.connect(transport);
console.error("PostgreSQL MCP server is running");

Con stdio, el cliente MCP inicia el script como un proceso hijo y se comunica con él a través de la entrada y salida estándar. Es el método de transporte más simple y fiable para el desarrollo local. La línea de registro utiliza deliberadamente console.error para que no contamine el canal stdout que MCP utiliza para los mensajes de protocolo.

Conectar Claude Desktop

Abra el archivo de configuración de Claude Desktop. En macOS se encuentra aquí:

~/Library/Application Support/Claude/claude_desktop_config.json

En Windows, la ruta es:

%APPDATA%\Claude\claude_desktop_config.json

Agregue una entrada para el nuevo servidor:

{
  "mcpServers": {
    "postgres-assistant": {
      "command": "node",
      "args": ["/absolute/path/to/nl-db-assistant/server.js"]
    }
  }
}

Reinicie Claude Desktop y aparecerá un ícono de herramientas pequeño en la interfaz para confirmar que los servidores MCP están conectados y listos.

Probándolo

Funcionan las frases cotidianas: cuántos pedidos llegaron durante la semana pasada, qué categoría de producto generó más ingresos este mes, o quiénes son los cinco clientes más importantes según el valor total de sus pedidos.

Claude lee el recurso de esquema en tiempo real, escribe el SQL adecuado, llama a query_database, recibe los resultados y los convierte en una respuesta clara. Los colegas no técnicos nunca ven la consulta, solo la pregunta y la respuesta.

Aproximadamente 80 líneas de JavaScript generan un servidor que muestra el esquema en tiempo real de PostgreSQL de cualquier modelo conectado, convierte las preguntas en lenguaje natural en consultas SQL, mantiene el acceso en modo solo lectura y devuelve una salida estructurada que el modelo puede resumir. Fue escrito una sola vez, y cualquier modelo compatible con MCP, ya sea Claude ahora o otro en el futuro, puede utilizarlo sin necesidad de modificar el servidor. Ese es el beneficio de un protocolo compartido.

Números de adopción

La adopción ha sido vertiginosa. Las descargas mensuales del SDK aumentaron de 100,000 en el lanzamiento a 97 millones para marzo de 2026, lo que representa un incremento de unas 970 veces en 18 meses. En contraste, el paquete npm de React tardó aproximadamente tres años en alcanzar 100 millones de descargas mensuales.

El uso en entornos de producción incluye Block, Bloomberg, Amazon y cientos de empresas de la lista Fortune 500. Pinterest describió su configuración MCP para producción en abril de 2026: servidores específicos para Presto, Spark y Airflow, con una persona que aprueba las operaciones sensibles. Se informa que unas 66,000 invocaciones de herramientas al mes por parte de 844 usuarios activos ahorran aproximadamente 7,000 horas de trabajo técnico mensualmente.

Actualmente existen servidores MCP oficiales o mantenidos por la comunidad para Slack, GitHub, Google, Salesforce y Stripe, así como para HubSpot, Shopify, Notion, Linear, Sentry, Figma, Webflow, Cloudflare y Postman.

El tema de la hoja de ruta para 2026 es la preparación para entornos empresariales. Los puntos principales son el inicio de sesión mediante OAuth 2.1 vinculado a proveedores de identidad empresarial, la coordinación entre múltiples agentes donde uno de ellos puede ser llamado como un servidor de herramientas, y un registro cuidadosamente seleccionado de servidores verificados con calificaciones de seguridad.

Preguntas frecuentes

¿Es MCP simplemente una llamada a función con pasos adicionales? No, ya que ambas se encuentran en capas diferentes. La llamada a función es cuando un modelo elige invocar una herramienta, mientras que MCP es el protocolo que conecta al modelo con dicha herramienta. La llamada a función decide si se debe invocar una herramienta, mientras que MCP se encarga de cómo acceder a ella y comunicarse con ella. Las configuraciones modernas típicas combinan ambos.

¿Solo funciona con Claude? En absoluto, y esa es una de sus mejores características. OpenAI, Google DeepMind y Microsoft han adoptado MCP, al igual que miles de equipos de desarrollo. Un modelo con un cliente compatible con MCP puede utilizar cualquier servidor MCP, independientemente de quién haya creado cada componente.

¿Está listo para producción en 2026? Para la mayoría de los usos, sí, dadas las amplias implementaciones mencionadas anteriormente. Sin embargo, en sistemas donde la latencia es crítica, como las operaciones de trading en tiempo real o los requisitos de menos de 100 ms, la abstracción conlleva costos, y las conexiones API directas podrían ser superiores a las mediadas por MCP.

¿Es lo suficientemente seguro para su uso en empresas? Se está acercando a ese nivel. La actualización de las especificaciones de marzo de 2025 incluyó un marco de autorización completo basado en OAuth 2.1, y la hoja de ruta para 2026 prevé la integración con SAML y OIDC con proveedores de identidad como Okta y Azure AD. Los sectores altamente regulados, como las finanzas o la salud, aún necesitan capas adicionales de cumplimiento por el momento.

¿Quién lo gobierna, y ¿podría Anthropic cambiar de dirección? Desde diciembre de 2025, el protocolo está bajo la Agentic AI Foundation, que forma parte de la Linux Foundation. Esto lo convierte en una infraestructura compartida, neutral con respecto a los proveedores y gestionada por la comunidad, comparable a HTTP o TCP/IP, y ninguna empresa puede redirigirlo unilateralmente.

¿Qué diferencia a una herramienta de un recurso? Una herramienta es una acción que el modelo elige realizar, como ejecutar una consulta, enviar un mensaje o crear un archivo. Un recurso son los datos que el modelo lee de forma pasiva, como un archivo, un esquema o un documento. Los recursos se cargan en el contexto, pero las herramientas se ejecutan según sea necesario durante la conversación.

¿Puede un servidor cubrir varios bases de datos o servicios? Sí. Un servidor puede ofrecer tantas herramientas y recursos como sea necesario, y un diseño común es el de un servidor de plataforma de datos que brinda acceso de lectura a varias bases de datos, cada una expuesta como una herramienta o recurso distinto.

Leer más

• Notas prácticas: Protocolo de Contexto de Modelo (MCP) explicado: Guía para principiantes — Guía paso a paso de las Notas prácticas: Protocolo de Contexto de Modelo (MCP) explicado: Guía para principiantes: contratos, verificaciones y espacios para código listo para usar para los equipos que implementan este patrón.
• Notas prácticas: El nuevo MCP es estadoless: Dentro del protocolo 2026–07–28 — Guía paso a paso de las Notas prácticas: El nuevo MCP es estadoless: Dentro del protocolo 2026–07–28: contratos, verificaciones y espacios para código integrable para los equipos que implementan este patrón.