MCP desde cero: qué es y qué problema resuelve

󰃭 2026-11-18 · 8 min de lectura

Contenido

MCP es una sigla que veía pasar por todas partes sin saber bien qué había detrás. No había trabajado nunca con ello. Esta serie es lo que habría querido encontrar el primer día: empezar de cero, entender qué es, mirar el protocolo por dentro, montar un servidor de verdad sobre PostgreSQL, y después probarlo, romperle el diseño, atacarlo y publicarlo por HTTP.

Son siete entradas. Esta es la primera y es solo teoría, más un servidor de ocho líneas para que haya algo que ejecutar.

Una advertencia que me habría ahorrado una tarde: MCP ha cambiado mucho este año. La mayoría de tutoriales que encuentras en internet describen la versión anterior del protocolo (con un «apretón de manos» inicial y sesiones) y una API de Python que ya no existe con ese nombre. Esta serie usa la versión de protocolo 2026-07-28 y el SDK oficial de Python 2.3, que es lo vigente mientras escribo esto. Cuando algo difiera de lo que verás en otros sitios, lo digo.

El código está en Codeberg: https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-mcp.

El problema que resuelve #

Un asistente de IA, por sí solo, solo sabe lo que sabe. No ve tu base de datos, ni tus ficheros, ni tu sistema de tickets. Para que pueda mirarlos (o hacer algo en ellos) alguien tiene que escribir la integración.

Sin un estándar, cada aplicación con un modelo necesita una integración propia con cada sistema: si hay M aplicaciones y N sistemas, son M × N trabajos. Si te dedicas a bases de datos esto te suena: es el problema que resolvieron ODBC y JDBC. Cada aplicación habla un protocolo común con un driver, y cada base de datos tiene su driver. Pasas de M × N a M + N.

MCP (Model Context Protocol) es eso mismo para asistentes de IA. Lo creó Anthropic y hoy se desarrolla como un proyecto abierto, con especificación pública, SDK en varios lenguajes y un proceso de propuestas de cambio. Si has usado un editor con autocompletado, la otra comparación útil es con el Language Server Protocol: mismo planteamiento (un protocolo estándar entre el editor y los servidores de cada lenguaje) y, de hecho, también va sobre JSON-RPC.

Los tres actores #

Hay tres piezas, y conviene no mezclar los nombres:

 host (la aplicación con el modelo)
 ├── cliente MCP 1 ── stdio ──▶ servidor A   (un proceso en tu máquina)
 ├── cliente MCP 2 ── stdio ──▶ servidor B   (otro proceso en tu máquina)
 └── cliente MCP 3 ── HTTP  ──▶ servidor C   (remoto)
  • Host: la aplicación donde vive el modelo. Un editor, un asistente de escritorio, una herramienta de línea de comandos, o un programa tuyo.
  • Cliente MCP: la parte del host que habla el protocolo. El host crea uno por cada servidor al que se conecta; cada cliente mantiene su conexión con su servidor.
  • Servidor MCP: un programa que ofrece capacidades. Eso es lo que vamos a escribir.

«Servidor» aquí no quiere decir «máquina remota»: un servidor MCP puede ser un proceso que el host lanza en tu propio equipo. Que sea local o remoto depende solo del transporte, que veremos en un momento.

Qué ofrece un servidor: tres cosas #

Un servidor puede ofrecer tres tipos de cosas. La diferencia entre ellas no es técnica sino de quién decide usarlas, y es la mejor forma de recordarlas:

QuéPara qué sirveQuién decide usarlo
Tool (herramienta)Una función que el modelo puede llamar: buscar usuarios, crear un evento, consultar un pedido.El modelo
Resource (recurso)Datos de solo lectura con una dirección (URI): un fichero, el esquema de una base de datos, una ficha.La aplicación
PromptUna plantilla de instrucciones con parámetros, para tareas que se repiten.El usuario

Para traducirlo a vocabulario de APIs (a medias, como todas las traducciones): una herramienta se parece a un endpoint RPC con parámetros tipados y un resultado; un recurso, a un GET sobre una URI; y un prompt, a una macro. En la práctica las herramientas son lo que más se usa, y lo que ocupa casi toda la serie.

Lo que hace especial a una herramienta, frente a un endpoint, es quién la llama y cómo se entera de que existe. A un endpoint lo llama un programa que escribió una persona leyendo la documentación. A una herramienta MCP la llama un modelo, que se entera de que existe porque el servidor se lo cuenta en tiempo de ejecución: el nombre, una descripción en lenguaje natural y un esquema JSON de los parámetros. El modelo decide si le sirve y con qué argumentos. Esa descripción forma parte de la interfaz, y de ahí sale casi todo lo interesante de las entradas 5 y 6.

Cómo viaja por debajo #

El mensaje es siempre JSON-RPC 2.0: peticiones con un method y unos params, y respuestas con un result o un error. Hay dos transportes:

  • stdio: el host lanza el servidor como proceso hijo y le habla por la entrada y la salida estándar. Es lo normal para servidores locales, sin red y sin puertos.
  • Streamable HTTP: peticiones POST a una URL (por convención, /mcp). Es lo que se usa para servidores remotos, con autenticación HTTP normal.

Y, desde la versión de protocolo 2026-07-28, MCP no tiene estado. Cada petición lleva dentro todo lo necesario para procesarla: la versión del protocolo y las capacidades del cliente, en un campo _meta. No hay un initialize inicial ni una sesión. Un cliente puede preguntar qué ofrece el servidor con una petición server/discover, pero es opcional.

Que no haya sesión tiene una consecuencia práctica que se aprecia en la última entrada: un servidor remoto se puede repartir entre varias réplicas con un balanceador cualquiera, sin pegajosidad. Con la versión anterior, un cliente abría una sesión y todas sus peticiones tenían que llegar al mismo sitio.

El SDK actual atiende los dos mundos: un cliente moderno usa el protocolo nuevo, y uno antiguo hace su initialize de siempre y también funciona. En la siguiente entrada lo veremos con mensajes escritos a mano.

Un primer servidor #

El SDK oficial de Python 2.x se instala con pip (necesita Python 3.10 o posterior):

ignacio@localhost:~/lab-mcp$ python3 -m venv .venv && source .venv/bin/activate
ignacio@localhost:~/lab-mcp$ pip install "mcp[cli]>=2,<3"

Ojo con el <3: lo que instala pip install mcp es la serie 2.x, y conviene fijar el límite superior para que una versión mayor no te rompa los ejemplos.

El servidor mínimo, con una sola herramienta:

# hola/hola.py
from mcp.server import MCPServer

mcp = MCPServer("Hola")


@mcp.tool()
def sumar(a: int, b: int) -> int:
    """Suma dos números enteros."""
    return a + b


if __name__ == "__main__":
    mcp.run()

Tres cosas, que se repetirán toda la serie:

  • MCPServer("Hola") crea el servidor. Ese nombre es el que verán los clientes. (Si has visto tutoriales con FastMCP, es el mismo concepto con otro nombre: en el SDK 2.x FastMCP ya no existe y se usa MCPServer.)
  • @mcp.tool() convierte la función en herramienta. El nombre sale del nombre de la función, la descripción de la docstring y el esquema de los parámetros de las anotaciones de tipo. No hay que escribir ningún JSON Schema.
  • mcp.run() arranca el servidor; por defecto, por stdio.

Si lo ejecutas directamente se queda esperando mensajes por la entrada estándar, que no es muy interesante. Para hablar con él hace falta un cliente, y el SDK trae uno. Este lanza hola.py como proceso hijo, pregunta qué herramientas ofrece y llama a una:

# hola/cliente_hola.py
import sys

import anyio

from mcp import Client, StdioServerParameters


async def main() -> None:
    # Lanza hola.py como proceso hijo y habla con él por stdin/stdout.
    params = StdioServerParameters(command=sys.executable, args=["hola.py"])
    async with Client(params) as client:
        print("servidor:", client.server_info.name, "| protocolo:", client.protocol_version)

        for herramienta in (await client.list_tools()).tools:
            print("herramienta:", herramienta.name, "-", herramienta.description)
            print("  parámetros:", herramienta.input_schema["properties"])

        resultado = await client.call_tool("sumar", {"a": 2, "b": 3})
        print("resultado:", resultado.structured_content)


anyio.run(main)
ignacio@localhost:~/lab-mcp$ cd hola && python cliente_hola.py
servidor: Hola | protocolo: 2026-07-28
herramienta: sumar - Suma dos números enteros.
  parámetros: {'a': {'title': 'A', 'type': 'integer'}, 'b': {'title': 'B', 'type': 'integer'}}
resultado: {'result': 5}

El cliente ha descubierto la herramienta sin que se la hayamos descrito en ningún sitio: nombre, descripción y los dos parámetros enteros salieron de la función. Y el resultado vuelve como {'result': 5}: MCP envuelve en un objeto lo que no lo es.

Lo que MCP no es #

Para no esperar de él lo que no hace:

  • No decide cómo usa el modelo las herramientas. El protocolo solo define cómo se anuncian y cómo se llaman. Qué herramienta elige el modelo, con qué argumentos y cuándo, es cosa del modelo y del host. El servidor no controla eso.
  • No es una capa de seguridad. El protocolo lleva cosas de autorización para servidores remotos, pero que un servidor sea MCP no lo hace seguro ni de fiar. Un servidor local es un proceso normal con tus permisos. De esto va la entrada 6.
  • No es un framework de agentes. Un agente puede usar MCP para llegar a sus herramientas, pero MCP no orquesta nada.

Dónde estamos #

Tenemos el vocabulario (host, cliente, servidor; herramientas, recursos, prompts), sabemos que va sobre JSON-RPC por stdio o HTTP, que ahora no tiene estado, y que un servidor mínimo son ocho líneas.

En la siguiente entrada quito el SDK de en medio y le hablo a este mismo servidor escribiendo los mensajes a mano, por stdio y por HTTP con curl. Es la forma más rápida de que el protocolo deje de parecer magia.

Para saber más, la descripción de la arquitectura en la documentación oficial y la documentación del SDK de Python.


Serie: MCP desde cero [RSS]

  1. MCP desde cero: qué es y qué problema resuelve

¿Comentarios? Esta entrada tiene un hilo en Mastodon: responde allí y la conversación se queda en el fediverso.

Cargando comentarios desde mastodon.social…

Ingrese la dirección de su instancia


Más posts como este