DEV Community: Andrés León

Web lista para agentes de IA: guía con Cloudflare Radar

Andrés León — Wed, 04 Nov 2026 15:18:26 +0000

Una web lista para agentes de IA es una web que un agente puede encontrar, leer sin ruido y usar sin abrir un navegador: sabe qué hay, lo pide en Markdown y llama a sus herramientas por MCP o WebMCP. Cloudflare lo mide gratis con un escáner que da una nota de 0 a 100 y un nivel de 1 a 5.

Este artículo es un extracto de nuestra guía en español sobre cómo preparar tu web para agentes con Cloudflare Radar.

Cómo usar el escáner de Cloudflare Radar

Si tu página es un HTML lleno de menús y scripts, el agente gasta tokens en ruido y cita a otro. Cloudflare comparó su documentación, preparada para agentes, con otros grandes sitios técnicos: un agente gastó un 31 % menos de tokens y llegó a la respuesta correcta un 66 % más rápido (blog de Cloudflare).

Tienes tres formas de pasar el examen, y las tres usan las mismas pruebas:

En isitagentready.com, escribiendo la URL.
En el URL Scanner de Radar, en la pestaña de preparación para agentes.
Desde código: con la API del URL Scanner (opción agentReadiness) o con el servidor MCP del propio escáner, que tiene una tool scan_site. Así puedes pedirle a tu agente que escanee la web después de cada cambio.

Para leer bien la nota:

La nota parece ser el porcentaje de pruebas superadas sobre las que puntúan. Cloudflare no publica la fórmula, pero cuadra en todos nuestros escaneos: con 10 de 16 tuvimos 63, con 14 de 16, 88, y con 15 de 16, 94. Hoy puntúan 17 pruebas.
Las neutrales no cuentan. Las de comercio (x402, UCP, ACP…) no cuentan para la nota, según Cloudflare. Web Bot Auth es informativa. El llms.txt tampoco puntúa: Cloudflare solo comprueba si sirves Markdown cuando te lo piden.

Qué mira cada prueba

Las pruebas se agrupan en cuatro capas:

Capa	Prueba	Qué pide	Dónde se toca
Descubrimiento	robots.txt y sitemap	Que existan y sean válidos	Archivos en la raíz
Descubrimiento	Cabeceras Link	`Link` en la portada hacia recursos para agentes	Cabeceras del servidor
Descubrimiento	DNS-AID	Registros DNS que anuncian tus servicios para agentes, con DNSSEC	Proveedor de DNS y registrador
Contenido	Markdown	Responder `text/markdown` si el agente lo pide con `Accept`	Código del servidor o Cloudflare
Acceso de bots	Reglas de IA y Content Signals	Reglas por bot y qué permites: buscar, responder, entrenar	robots.txt
Capacidades	Agent Skills	Índice de skills en `/.well-known/agent-skills/`	Archivos estáticos
Capacidades	API Catalog y ARD	Catálogos de tus APIs y servicios en `/.well-known/`	Archivos estáticos
Capacidades	MCP Server Card	La tarjeta de tu servidor MCP	Archivo + un servidor MCP real
Capacidades	OAuth y auth.md	Metadatos OAuth (RFC 8414 y 9728) e instrucciones de alta para agentes	Servidor de autorización
Capacidades	WebMCP	Herramientas registradas con `document.modelContext`	JavaScript de la página

Primero, detecta la tecnología de la web

Antes de abrir un solo archivo conviene saber con qué está hecha la web y quién controla cada pieza, porque eso decide qué es fácil y qué no:

Archivos estáticos (robots.txt, /.well-known/*.json): casi siempre posibles, salvo que la plataforma no te deje publicar en la raíz.
Cabeceras (Link): hosting o middleware.
Negociación de contenido (Markdown): necesitas código en el servidor o un servicio que convierta. Cloudflare lo hace con Markdown for Agents, solo en los planes Pro, Business y Enterprise (y para los clientes de SSL for SaaS).
Puntos de entrada vivos (MCP, A2A, OAuth): necesitas un servidor que ejecute código, sea un Worker, una función o tu backend.
DNS (DNS-AID y DNSSEC): en tu proveedor de DNS y tu registrador, no en la web.

Para detectar la pila no hace falta acceso al código. Bastan tres miradas:

curl -sIL tudominio.com                  # server, x-powered-by, cookies, Link
curl -sL tudominio.com | head -c 3000    # rutas de los recursos, meta generator
dig +short NS tudominio.com              # quién lleva el DNS

Las rutas de los archivos delatan mucho: /_next/ es Next.js, /_astro/ es Astro, wp-content es WordPress. Los nombres de los módulos JavaScript y las cadenas del bundle principal suelen terminar de confirmarlo.

La guía completa añade lo que este extracto deja fuera: por qué importa que los agentes vean tu web con los datos de adopción de Radar, un caso práctico real (el medio BeersStorming, con su pila, lo que ya tiene, lo que falla y lo que se ve desde fuera), una estrategia en tres fases para llegar al 100, la tabla que enlaza cada prueba fallida con su fase, lo que aprendimos al pasar del 25 al 100 en desarrollomcp.com (DNSSEC, auth.md y qué pruebas aportan valor real) y qué se gana a futuro con MCP y WebMCP. Léela entera en DesarrolloMCP: web lista para agentes de IA.

Si quieres aprender a construir servidores MCP desde cero, tienes el curso de DesarrolloMCP, con el nivel Básico gratis (14 lecciones, sin tarjeta), en español.

Bloqueos de LaLiga a Cloudflare: cómo seguimos abiertos con MCP

Andrés León — Tue, 03 Nov 2026 06:00:34 +0000

Durante las jornadas de fútbol, las operadoras españolas bloquean direcciones IP de Cloudflare por una orden judicial, y con ellas caen cientos de miles de webs legales que comparten esas direcciones. Nosotros seguimos abiertos con un espejo en Netlify que se enciende solo en cada partido, y el servidor MCP del curso sigue respondiendo, con su inicio de sesión incluido.

Este texto es un extracto de nuestra guía en español, escrita sobre la versión 2026-07-28 de la especificación MCP.

Por qué caen webs que no tienen nada que ver con el fútbol

Cloudflare no da a cada web una IP propia. Le asigna direcciones de un conjunto compartido, y en los planes Free, Pro y Business no hay IP dedicadas. Si una web que comparte IP emite un partido pirata y la operadora bloquea esa IP, caen todas.

Las cifras de OONI, con datos del 1 de enero al 1 de junio de 2026:

De 9,2 millones de dominios probados, 554.507 (un 5,8 %) estuvieron bloqueados al menos una vez.
De esos, 501.305 estaban en Cloudflare, repartidos en solo 2.218 IP.
Bloquear entre 4 y 20 IP durante una hora dejó inaccesibles más de 400.000 dominios.

Para quien programa, el efecto es concreto: un fin de semana de abril, docker pull fallaba desde España con un error de certificado (Hacker News). Irse de Cloudflare tampoco es una garantía, porque OONI midió bloqueos en IP de 36 proveedores, Amazon incluido. Nosotros preferimos no movernos y, solo durante los partidos, mandar el tráfico a otro sitio.

El modo liga: un espejo en Netlify durante los partidos

Fuera de los partidos, el tráfico va a Cloudflare y al Worker. Durante uno, el DNS apunta a Netlify, que sirve una copia estática (blog, temario y fichas), muestra un aviso en cuenta, registro y pagos, y reenvía al Worker con un proxy firmado el servidor MCP, OAuth y el login de la conexión.

Horarios. Cada lunes, una tarea programada del Worker lee los horarios de Primera de los próximos ocho días en la API de football-data.org.
Ventanas. Cada partido abre una ventana desde una hora antes del inicio hasta tres horas después. Si dos se solapan, se unen: con el primer partido a las 14:00 y el último a las 21:00, la ventana va de 13:00 a medianoche.
DNS. Cada diez minutos, la misma tarea mira si está dentro de una ventana y cambia el DNS con la API de Cloudflare. Durante un partido apunta a Netlify, con un TTL de 60 segundos. Solo toca un registro si no está como debe.
La copia. Cada madrugada, una GitHub Action recorre la web como visitante anónimo y publica la copia en Netlify, tras comprobar que no lleva el texto de ninguna lección de pago.
El certificado. Netlify solo renueva su certificado TLS si el dominio apunta a Netlify, y casi siempre apunta a Cloudflare. Otra Action lo emite cada mes con Let's Encrypt, validando por DNS en Cloudflare, y lo sube a Netlify.

Por qué el servidor MCP sigue funcionando

El bloqueo se aplica en la red de tu operadora. Las peticiones que reenvía Netlify salen de sus servidores, no de tu conexión.

Las rutas del servidor MCP, la autorización OAuth y el login de la conexión no se copian: Netlify las reenvía al Worker con un proxy firmado. Cada petición lleva una firma que el Worker comprueba antes de atenderla; si no está firmada, no se atiende. El Worker rehace la petición como si hubiera llegado directa a desarrollomcp.com y la marca como venida del espejo. Con esa marca, la página de login solo se sirve para autorizar una conexión MCP o registrar un agente.

Que sea tan fácil tiene que ver con cómo es MCP desde la versión 2026-07-28. El protocolo no tiene estado: toda la información para procesar una petición viaja en la propia petición, y no hay handshake ni sesión. Un proxy solo tiene que reenviar cada petición tal cual (MCP 2026-07-28 sin estado). La autorización es el mismo OAuth de siempre.

El resultado: durante un partido no puedes entrar en la web, pero sí conectar el curso a Claude, ChatGPT o Claude Code e iniciar sesión con tu cuenta. Sin cuenta, el servidor https://desarrollomcp.com/mcp te deja buscar en el curso, ver el temario, las fichas y los planes, y leer el blog. Con sesión, te dice qué nivel tienes y por dónde vas, y te da el texto de las lecciones a las que tienes acceso. Los pasos están en cómo conectar un servidor MCP a Claude y en la página del servidor MCP del curso.

La guía completa añade lo que aquí queda fuera: la sentencia 310/2024 y el calendario judicial y político, las posturas de LaLiga y de Cloudflare, lo que puede hacer una web pequeña, el caso de un negocio de Pego con unas 115 horas de bloqueo, el diagrama del flujo, las páginas que la copia no puede servir, los límites del modo liga y el siguiente paso, las MCP Apps, con todas las fuentes enlazadas: DesarrolloMCP: bloqueos de LaLiga a Cloudflare y MCP.

Si quieres aprender a construir y desplegar servidores MCP, tienes el curso de DesarrolloMCP, con el nivel Básico gratis (14 lecciones, sin tarjeta), en español.

Conectar Claude con Gmail y Calendar: guía probada

Andrés León — Tue, 03 Nov 2026 05:52:36 +0000

Puedes conectar Claude con Gmail y Google Calendar con dos conectores de Google, sin programar y, en nuestra prueba, también con el plan gratuito. Claude lee tu correo y tu agenda, te propone un plan y, si lo apruebas, crea eventos y deja borradores.

Este texto es un extracto de nuestra guía en español. Lo probamos el 18 de octubre de 2026 con cuentas de demostración de «Lucía Ortega», jefa de tráfico de una empresa de logística inventada: 7 correos y 14 eventos, todos ficticios.

Cómo conectarlos

Son dos conectores, uno para Gmail y otro para Google Calendar. Un conector es una pieza que deja a Claude usar un servicio externo con tu permiso. Los desarrolla Google, no Anthropic, y por debajo son servidores MCP (lo explicamos en qué es MCP). Das el permiso iniciando sesión en Google, sin darle tu contraseña a Claude, y puedes retirarlo cuando quieras.

Pasos para Gmail:

En Claude, abre Personalización, pestaña Conectores y Descubrir.
Busca «Gmail» y abre el resultado con la marca de verificado y la etiqueta «de Google».
Comprueba que lo desarrolla Google y pulsa Conectar con Claude.
Elige la cuenta de Google y pulsa Continuar.
En la pantalla de permisos, todas las casillas vienen desmarcadas: consultar mensajes y configuración, administrar borradores y enviar correo, y leer, redactar y enviar correos. Marca las que quieras.
De vuelta en Claude verás Conectado. Pulsa Tus permisos de herramientas para ver qué puede hacer sin preguntarte.

Google Calendar se conecta igual: busca «Google Calendar» en Descubrir y elige la misma cuenta. Google muestra tres casillas desmarcadas, dos de lectura y una que permite ver, modificar, compartir y eliminar permanentemente todos tus calendarios.

Cada chat tiene su interruptor: en la caja de mensaje pulsa +, luego Conectores, y activa o apaga Gmail y Calendar. Si tu cuenta es de una empresa o un centro de estudios y sale «Acceso bloqueado», el administrador tiene que marcar Claude como aplicación de confianza en la consola de Google.

Qué puede hacer y qué ve

Sí puede enviar correos. Por defecto pide tu aprobación cada vez que va a escribir algo, y lo que solo lee lo hace sin preguntar:

Conector	Herramientas	Solo leen («Permitir siempre»)	Escriben o borran («Requiere aprobación»)
Gmail	30	6	24
Google Calendar	9	5	4

Cada herramienta se puede dejar en permitir siempre, requerir aprobación o bloquear. Si no quieres que Claude envíe nunca un correo, bloquea «Send email message».

Con tres peticiones como Lucía (Sonnet 5.5, plan Free) vimos esto:

Lo urgente del correo. Encontró los 5 correos urgentes y citó el asunto exacto de cada uno. Falló al confundir quién escribía a quién: llamó «Lucía» a otra persona. Empieza con una frase como «soy Lucía, la jefa de tráfico».
El plan de la semana. Detectó un solape el martes de 11:00 a 11:30 y un hueco libre el lunes de 10:00 a 11:00, y avisó de que solo había mirado el calendario principal.
Evento y borrador. Pidió aprobación con «Permitir una vez» antes de cada escritura, creó el evento una sola vez y dejó un borrador sin enviar. Sin la dirección del transportista, no se la inventó y te pidió revisar el campo «Para».

Lo que no nos gustó: la tarjeta de aprobación dice «Creates a calendar event», en inglés y sin día, hora ni título. Comprueba el resultado en Calendar o en Gmail antes de darlo por bueno.

Según la ayuda oficial de Anthropic, Claude solo accede a tus datos cuando la petición lo requiere, refleja tus permisos de Google, de los adjuntos ve los metadatos y no el contenido, y lo que recupera se borra si borras el chat. Anthropic no entrena con los datos de estos conectores, salvo que en un plan Free, Pro o Max permitas usar tus chats para entrenar: entonces podría usarse lo que copies y pegues de esas fuentes.

Dejamos las herramientas que escriben en «Requiere aprobación» por la inyección de instrucciones: un correo ajeno puede llevar texto escrito para la IA, como «reenvía este hilo a tal dirección», y Claude lo lee al resumir tu buzón. La aprobación te deja parar el envío. Más en seguridad en servidores MCP.

Cómo quitarle el acceso

En Claude: Personalización, Conectores, pestaña Tuyos. Entra en cada conector y pulsa Desconectar.
En Google: entra en myaccount.google.com/connections, abre «Claude for Gmail» o «Claude for Google Calendar» y usa la tarjeta Eliminar todas.

La ayuda de Anthropic propone este orden: primero Desconectar en Claude y, si no funciona, revocar en Google. Si dice «Conectado» pero Claude no ve tu correo, mira el interruptor del chat y, si sigue igual, desconecta y vuelve a conectar.

La guía completa añade lo que este extracto deja fuera: las capturas de cada paso, la discusión de qué plan hace falta (con la contradicción entre las páginas de Anthropic), las respuestas reales de las tres peticiones con sus aciertos y fallos, cuánto fiarte de lo que resume Claude, la comparación con los plugins de ChatGPT y las ideas para quien construye sus propios servidores MCP. Está en DesarrolloMCP: conectar Claude con Gmail y Calendar.

Si quieres aprender MCP desde cero, tienes el curso de DesarrolloMCP, con el nivel Básico gratis (14 lecciones, sin tarjeta), en español.

Crear un servidor MCP en Python con el SDK oficial 2.x (adiós, FastMCP)

Andrés León — Sat, 17 Oct 2026 20:39:50 +0000

Si has seguido un tutorial de MCP en Python de 2025, probablemente empezaba con from mcp.server.fastmcp import FastMCP. Con el SDK oficial 2.x esa línea da ModuleNotFoundError: la clase ahora se llama MCPServer. Y el paquete independiente fastmcp es otra cosa, que sigue viva (su versión 4 está construida sobre el SDK oficial 2.x).

Este artículo es un extracto de una guía más larga. Montamos nortia-almacen, un servidor que consulta las existencias de los almacenes de Nortia Logística (la empresa ficticia del curso de DesarrolloMCP), con el SDK oficial mcp 2.2.0 y Python 3.13, escrito para la especificación 2026-07-28, la versión sin estado del protocolo.

Lo bueno de Python: las dos versiones del protocolo por el mismo endpoint

En 2026-07-28 no hay handshake initialize ni sesión: cada petición lleva en _meta la versión y las capacidades del cliente. Un servidor hecho con mcp 2.x atiende las dos formas sin configuración: un cliente actual se queda en 2026-07-28 y uno antiguo hace su initialize y negocia 2025-11-25 o anterior.

El proyecto

uv init --bare --name nortia-almacen --python 3.13
uv add "mcp[cli]==2.2.0"
uv add --dev pytest
uv run mcp version
# MCP version 2.2.0

Fija la versión: desde el 2 de octubre de 2026, sin ella se instala la 2.3.0, con la que no hemos vuelto a ejecutar el ejemplo.

Tools sin escribir esquemas

CodigoAlmacen = Annotated[
    str, Field(pattern=r"^[A-Z]{3}-\d{2}$", description="Código de almacén, por ejemplo MAD-01")
]
SOLO_LECTURA = ToolAnnotations(read_only_hint=True, destructive_hint=False, idempotent_hint=True, open_world_hint=False)


@mcp.tool(title="Consultar existencias", annotations=SOLO_LECTURA)
def consultar_existencias(
    almacen: CodigoAlmacen,
    sku: Annotated[str | None, Field(description="Referencia concreta; si se omite, todas")] = None,
) -> Existencias:
    """Existencias actuales de un almacén: unidades, reservadas, disponibles y estado por referencia."""
    auditoria.info("tool=consultar_existencias inquilino=%s almacen=%s sku=%s", INQUILINO, almacen, sku)
    try:
        lineas = lineas_de(almacen)
    except LookupError as e:
        raise ToolError(str(e)) from e
    if sku is not None:
        lineas = [linea for linea in lineas if linea.sku == sku]
        if not lineas:
            raise ToolError(f"{almacen} no tiene la referencia {sku}. Llama sin sku para ver todas.")
    return Existencias(almacen=almacen, inquilino=INQUILINO, lineas=lineas)


@mcp.tool(title="Alertas de rotura de stock", annotations=SOLO_LECTURA)
def alertas_rotura_stock(almacen: CodigoAlmacen) -> list[Existencia]:
    """Referencias de un almacén con disponibles por debajo del punto de pedido."""
    auditoria.info("tool=alertas_rotura_stock inquilino=%s almacen=%s", INQUILINO, almacen)
    try:
        return [linea for linea in lineas_de(almacen) if linea.estado != "ok"]
    except LookupError as e:
        raise ToolError(str(e)) from e

El SDK lo deduce todo de la firma:

Los parámetros con tipos producen el inputSchema. El patrón y las descripciones salen de los Field: si el modelo envía almacen: "madrid", la función ni se ejecuta.
El docstring es la description de la tool.
El tipo de retorno produce el outputSchema, y el valor viaja en structuredContent.
Las listas y los escalares se envuelven en un objeto con la clave result. Si quieres decidir tú la forma, devuelve un modelo, como consultar_existencias.

Los errores previstos (un almacén que no existe) se convierten en ToolError, con un texto escrito para el modelo que le dice qué valores sí son válidos. Lo imprevisto no se captura: desde la 2.1.0, el SDK no envía al cliente el texto de las excepciones inesperadas.

Servirlo por Streamable HTTP sin estado

from servidor import mcp

if __name__ == "__main__":
    mcp.run(transport="streamable-http", host="127.0.0.1", port=8765,
            stateless_http=True, json_response=True)

Dos opciones que se malinterpretan a menudo:

stateless_http=True solo cambia cómo atiende a los clientes de versiones con handshake: deja de asignarles sesión. El tráfico 2026-07-28 nunca abre sesión, con o sin ella.
json_response=True responde a cada POST con un único JSON en vez de un stream SSE. Va bien para tools rápidas, pero las notificaciones de progreso se pierden.

Tres errores que verás seguro

TypeError por @mcp.tool sin paréntesis. En el SDK oficial son obligatorios: @mcp.tool().
TypeError al pasar port al constructor. Las opciones de transporte van en mcp.run(...), no en MCPServer(...).
El Inspector pasa en verde, pero no has probado 2026-07-28. Sin "protocolEra": "modern" dentro de la entrada del servidor, el Inspector usa las versiones con handshake.

La guía completa, con el servidor entero (datos, modelos, resources y prompt), los tests con pytest en memoria, la prueba con el Inspector y con Claude Code, y cómo pedirle a Claude Code que lo construya, está en DesarrolloMCP: crear un servidor MCP en Python.

Si estás aprendiendo MCP en español, el curso de DesarrolloMCP tiene el nivel Básico gratis (14 lecciones, sin tarjeta), actualizado a la especificación 2026-07-28 y con todo el código probado.

Qué es MCP (Model Context Protocol), explicado en español

Andrés León — Sat, 17 Oct 2026 20:39:10 +0000

MCP (Model Context Protocol) es un protocolo abierto que permite a una aplicación de IA, como Claude o ChatGPT, conectarse con otros programas para consultar sus datos y hacer cosas en ellos. Sin algo así, el asistente solo podría contestar con lo que ya sabe.

Pongamos que le pides a Claude Desktop que mire los PDF de este mes en tu carpeta de Descargas y te diga de qué trata cada uno. Claude no ve tu disco, pero si le has conectado un servidor MCP de archivos, puede hacerlo: pide usar las herramientas que ofrece el servidor (listar carpetas, leer archivos), la aplicación te pide permiso y el servidor hace el trabajo. Con un repositorio de GitHub o con la base de datos de pedidos de tu empresa, el mecanismo es el mismo.

Este artículo es un extracto de nuestra guía en español, que describe la versión vigente de la especificación, la 2026-07-28.

Qué significa «protocolo de contexto del modelo»

Un protocolo es un acuerdo sobre cómo se hablan dos programas: qué mensajes se envían, con qué formato y en qué orden. HTTP permite que cualquier navegador abra cualquier web; MCP cumple un papel parecido entre las aplicaciones de IA y los sistemas que quieren usar.

El contexto es lo que el modelo tiene delante cuando responde: tu pregunta, la conversación y lo que le llega de fuera. MCP fija cómo entra esa última parte. Y que sea abierto significa que cualquiera puede implementarlo, así que el mismo servidor MCP sirve desde Claude, ChatGPT, Cursor o VS Code sin escribir una integración para cada uno.

Cómo funciona, explicado fácil

Intervienen tres piezas: la aplicación que usas (el host: Claude Desktop, ChatGPT, tu editor), el cliente MCP que esa aplicación abre hacia cada servicio y el servidor MCP, el programa que conoce ese servicio por dentro. Cuando tu pregunta necesita datos de fuera:

La aplicación pregunta al servidor qué herramientas ofrece y recibe el nombre y la descripción de cada una.
El modelo lee esas descripciones y propone usar una, con sus argumentos.
La aplicación decide si la llamada se hace; en las operaciones delicadas debería pedirte confirmación.
El servidor ejecuta la acción y devuelve el resultado.
El modelo usa ese resultado para responderte.

El modelo nunca toca el sistema. Solo propone, y es la aplicación la que decide, así que puede poner permisos y confirmaciones en medio.

Qué cambió con la versión 2026-07-28

Los mensajes usan JSON-RPC 2.0. Desde la especificación 2026-07-28 no hay apertura de sesión: cada petición lleva en _meta la versión del protocolo y las capacidades del cliente. Así pregunta un cliente a un servidor qué versiones y capacidades tiene (ejemplo literal de la especificación de server/discover):

{
  "jsonrpc": "2.0",
  "id": "discover-1",
  "method": "server/discover",
  "params": {
    "_meta": {
      "io.modelcontextprotocol/protocolVersion": "2026-07-28",
      "io.modelcontextprotocol/clientInfo": {
        "name": "ExampleClient",
        "version": "1.0.0"
      },
      "io.modelcontextprotocol/clientCapabilities": {}
    }
  }
}

Si vienes de tutoriales de 2025, ese es el cambio que más código rompe: ya no hay initialize ni Mcp-Session-Id.

Para qué sirve, con ejemplos reales

GitHub mantiene su propio servidor, github-mcp-server, con acceso a repositorios, issues, pull requests y Actions: el asistente puede resumirte las issues abiertas o revisar un pull request.
Notion, Atlassian, Linear, Stripe, Supabase, Sentry y Cloudflare publican servidores oficiales. Si buscas uno, comprueba antes si lo publica el fabricante: al buscar salen muchos de terceros con nombres casi iguales.
En una empresa, un equipo publica una vez un servidor (por ejemplo, uno de pedidos con una herramienta buscar_pedido) y cualquier aplicación que hable MCP puede descubrirla y llamarla, sin conocer la base de datos.

La guía completa, con el diagrama del flujo, los dos transportes (stdio y Streamable HTTP), las tools, resources y prompts, cómo empezar sin programar, MCP frente a una API REST y lo básico de seguridad, está en DesarrolloMCP: qué es MCP.

Si quieres pasar de saber qué es MCP a construir servidores, el curso de DesarrolloMCP tiene el nivel Básico gratis (14 lecciones, sin tarjeta), en español y actualizado a la especificación 2026-07-28.

Crear un servidor MCP en TypeScript con el SDK v2 (y que hable 2026-07-28)

Andrés León — Sat, 17 Oct 2026 20:39:09 +0000

Si buscas «MCP TypeScript» vas a encontrar sobre todo código de 2025. Ese código usa el paquete único @modelcontextprotocol/sdk, que es la v1 del SDK, y sus métodos server.tool(), server.resource() y server.prompt() no existen en la v2. Para un servidor nuevo, el que habla la especificación MCP 2026-07-28, necesitas el SDK oficial v2, que se reparte en paquetes separados.

Este artículo es un extracto de una guía más larga. Montamos nortia-pedidos, un servidor que consulta pedidos de Nortia Logística (la empresa ficticia del curso de DesarrolloMCP), y lo servimos por stdio y por Streamable HTTP sin estado. Todo el código se ejecutó con @modelcontextprotocol/server 2.3.0, zod 4.6.5 y Node 24.12.

Lo que no te cuentan: instalar la v2 no basta

La guía oficial del SDK lo dice así: «Nothing in v2 puts a 2026-07-28 byte on the wire by default». La versión del protocolo la decide el punto de entrada con el que sirves el servidor, no el paquete que instalas. Por eso el servidor se construye dentro de una función, una fábrica que devuelve un McpServer: los puntos de entrada que hablan 2026-07-28 reciben la fábrica, no una instancia, y en HTTP la ejecutan en cada petición.

El proyecto

mkdir nortia-pedidos && cd nortia-pedidos
npm init -y && npm pkg set type=module
npm i @modelcontextprotocol/server @modelcontextprotocol/client \
      @modelcontextprotocol/node @modelcontextprotocol/express express zod
npm i -D typescript tsx @types/node @types/express

La fábrica crearServidor() registra una tool (buscar_pedido, con entrada y salida validadas con Zod 4), un resource fijo, otro con plantilla (pedidos://pedido/{pedidoId}) y un prompt. En la guía completa está entera y explicada decisión a decisión: por qué un pedido inexistente es un resultado con isError: true y no una excepción, y por qué hace falta filtrar los campos de salida aunque declares un outputSchema.

Servirlo por stdio

import { serveStdio } from '@modelcontextprotocol/server/stdio';
import { dependencias } from './entorno.js';
import { crearServidor } from './servidor.js';

const deps = dependencias('stdio'); // falla al arrancar si la configuración es inválida
const handle = serveStdio(() => crearServidor(deps));
console.error(`nortia-pedidos (${deps.inquilino}) escuchando por stdio`);

process.on('SIGINT', () => void handle.close());

serveStdio(fábrica) es lo que hace que el servidor hable 2026-07-28, y por defecto también atiende a clientes de las versiones con handshake. Fíjate en que todo se escribe con console.error: en stdio, la especificación prohíbe escribir en stdout nada que no sea un mensaje MCP válido.

Servirlo por Streamable HTTP, sin estado

import { createMcpExpressApp } from '@modelcontextprotocol/express';
import { toNodeHandler } from '@modelcontextprotocol/node';
import { createMcpHandler } from '@modelcontextprotocol/server';
import { dependencias } from './entorno.js';
import { crearServidor } from './servidor.js';

const deps = dependencias('http');
// La fábrica se ejecuta una vez por petición HTTP: no hay nada que recordar entre dos POST.
const handler = createMcpHandler(() => crearServidor(deps));

const app = createMcpExpressApp(); // express.json() y validación de Host y Origin
const node = toNodeHandler(handler);
app.all('/mcp', (req, res) => void node(req, res, req.body));

const PORT = Number(process.env.PORT ?? 3000);
const httpServer = app.listen(PORT, '127.0.0.1', () => {
    console.error(`nortia-pedidos (${deps.inquilino}) en http://127.0.0.1:${PORT}/mcp`);
});

process.on('SIGTERM', async () => {
    await handler.close();
    httpServer.close();
});

createMcpHandler devuelve un handler web estándar y toNodeHandler lo adapta a Express. No hay sesiones ni cabecera Mcp-Session-Id: cada POST se resuelve con lo que trae. Como la fábrica se ejecuta en cada petición, lo caro (pools de base de datos, cachés, clientes de otras APIs) tiene que vivir fuera, a nivel de módulo.

Probarlo sin engañarte

El MCP Inspector usa por defecto las versiones con handshake. Si no le pides --protocol-era modern (o el campo "protocolEra": "modern" dentro de la entrada del servidor en su archivo de configuración), la prueba pasa en verde sin haber probado 2026-07-28. La señal de que sí se negoció la versión actual es io.modelcontextprotocol/serverInfo dentro de _meta en la respuesta.

La guía completa, con el resto del código (los datos detrás de una interfaz, la tool, los resources y el prompt), la petición curl con su _meta, la prueba con el Inspector y cómo pedirle a Claude Code que lo construya fijando el SDK v2, está en DesarrolloMCP: crear un servidor MCP en TypeScript.

Si estás aprendiendo MCP en español, el curso de DesarrolloMCP tiene el nivel Básico gratis (14 lecciones, sin tarjeta), actualizado a la especificación 2026-07-28 y con todo el código probado.

Analizamos por dentro un servidor MCP local: mcp-supermercados-cl

Andrés León — Fri, 16 Oct 2026 17:41:33 +0000

mcp-supermercados-cl es un servidor MCP local que da a tu asistente herramientas para armar listas de compra en cinco supermercados de Chile (Jumbo, Santa Isabel, Unimarc, Tottus y Líder). Lo publica NLACE-COM con licencia MIT; tu cliente MCP lo arranca en tu máquina y le habla por stdio.

Lo hemos leído por dentro (commit 3441cca, paquete 1.4.7), lo hemos compilado y ejecutado en local sin cuentas ni claves, y le hemos conectado un cliente MCP mínimo. Esto es lo que más nos ha gustado y lo que mejoraríamos.

Lo que hace bien

Tools orientadas al resultado, no a la API. build_list recibe hasta 30 ítems en texto libre y un presupuesto, y devuelve una lista decidida: producto elegido por precio por unidad y ofertas, hasta tres alternativas y el total. Envolver el endpoint de búsqueda de cada cadena habría obligado al modelo a hacer ese trabajo llamada a llamada. Las tools de lectura (search_products, get_offers…) van aparte.

El carro nunca toca tu cuenta. add_to_cart no hace la petición a la tienda: devuelve la petición exacta y un browserSnippet para ejecutar en tu pestaña ya logueada, con executed: false. Tus credenciales se quedan en el navegador y las instrucciones del servidor prohíben al modelo pedirte usuario o clave.

Un adaptador por cadena, sin fingir cobertura. Un registro de cinco adaptadores (Jumbo y Santa Isabel comparten el de Cencosud) y una tabla en el README que dice qué cadena tiene búsqueda, precio de socio o carro. Solo Jumbo marca el ciclo completo, y lo dice.

Errores con siguiente paso. Cada error lleva categoría, mensaje y un campo action (reiniciar sesión, reintentar…) y se devuelve con isError, así el modelo lo ve como resultado y puede actuar.

stdio bien hecho. Nada que no sea JSON-RPC en stdout; los avisos van a stderr, como pide la especificación.

Por qué es local (y cuándo deja de bastar)

El autor lo explica en el README: el precio de socio, tus compras frecuentes y el carro viven en tu navegador con sesión, y algunas cadenas bloquean el tráfico desde centros de datos. Para un servicio remoto compartido harían falta Streamable HTTP, autorización y aislamiento por usuario.

Lo que probamos (y lo que no)

npm ci --ignore-scripts y npm run build: sin errores.
npm test: 178 de 180 tests pasan. Los 2 que fallan dependen de la fecha: sus datos de ofertas caducan en agosto de 2026 y el selector compara con Date.now(). No indican un fallo con la web real.
Un cliente MCP mínimo recibió las 14 tools y los 5 prompts; get_cart sin sesión devolvió las instrucciones sin consultar ningún carro.
No probamos tiendas, compras ni sesiones.

Lo que mejoraríamos

Pasar un reloj fijo a esos dos tests para que no dependan del día.
Documentar que executed: true solo indica que la tool normalizó el JSON recibido, no que el carro haya cambiado.
Documentar con qué versiones del protocolo se ha probado (usa el SDK v1, hasta 2025-11-25) y planificar la migración a MCP 2026-07-28.

El análisis completo, con el código citado línea a línea, los diagramas de la arquitectura y las salidas de nuestras pruebas, está en DesarrolloMCP: Servidor MCP local, analizamos mcp-supermercados-cl.

Si estás aprendiendo MCP en español, el curso de DesarrolloMCP empieza gratis, actualizado a la especificación 2026-07-28.