Guía de campo · octubre de 2026

Guía de campo de MCP

Conectar los modelos con el mundo, un servidor cada vez
por Mat Siems
Parte I

El problema N por M

Por qué existe un protocolo, y por qué ahora.

Capítulo 1 · Parte I

Un enchufe para cada toma

Bienvenido. Esta es una guía de campo del Model Context Protocol, que casi todo el mundo abrevia como MCP, tal como está en octubre de 2026. Tiene cien capítulos breves, y cada uno pretende enseñarte algo que puedas usar esta misma semana, tanto si construyes servidores como si gestionas los hosts que se conectan a ellos o si alguien con más galones te ha pedido que «tengas una opinión sobre MCP» para el viernes.

Empecemos por la descripción sin adornos. MCP es un protocolo abierto que permite a una aplicación de IA conectarse a herramientas y datos externos a través de una única interfaz estándar. A un lado está algo que habla con un modelo: una aplicación de chat, un agente de programación, un IDE. Al otro, algo que sabe hacer un trabajo: buscar en un gestor de incidencias, consultar una base de datos, leer una carpeta, enviar un mensaje. MCP es la forma pactada de la conversación entre ambos. La aplicación pregunta qué hay disponible, el otro lado lo describe y, a partir de ahí, el modelo puede pedir que se haga un trabajo y recibir los resultados.

La comparación a la que todo el mundo recurre es el USB-C y, por una vez, el tópico se gana el sueldo. Antes de un puerto común, cada aparato traía su propio cable y todos los cajones se llenaban de los que no servían. Después, el fabricante construye una sola toma y confía en que lo que llegue encajará. MCP hace lo mismo con el espacio que hay entre los modelos y el mundo. Construye un servidor una vez y cualquier host que hable el protocolo podrá enchufarlo. Construye un host una vez y podrá usar cualquier servidor.

Un protocolo es aburrido a propósito. Así es como llega a estar en todas partes.

¿Qué significa esto en la práctica? Significa que, cuando quieres que tu asistente lea la wiki de la empresa, ya no esperas a que el proveedor del asistente escriba una integración con la wiki, ni la escribes tú en un formato de plugin propietario que quedará obsoleto antes de la primavera. Buscas, o construyes, un servidor MCP para la wiki y lo conectas. Ese mismo servidor funciona luego en tu agente de programación, en tu aplicación de chat de escritorio y en la herramienta interna que está construyendo tu equipo de plataforma, porque todos hablan el mismo idioma.

También supone un pequeño cambio en tu manera de pensar en el modelo. Un modelo por sí solo sabe aquello con lo que se entrenó y lo que tú le pegues. Un modelo con servidores MCP conectados puede consultar cosas, actuar y traer contexto fresco cuando lo necesita, dentro de los límites que tú fijes. Esa última frase ocupará buena parte de un tercio de este libro, porque un enchufe que encaja en todo también encaja en cosas que no tenías previstas.

El resto de la Parte 1 explica por qué existe el protocolo, de dónde viene y qué no es. Si tienes prisa, salta al décimo capítulo y conecta algo. Volverás. Todo el mundo vuelve, normalmente justo después de la primera llamada a una herramienta que le sorprende.

Un enchufe, cualquier toma HOSTS · hablan con un modelo SERVIDORES · un oficio App de chat escritorio · web Agente de código terminal IDE editor MCP una interfaz estándar 1 ¿qué hay disponible? 2 el servidor describe 3 pide el trabajo 4 vuelven resultados Gestor de tickets buscar Base datos consulta Carpeta leer Mensajes enviar Construye un servidor una vez: cualquier host que hable MCP podrá usarlo. Construye un host una vez: podrá usar todos los servidores.
Fig. 1 · Un enchufe para cada toma. Hosts y servidores se encuentran en una interfaz estándar: preguntar, describir, pedir, devolver.
Capítulo 2 · Parte I

Multiplicar es el enemigo

Todo problema de integración es, en secreto, un problema de multiplicación, y la multiplicación es el enemigo. Supón que hay cinco aplicaciones de IA que le importan a tu organización y veinte sistemas a los que quieres que lleguen. Si cada aplicación se integra con cada sistema según sus propias reglas, necesitas cien integraciones. Cada una la escribirá una persona distinta, con un estilo distinto y una idea distinta de lo que es un error. Cada una se romperá según su propio calendario.

Este es el problema N por M, y es más antiguo que los modelos de lenguaje. Es la razón por la que existen los controladores SQL, los controladores de impresora, HTTP y el humilde enchufe de la pared. En todos los casos la solución fue la misma: acordar una forma en el medio. Así cada aplicación implementa esa forma una vez, cada sistema la implementa una vez, y las cien integraciones se reducen a veinticinco trabajos. N más M, no N por M. La aritmética resulta más convincente a medida que crecen los números, y en las herramientas de IA los números crecieron muy deprisa.

Antes de MCP, cada proveedor de modelos y cada framework de agentes tenía su propia manera de describir una herramienta. Todas se parecían, porque todas eran JSON Schema con un nombre y una descripción, pero parecerse no es ser lo mismo. Una herramienta escrita para un framework había que volver a envolverla para el siguiente. Una empresa que quería que su producto fuera accesible desde asistentes de IA tenía que elegir favoritos, o publicar cinco plugins ligeramente distintos y mantenerlos todos. La mayoría eligió uno y cruzó los dedos.

El coste de integración crece con el producto de tus elecciones. Los estándares hacen que crezca con la suma.

MCP baja el acuerdo un nivel. No le importa qué modelo hay detrás del host ni en qué lenguaje está escrito el servidor. Le importa que ambos lados intercambien los mismos mensajes: enumera tus herramientas, llama a esta, aquí tienes el resultado. Una vez fijado eso, quienes conocen el gestor de incidencias construyen su servidor, y quienes construyen hosts se concentran en alojar. Cada parte hace el trabajo para el que está mejor situada, y lo hace una sola vez.

Hay un coste, y conviene nombrarlo. Una forma compartida es un compromiso. Algunos sistemas tienen capacidades que el protocolo no expresa con limpieza, y algunos hosts querrían funciones que el protocolo aún no ofrece. Te toparás con ambas frustraciones. El trato sigue siendo bueno, por la misma razón por la que nadie diseña un enchufe a medida para su hervidor: el valor de encajar en todas partes es mayor que el de encajar a la perfección en un solo sitio.

Así que, cuando alguien te pregunte por qué tu equipo debería usar MCP en lugar de escribir una integración directa, haz la cuenta en voz alta. Cuenta los hosts que querrás soportar dentro de dos años, cuenta los sistemas y multiplica. Luego vuelve a contar y suma. La distancia entre esos dos números es todo el caso de negocio, y rara vez necesita una diapositiva.

Multiplicar es el enemigo Punto a punto apps sistemas Una forma en medio apps sistemas MCP cada par se hace y se rompe aparte cada lado implementa la forma una vez N × M = 5 × 20 = 100 integraciones que escribir y mantener N + M = 5 + 20 = 25 piezas de trabajo, cada una una vez El coste crece con el producto de tus opciones; un estándar lo convierte en la suma.
Fig. 2 · Multiplicar es el enemigo. Cinco apps y veinte sistemas: cien enlaces punto a punto frente a veinticinco vía MCP.
Capítulo 3 · Parte I

La vida antes del protocolo

Ayuda recordar lo que hacíamos antes, aunque solo sea para que nadie proponga con nostalgia volver a hacerlo. Los modelos de lenguaje aprendieron a llamar funciones bastante antes de que existiera MCP. Describías una función con un nombre, una frase de explicación y un JSON Schema para sus argumentos; el modelo respondía, no con prosa, sino con una petición estructurada para llamarla; tu código ejecutaba la función y le devolvía la respuesta. Funcionaba. Sigue funcionando. Es, de hecho, exactamente lo que ocurre por debajo de MCP.

El problema era todo lo que había alrededor. La API de cada proveedor tenía su propio sobre para las definiciones y los resultados de las herramientas. Cada framework de agentes volvía a envolver esos sobres en sus propias abstracciones, con sus propios decoradores y clases base. Un equipo que quería que su asistente buscara en su documentación escribía una función de búsqueda, la conectaba a un framework y descubría seis meses después que media empresa usaba otro asistente que no podía verla. La función estaba bien. El problema era el pegamento, y el pegamento era artesanal cada vez.

Luego llegaron los ecosistemas de plugins. Varios productos ofrecían a terceros una forma de ampliarlos, cada uno con su formato de manifiesto, su proceso de revisión y su ciclo de vida. Un plugin construido para un producto no servía para otro. Algunos de esos ecosistemas se retiraron y se llevaron sus plugins por delante. Si construiste sobre uno, aprendiste la lección que todas las plataformas acaban enseñando: eras inquilino, no propietario.

El código pegamento es la materia oscura del software. Lo sostiene todo y nadie sabe cuánto hay.

Había además un coste más sutil. Como cada integración vivía dentro de una aplicación concreta, sabía demasiado de esa aplicación. Daba por supuesto cierto modelo, cierto estilo de prompt, cierta manera de pedir permiso al usuario. Moverla obligaba a desenredar esos supuestos. Probarla obligaba a ejecutar la aplicación entera. Reutilizarla significaba copiarla, y copiarla significaba dos versiones que se iban separando.

La respuesta de MCP es la separación. El servidor sabe del sistema que envuelve y nada del modelo. El host sabe del modelo y del usuario y nada de las entrañas del sistema. El protocolo es la rendija estrecha y bien especificada entre ambos. Esa rendija es donde la reutilización se vuelve posible, y donde se vuelve posible probar sin un modelo de por medio.

Nada de esto fue una falta de imaginación de quienes vinieron antes. La llamada a funciones era la primitiva correcta. Los plugins fueron un experimento razonable. Simplemente les faltaba un punto medio neutral que nadie poseyera y todo el mundo pudiera implementar. Si hoy mantienes un montón de integraciones anteriores a MCP, no hace falta que las reescribas en un fin de semana. Envuelve como servidor la que más se reutiliza, conéctala a dos hosts y comprueba si el cajón del pegamento pesa menos. Suele pesar menos, y ya nunca vuelve a pesar más.

Tres vías a una herramienta Function calling Plugins Servidor MCP Definición sobre del proveedor manifiesto un esquema compartido Reúso reenvolver cada vez inútil en otro sitio todo host MCP De quién es la aplicación la plataforma nadie; todos Conoce modelo, prompt, app un producto solo su sistema Probarlo solo lanzar toda la app lanzar el producto llamarlo directo Function calling era la primitiva correcta; el pegamento alrededor era artesanal. MCP añade el punto medio neutral que nadie posee y todos implementan.
Fig. 3 · La vida antes del protocolo. Function calling, plugins y servidores MCP comparados en formato, reutilización, dueño y pruebas.
Capítulo 4 · Parte I

Breve historia de un estándar joven

La historia es breve porque no ha tenido mucho calendario. Anthropic publicó el Model Context Protocol como especificación abierta en noviembre de 2024, con SDK y un puñado de servidores de referencia para cosas como sistemas de archivos, Git y bases de datos. En su lanzamiento era la propuesta de una sola empresa, implementada en la aplicación de escritorio de esa empresa, con la promesa de que cualquiera podría construir sobre ella. Promesas así abundan. La mayoría no las recoge nadie.

Esta sí. A lo largo de 2025 el protocolo lo adoptó una variedad notable de hosts: los asistentes y kits de agentes de otros proveedores de modelos, los principales IDE y agentes de programación, y una larga cola de herramientas más pequeñas. Las empresas empezaron a publicar servidores oficiales para sus productos, y el número de servidores de la comunidad creció más deprisa de lo que nadie podía contar con provecho. A finales de ese año, «¿soporta MCP?» se había convertido en una pregunta rutinaria en cualquier evaluación de herramientas, formulada en el mismo tono que «¿tiene API?».

La especificación avanzó rápido. Las revisiones se identifican por fecha y no por número de versión, y cada una añadía o ajustaba algo: un transporte HTTP con streaming para sustituir a otro anterior más torpe; un marco de autorización basado en OAuth; salida estructurada de las herramientas; formas de que un servidor haga una pregunta al usuario; maquinaria para trabajos de larga duración. Algunas funciones tempranas se eliminaron cuando resultaron dar más problemas de los que resolvían. Es buena señal. Los estándares que nunca restan nada acaban siendo museos.

Un estándar se vuelve real el día en que su autor deja de ser su único implementador.

En diciembre de 2025 Anthropic cedió MCP a una fundación abierta recién creada bajo la Linux Foundation, junto con aportaciones de otras empresas. El efecto práctico es que el protocolo se gobierna ahora a la vista de todos, con propuestas, grupos de trabajo y mantenedores procedentes de varias organizaciones, en lugar de ser la hoja de ruta de un solo proveedor. Para quien compra, eso responde a la pregunta que siempre se hace sobre un estándar joven: ¿qué pasa si la empresa que hay detrás cambia de idea?

¿Qué conviene sacar de la historia? Sobre todo, una idea del tempo. Los detalles han cambiado cada pocos meses y seguirán haciéndolo. Los campos se renombran, se añaden capacidades, los mecanismos obsoletos sobreviven un tiempo en servidores antiguos. Por eso este libro se apoya en principios y, cuando nombra un mecanismo concreto, te cuenta por qué existe, para que reconozcas a su sucesor.

Hay también una lección en por qué se extendió. MCP no era el diseño más ingenioso posible. Era lo bastante sencillo para implementarlo en una tarde, lo bastante abierto para que nadie tuviera que pedir permiso y útil desde el primer día. Esas tres propiedades le ganan al ingenio casi siempre. Si alguna vez te ves diseñando un estándar interno, recuerda el orden: útil, luego abierto, luego sencillo y, solo si sobra tiempo, ingenioso.

Un estándar joven, adoptado rápido Spec abierta SDKs + servidores ref. nov 2024 Hosts lo adoptan asistentes · IDEs 2025 Revisiones de spec revisiones fechadas 2025–26 Linux Foundation gobernanza abierta dic 2025 Pregunta por defecto ¿se pide como API? oct 2026 añadido: HTTP con streaming · OAuth · salida estructurada · elicitación · tareas Por qué se extendió: útil, luego abierto, luego simple. Lo ingenioso vino al final.
Fig. 4 · Breve historia de un estándar joven. De la spec abierta en noviembre de 2024 a la gobernanza de la Linux Foundation en diciembre de 2025.
Capítulo 5 · Parte I

El modelo solo habla

El dato más útil sobre MCP es también el que más se malinterpreta. El modelo nunca llama a una herramienta. El modelo solo habla. Cuando la gente dice «el modelo buscó en la base de datos», lo que ocurrió en realidad es que el modelo produjo un texto que decía, de forma estructurada, me gustaría que se llamara a la herramienta de búsqueda con estos argumentos, y un software corriente decidió si hacerlo o no.

Ese software es el host: la aplicación de chat, el agente de programación, el IDE. El host le ha dado al modelo una lista de herramientas que puede pedir, cada una con un nombre, una descripción y un esquema. Cuando la respuesta del modelo contiene una petición de herramienta, el host la lee, comprueba sus propias reglas, quizá te pide permiso y luego envía la petición por MCP al servidor que ofrece esa herramienta. El servidor hace el trabajo y devuelve un resultado. El host vuelve a colocar el resultado en la conversación y el modelo, al leerlo, decide qué decir o qué pedir a continuación.

¿Por qué importa? Porque todas las propiedades de seguridad, todos los permisos y todos los registros de auditoría viven en el host y en el servidor, no en el modelo. Un modelo no puede ir más allá de sus herramientas, porque no puede hacer nada salvo producir texto. Si un servidor expone una herramienta que borra registros, el modelo puede pedir que se borren registros; que eso ocurra depende de las reglas de aprobación del host y de las comprobaciones del propio servidor. Si ninguno comprueba nada, el criterio del modelo es el único guardián, y ese criterio puede verse influido por cualquier cosa que haya en su contexto.

El modelo propone. El host dispone. El servidor hace el trabajo y guarda los recibos.

Esto explica también por qué los servidores MCP no necesitan saber a qué modelo sirven. Reciben una petición bien formada y devuelven un resultado bien formado. Que esa petición venga de un modelo de frontera, de uno pequeño ejecutado en local o de un banco de pruebas en el que alguien teclea JSON a mano les resulta invisible, y así debe ser. Parte de la mejor depuración que harás nunca consiste en llamar a un servidor directamente, sin un modelo a la vista, para ver si el problema está por encima o por debajo del protocolo.

Explica, además, por qué las descripciones de las herramientas importan tanto. El modelo elige qué pedir basándose únicamente en lo que se le ha contado. Una herramienta llamada query descrita como «ejecuta una consulta» se pedirá en momentos extraños con argumentos extraños. Una herramienta llamada search_open_tickets descrita como «busca incidencias de soporte abiertas que coincidan con una frase; devuelve como máximo veinte» se pedirá cuando toca. El modelo no puede leer tu código fuente. Lee tus adjetivos.

Ten la secuencia en la cabeza: el modelo pide, el host decide, el servidor actúa, el resultado vuelve. Cuando algo sale mal, pregúntate cuál de los cuatro pasos falló. Casi toda la confusión sobre los agentes viene de imaginar un quinto paso en el que el modelo alargó la mano e hizo algo por su cuenta. No lo hizo. Algo que tú configuraste se lo permitió.

El modelo solo habla Usuario Modelo Host Servidor hace una pregunta pregunta + herram. texto: call search_tickets(q) revisa sus reglas ¿pedir permiso? tools/call hace el trabajo resultado resultado puesto en contexto respuesta El modelo propone. El host dispone. El servidor hace el trabajo.
Fig. 5 · El modelo solo habla. El modelo emite texto; el host comprueba reglas, llama al servidor y devuelve el resultado.
Capítulo 6 · Parte I

El contexto es el producto

El nombre te dice el oficio si lo lees despacio. Model Context Protocol: protocolo de contexto para modelos. No es un protocolo de herramientas, aunque las herramientas sean su rasgo más famoso, ni un protocolo de agentes, aunque los agentes lo usen a fondo. Es un protocolo para hacer llegar contexto a un modelo: los datos adecuados, los archivos adecuados, las capacidades adecuadas, en el momento en que el modelo los necesita.

La utilidad de un modelo está acotada por lo que hay en su ventana de contexto. Solo puede razonar sobre lo que ve. Antes de protocolos como MCP, las formas principales de meter contexto eran pegarlo a mano, embutir en el prompt las mejores apuestas de un sistema de recuperación o hacer fine-tuning. Las tres tienen su sitio. Las tres comparten una debilidad: alguien tenía que decidir de antemano qué iba a necesitar el modelo. MCP permite que el modelo, o la aplicación que lo rodea, vaya a buscar contexto bajo demanda. Pregunta por los incidentes de la semana pasada y el asistente puede ir a mirar, en lugar de depender de lo que alguien hubiera pegado por casualidad.

Este enfoque explica las tres primitivas del lado del servidor mejor que cualquier diagrama. Las herramientas permiten al modelo traer o cambiar cosas cuando él lo decide. Los recursos permiten a la aplicación adjuntar datos, como un archivo o un registro, directamente a la conversación. Los prompts permiten al usuario traer una receta preparada. Las tres son maneras de llevar el material adecuado al campo de visión del modelo. Las tres cuestan espacio en una ventana finita.

El contexto no es gratis. Cada token que le das al modelo es un token que tiene que leer para encontrar el que importa.

Ese coste es la restricción silenciosa que hay detrás de buena parte del buen diseño en MCP. Un servidor que devuelve diez mil filas no ha sido generoso; ha sido maleducado. Un host que carga las definiciones completas de doscientas herramientas antes del primer mensaje se ha gastado una buena parte del presupuesto en menús. Los buenos servidores devuelven menos y señalan dónde hay más. Los buenos hosts cargan las definiciones de herramientas de forma perezosa y dejan que el modelo busque lo que necesita. Volverás a ver ambas ideas en partes posteriores.

De aquí se deriva un hábito práctico. Cuando evalúes un servidor, no te preguntes solo si sabe hacer el trabajo. Pregúntate cuánto contexto gasta en hacerlo. Llama a una herramienta a mano y mira el tamaño de lo que vuelve. Cuenta las herramientas que anuncia y lee sus descripciones como si fueras un modelo con una mesa pequeña y una fecha de entrega. Un servidor que responde en doscientas palabras cuando su rival responde en dos mil no es menos capaz. Es más considerado, y los servidores considerados producen mejores respuestas, porque al modelo le queda sitio para pensar.

El protocolo transporta contexto. Tu trabajo es asegurarte de que transporta la cantidad justa. Un embudo, no una manguera de incendios.

El contexto es el producto Herram. el modelo busca, actúa Recursos la app adjunta datos Prompts el usuario trae receta Contexto a demanda traído cuando hace falta Ventana de contexto finita cada token hay que leerlo La cantidad justa espacio para pensar Mejor respuesta Manguera 10.000 filas de vuelta Embudo menos datos, más enlaces 200 defs de herram. al inicio cargar a demanda Cada token que le das al modelo es uno que tiene que leer.
Fig. 6 · El contexto es el producto. Herramientas, recursos y prompts confluyen en una ventana finita: devuelve menos, enlaza más.
Capítulo 7 · Parte I

Ideas prestadas, deudas reconocidas

Los buenos estándares son en su mayoría prestados, y MCP es honesto con sus deudas. La más clara es con el Language Server Protocol, que resolvió un problema asombrosamente parecido para los editores de código una década antes. Antes de LSP, cada editor necesitaba su propio plugin para cada lenguaje si quería autocompletado, ir a la definición y subrayados de error. Después, el equipo de un lenguaje escribía un único servidor de lenguaje y todos los editores que hablaban el protocolo obtenían esas funciones. N por M se convirtió en N más M. ¿Te suena?

Los diseñadores de MCP tomaron algo más que la aritmética. Tomaron la forma. En LSP un cliente, el editor, lanza un servidor, a menudo como subproceso que habla por la entrada y la salida estándar, y ambos intercambian mensajes JSON-RPC. Empiezan con un saludo de inicialización en el que cada lado declara sus capacidades, para que ninguno tenga que adivinar qué admite el otro. Siguen con peticiones, respuestas y notificaciones que fluyen en ambas direcciones. Si alguna vez has depurado un servidor de lenguaje, ya entiendes de MCP más de lo que crees.

La segunda deuda es con JSON-RPC 2.0, una especificación pequeña, antigua y deliberadamente sosa para llamadas a procedimientos remotos codificadas en JSON. Un mensaje es una petición con un nombre de método, unos parámetros y un id; o una respuesta que lleva un resultado o un error para ese id; o una notificación, que es una petición que no espera respuesta. Eso es casi todo. MCP añade sus propios métodos encima, como enumerar herramientas o leer recursos, pero el sobre es JSON-RPC sin tocar. Hay bibliotecas para él en todos los lenguajes, y esa es una de las razones por las que aparecieron servidores MCP en tantos lenguajes tan deprisa.

Nadie se lleva el mérito por inventar el sobre. Todo el mundo se beneficia de no reinventarlo.

Otras deudas son menos directas. OAuth aporta la historia de la autorización para servidores remotos, entera y no solo en espíritu. JSON Schema describe las entradas y salidas de las herramientas. Las URI dan nombre a los recursos. Los server-sent events transportan flujos sobre HTTP. Nada de esto se inventó para MCP, y ahí está precisamente su valor: cada pieza llega con herramientas, documentación y una generación de ingenieros que ya conoce sus aristas.

¿Por qué debería importarle el linaje a quien está en el tajo? Porque las ideas prestadas vienen con respuestas prestadas. Cuando te preguntes cómo gestionar una petición cancelada, los mundos de LSP y JSON-RPC tienen opinión. Cuando te preguntes cómo validar un token, el mundo de OAuth tiene una década de lecciones duras, muchas escritas en forma de avisos de seguridad. Leer un buen artículo sobre el diseño de servidores de lenguaje te hará mejor autor de servidores MCP que leer diez entradas entusiastas sobre agentes.

El solapamiento es el protocolo, y el protocolo es casi todo solapamiento. No es una crítica. El mejor cumplido que se le puede hacer a un estándar es que sus piezas ya inspiraban confianza antes de que nadie las ensamblara.

Ideas prestadas, deudas reconocidas CAPA TOMADO DE Métodos MCP tools/list · resources/read lo propio de MCP Saludo + capacidades initialize · declarar funciones LSP Sobre del mensaje petición · respuesta · notificación JSON-RPC 2.0 Transportes subproceso stdio · streams HTTP LSP + SSE TRANSVERSAL JSON Schema entradas + salidas URIs nombres de recursos OAuth autorización remota El protocolo es casi todo solapamiento; sus piezas ganaron confianza antes.
Fig. 7 · Ideas prestadas, deudas reconocidas. Las capas de MCP y lo que cada una toma de LSP, JSON-RPC, SSE, JSON Schema, URIs y OAuth.
Capítulo 8 · Parte I

Lo que MCP no es

Toda tecnología de éxito atrae afirmaciones que nunca hizo. MCP ha reunido su cuota, así que merece la pena dedicar un capítulo a lo que no es. Ahorra reuniones.

No es un framework de agentes. MCP no decide cuándo llamar a una herramienta, cómo planificar una tarea de varios pasos, cómo reintentar ni cuándo parar. Esas decisiones corresponden al host y al modelo que lleva dentro. Un framework puede usar MCP para llegar a las herramientas, y muchos lo hacen, pero el protocolo no tiene opinión sobre bucles, memoria o razonamiento. Si estás eligiendo entre MCP y un framework de agentes, has entendido mal uno de los dos.

No sustituye a tu API. Un servidor MCP suele colocarse delante de una API existente y traducirla a una forma que un modelo pueda usar bien. La API sigue existiendo, sigue sirviendo a tu aplicación web y a tus socios y sigue llevando la lógica de negocio de verdad. Un servidor que duplica esa lógica en lugar de llamarla acabará divergiendo. Piensa en el servidor como en una recepcionista bien informada, no como en un segundo edificio.

No es un modelo de seguridad. MCP especifica cómo debe funcionar la autorización en los servidores remotos y da a los hosts la información que necesitan para pedir consentimiento. No puede volver honrado a un servidor malicioso, cuidadoso a un servidor descuidado ni inmune a un modelo frente a instrucciones escondidas en los datos. La seguridad es algo que construyes con MCP, a base de hosts, servidores, tokens y políticas. No es algo que MCP te regale por estar instalado.

Un protocolo te dice cómo hablar. No puede decirte de quién fiarte.

No es una función del modelo. Los modelos se entrenan para usar herramientas, pero MCP vive enteramente fuera del modelo, en el software que lo rodea. Por eso el mismo servidor funciona con modelos distintos, y por eso un host puede soportar MCP con un modelo que jamás ha oído hablar de él.

No es un mercado, aunque existen registros; ni una plataforma de alojamiento, aunque muchas empresas te alojarán servidores; ni una garantía de calidad, aunque a veces la gente trata la existencia de un servidor como prueba de que funciona. Un servidor es código que alguien escribió. Parte es excelente. Parte se escribió en una tarde y nadie volvió a tocarlo.

Entonces, ¿qué es? Un protocolo: un acuerdo preciso sobre mensajes, su orden y su significado, entre un cliente que actúa en nombre de un host y un servidor que ofrece capacidades. Es una afirmación más modesta que el bombo, y mucho más duradera. Cuando alguien en una reunión proponga MCP como respuesta a un problema, haz primero una sola pregunta: ¿se trata de que dos programas se pongan de acuerdo sobre cómo hablar? Si la respuesta es sí, MCP puede ayudar mucho. Si es no, es la herramienta equivocada, por muy de moda que esté la sigla.

Lo que MCP no es MCP NO ES… …PORQUE Un framework de agentes planificar es cosa de host + modelo Un sustituto de tu API se sitúa delante de la API Un modelo de seguridad la seguridad se construye con él Función del modelo vive fuera del modelo Un mercado o un host registros + hosting van aparte Una garantía de calidad un servidor es código de alguien Es un protocolo: mensajes, su orden y su significado entre un cliente que actúa por un host y un servidor que ofrece capacidades
Fig. 8 · Lo que MCP no es. Seis cosas que MCP no es, y por qué; lo que es: un protocolo entre cliente y servidor.
Capítulo 9 · Parte I

La forma de un ecosistema

Un protocolo por sí solo es un documento. Un ecosistema es lo que ocurre cuando lo implementa tanta gente que implementarlo se convierte en lo normal. MCP cruzó esa línea deprisa, y conviene conocer a sus principales habitantes antes de salir a buscar nada.

Los servidores son los más numerosos. Algunos son oficiales, construidos y mantenidos por la empresa cuyo producto envuelven: el servidor propio de un gestor de incidencias, el de un proveedor de nube, el de una empresa de pagos. Otros los construye la comunidad, a menudo para productos que aún no tienen servidor oficial, y van de lo soberbio a lo abandonado. Otros son internos, construidos por empresas para sus propios sistemas y nunca publicados. Cuando eliges un servidor, esas tres categorías implican expectativas muy distintas en cuanto a soporte y seguridad, y deberías saber con cuál estás tratando.

Los hosts son las aplicaciones que se conectan a los servidores en nombre de un usuario y un modelo. Incluyen asistentes de chat de escritorio y web, agentes de programación en el terminal y en el IDE, y un número creciente de herramientas de empresa que se han convertido discretamente en hosts porque añadieron un asistente. Los hosts difieren en qué partes del protocolo soportan. Casi todos soportan herramientas. Menos soportan todas las funciones del lado del cliente. La Parte 6 hace un recorrido por los principales.

Los SDK se sitúan entre ambos. Hay SDK oficiales para los principales lenguajes, mantenidos junto a la especificación, y se encargan de las partes tediosas: el encuadre de mensajes, el saludo inicial, la negociación de capacidades, los transportes. La mayoría de los servidores que te encuentres se construyeron sobre uno. La mayoría de los que construyas también deberían.

Los ecosistemas los construyen personas que resuelven su propio problema de una manera que, por casualidad, resuelve el tuyo.

Los registros son la forma en que cualquiera encuentra algo. Hay un registro oficial de metadatos de servidores, mantenido en abierto, sobre el que pueden construir otros catálogos y directorios de hosts. Hay directorios curados dentro de los principales hosts, donde un administrador puede activar un conector revisado sin que nadie toque un archivo de configuración. Y están las listas informales que brotan en todo ecosistema, algunas mantenidas con esmero y otras hechas sobre todo de entusiasmo. La Parte 9 trata el descubrimiento como es debido.

El efecto red es real y funciona en ambos sentidos. Cada host nuevo hace más valioso cada servidor existente, y cada servidor nuevo hace más útil cada host. Ese bucle es la razón de que MCP se extendiera, y también la de que el ecosistema tenga un problema de calidad: cuando construir un servidor es fácil y publicarlo es gratis, el número de servidores crece más rápido que la capacidad de nadie para revisarlos.

Tu jugada práctica para esta semana es un pequeño inventario. Enumera los hosts que ya usa tu equipo y, para cada uno, los servidores a los que se conecta. Anota cuáles son oficiales, cuáles de la comunidad y cuáles internos. La mayoría de los equipos que lo hacen se sorprenden con ambas listas. La sorpresa está bien. La ignorancia es la versión cara.

Quién vive en el ecosistema Ecosistema MCP Servidores oficiales comunidad internos Hosts apps de chat agentes de código herram. de negocio SDKs encuadre de mensajes saludo transportes Registros Registro MCP catálogos de hosts listas informales Más hosts cada servidor vale más Más servidores cada host es más útil efecto red los servidores superan cualquier revisión Esta semana: lista tus hosts, sus servidores y quién construyó cada uno.
Fig. 9 · La forma de un ecosistema. El ecosistema: servidores, hosts, SDKs y registros, unidos por un efecto red en dos sentidos.
Capítulo 10 · Parte I

Tus primeros diez minutos

La teoría es agradable, pero nada enseña MCP como ver ocurrir una llamada a una herramienta. Dedica diez minutos a esto ahora y los noventa capítulos siguientes tendrán más sentido.

Elige un host que ya uses. Si es Claude Code, abre un terminal en un proyecto y añade un servidor con el comando claude mcp add; si es una aplicación de chat de escritorio, busca su configuración de conectores o extensiones. Escoge un servidor cuyo trabajo entiendas por completo y cuyo radio de daño sea pequeño: un servidor de sistema de archivos apuntando a una carpeta de pruebas, un servidor de documentación de una biblioteca que conozcas, un conector de solo lectura a una herramienta que uses a diario. Evita cualquier cosa que pueda enviar correos o mover dinero. Estás aprendiendo, no haciendo una audición.

Una vez conectado, comprueba que el host lo ve. La mayoría de los hosts muestran en algún lugar evidente los servidores conectados y sus herramientas; en Claude Code, el comando /mcp los enumera con su estado. Lee los nombres y las descripciones de las herramientas. Es exactamente lo que leerá el modelo, y merece la pena verlo con sus ojos. ¿Son claras las descripciones? ¿Sabrías cuándo usar cada una?

Ahora haz una pregunta que necesite el servidor. No «usa la herramienta del sistema de archivos», que no te enseña nada, sino una pregunta de verdad cuya respuesta viva detrás del servidor: qué archivos de esta carpeta mencionan facturas, o qué dice la documentación sobre los reintentos. Observa lo que pasa. El host mostrará la petición de herramienta del modelo, a menudo con sus argumentos, y quizá te pida permiso. Apruébala. Luego mira el resultado que devolvió el servidor antes de que el modelo lo resumiera.

La primera llamada a una herramienta es un truco de magia. La segunda es un mecanismo. Procura llegar pronto a la segunda.

El último paso es el que la gente se salta. Verifica. Contrasta tú mismo la respuesta con la fuente. ¿Llamó el modelo a la herramienta que esperabas, con argumentos sensatos? ¿Devolvió el servidor lo que habrías devuelto tú? ¿Coincidía el resumen con el resultado, o el modelo adornó? Estás calibrando tres cosas a la vez: la calidad del servidor, el criterio del modelo y tu propia idea de cuánto fiarte de la pareja.

Después haz una cosa más. Plantea una pregunta que el servidor no pueda responder y mira si el modelo lo admite o se inventa algo. Una buena combinación dirá que no encontró la información. Una mala se la inventará con aplomo. Saber cuál tienes vale más que cualquier benchmark.

Si has seguido los pasos, ahora entiendes el bucle del protocolo mejor que la mayoría de la gente que habla de él: descubrir, pedir, llamar, devolver. Todo lo demás en este libro es detalle sobre una de esas cuatro palabras, más las consideraciones de seguridad que llegan en cuanto conectas algo más interesante que una carpeta de pruebas. Disfruta de la carpeta de pruebas mientras dure.

Tus primeros diez minutos Elige un host que ya uses Añade un servidor una carpeta de prueba Comprueba que se ve /mcp · lee las herram. Lee el resultado bruto antes del resumen Aprueba la llamada mira los argumentos Haz una pregunta real la respuesta está detrás Verifica la respuesta compárala con la fuente Tantea sus límites pregunta lo que no sabe ¿Lo admite? sí Pareja fiable dice que no halló nada no Inventa: fíate menos El bucle que acabas de ver descubrir pedir llamar devolver todo lo demás del libro es detalle sobre una de estas cuatro palabras La primera llamada a una herramienta es un truco de magia; la segunda, un mecanismo.
Fig. 10 · Tus primeros diez minutos. Una primera sesión: conecta un servidor pequeño, pregunta, aprueba, lee el resultado bruto, verifica.
Avance gratuito · Parte I

Sigue leyendo

Has leído los primeros 10 de 100 capítulos de Guía de campo de MCP. El libro completo incluye todos los capítulos y láminas, en PDF y EPUB, en inglés, francés, polaco y español.

El libro completo llegará pronto a la tienda.

¿Ya lo compraste? Lee la edición completa en línea

Guía de campo de MCP · Primera edición, octubre de 2026
100 capítulos · 10 partes · cien diagramas
por Mat Siems · MS Books, No. 13 · 2026