# Agentes de inteligencia artificial y Model Context Protocol

**Categoría:** Inteligencia artificial · **Nivel:** Intermedio · **Lectura:** 14 min
**Publicada:** 2026-07-27 · **Actualizada:** 2026-07-27 · **Autoría:** Underc0de
**Versión HTML (canónica):** https://underc0de.org/guias/inteligencia-artificial/agentes-de-ia-y-model-context-protocol/

## Respuesta rápida

Un **agente** es un modelo de lenguaje metido en un **bucle** con acceso a **herramientas**: recibe un objetivo, decide una acción, la ejecuta, mira el resultado y vuelve a decidir. El **Model Context Protocol** —MCP— es «un estándar de código abierto para conectar aplicaciones de IA con sistemas externos», y su documentación usa una analogía útil: «pensá en MCP como un puerto USB-C para aplicaciones de IA». Define una arquitectura de **host, cliente y servidor** sobre mensajes **JSON-RPC 2.0**, con tres primitivas que un servidor puede exponer —**herramientas**, **recursos** y **prompts**— y dos transportes: **stdio** para lo local y **Streamable HTTP** para lo remoto. La revisión vigente de la especificación es **2025-11-25**.

## Qué convierte un modelo en agente

Un modelo de lenguaje, por sí solo, produce texto. Lo que lo convierte en **agente** no es un modelo distinto sino tres piezas alrededor:

1. **Herramientas.** Funciones que el modelo puede pedir que se ejecuten: leer un archivo, consultar una API, correr una prueba.
2. **Un bucle.** El resultado de cada acción vuelve al contexto, y el modelo decide la siguiente con esa información nueva.
3. **Un criterio de parada.** Objetivo cumplido, permiso denegado, pasos agotados o costo excedido.

La diferencia práctica con un chatbot es de **capacidad de acción**: a un chatbot le pedís que redacte un correo y te lo escribe; un agente puede enviarlo.

> Cuando alguien dice «agente», la pregunta útil no es qué modelo usa, sino **qué herramientas tiene y con qué permisos**.

## El problema que resuelve MCP

Si cada aplicación define a su manera cómo se le declara una herramienta, quien mantiene una fuente de datos tiene que escribir una integración por cada aplicación, y quien construye una aplicación una por cada fuente. Es el problema de **N por M**.

> «MCP es un **estándar de código abierto** para conectar aplicaciones de IA con sistemas externos.»
>
> «Pensá en MCP como un **puerto USB-C para aplicaciones de IA**. Igual que USB-C provee una manera estandarizada de conectar dispositivos electrónicos, MCP provee una manera estandarizada de conectar aplicaciones de IA con sistemas externos.»

La especificación agrega una comparación que ayuda con el alcance: MCP «toma algo de inspiración del **Language Server Protocol**», que estandarizó cómo se agrega soporte de un lenguaje a todo un ecosistema de herramientas. La idea es la misma: **escribir el servidor una vez e integrarlo en cualquier parte**.

## Host, cliente y servidor

| Participante | Definición oficial | Ejemplo |
|---|---|---|
| **Host** | «La aplicación de IA que coordina y administra uno o varios clientes MCP» | Un editor de código, una app de escritorio, una CLI |
| **Cliente** | «Un componente que mantiene una conexión con un servidor MCP y obtiene contexto de él para que el host lo use» | Se crea uno por cada servidor conectado |
| **Servidor** | «Un programa que provee contexto a los clientes MCP» | Sistema de archivos, base de datos, servicio remoto |

**«Servidor MCP» se refiere al programa que sirve los datos de contexto, sin importar dónde corre.** Lo que cambia entre local y remoto es el transporte.

Debajo hay **dos capas**: la **capa de datos** «define el protocolo basado en JSON-RPC» e incluye el ciclo de vida y las primitivas; la **capa de transporte** «define los mecanismos y canales de comunicación», con el encuadre de mensajes y la autorización.

## Las primitivas

Un **servidor** puede exponer tres:

- **Herramientas:** «funciones ejecutables que las aplicaciones de IA pueden invocar para realizar acciones».
- **Recursos:** «fuentes de datos que proveen información contextual a las aplicaciones de IA».
- **Prompts:** «plantillas reutilizables que ayudan a estructurar interacciones con modelos de lenguaje».

Una herramienta *hace* algo; un recurso *informa* algo. Un servidor de base de datos bien diseñado expone el esquema como recurso y la consulta como herramienta. Esa separación define qué necesita autorización.

El **cliente** también puede ofrecer primitivas al servidor:

| Primitiva | Qué permite | Para qué sirve |
|---|---|---|
| **Sampling** | Que el servidor pida una respuesta del modelo al host | Usar un modelo sin incluir un SDK propio ni atarse a un proveedor |
| **Roots** | Consultar los límites de sistema de archivos o de URI donde operar | Que el servidor sepa dónde tiene permitido trabajar |
| **Elicitation** | Pedirle información adicional o una confirmación a la persona | Preguntar un dato que falta o confirmar una acción |

**Elicitation** es la que más rinde para la seguridad: es el mecanismo estándar para poner a una persona en el medio antes de una acción irreversible.

## Los dos transportes

| Transporte | Cómo funciona | Cuándo |
|---|---|---|
| **stdio** | «Usa flujos de entrada y salida estándar para comunicación directa entre procesos locales en la misma máquina, con rendimiento óptimo y sin sobrecarga de red» | El servidor corre en tu equipo |
| **Streamable HTTP** | HTTP POST del cliente al servidor, con eventos del servidor opcionales para streaming. Admite autenticación HTTP estándar; se recomienda **OAuth** | El servidor es remoto |

Un servidor **stdio** es un proceso que arranca en tu máquina con tus permisos de usuario: instalarlo equivale a ejecutar el programa de un tercero. Un servidor **remoto** no corre en tu máquina, pero recibe los datos que le mandes.

## Cómo se ve en la práctica

```json
// 1. El cliente pregunta qué herramientas hay
{ "jsonrpc": "2.0", "id": 2, "method": "tools/list" }

// 2. El servidor responde con nombre, descripción y esquema de entrada
{ "tools": [ {
    "name": "weather_current",
    "description": "Get current weather information for any location",
    "inputSchema": { "type": "object",
      "properties": { "location": { "type": "string" } },
      "required": ["location"] } } ] }

// 3. El cliente ejecuta con el nombre exacto y los argumentos del esquema
{ "jsonrpc": "2.0", "id": 3, "method": "tools/call",
  "params": { "name": "weather_current",
              "arguments": { "location": "Buenos Aires" } } }

// 4. Si la lista de herramientas cambia, el servidor avisa sin que nadie pregunte
{ "jsonrpc": "2.0", "method": "notifications/tools/list_changed" }
```

El **esquema de entrada** es JSON Schema, así que la validación de tipos viene incluida. El descubrimiento es **dinámico**. Y las **notificaciones** evitan que el cliente pregunte todo el tiempo si algo cambió.

## Qué no resuelve MCP

> «MCP se enfoca únicamente en el protocolo para el intercambio de contexto; **no dicta cómo las aplicaciones de IA usan los modelos ni cómo administran el contexto provisto**.»

Sigue siendo trabajo de la aplicación:

- **Qué herramientas se le muestran al modelo** en cada momento.
- **Cuánto contexto entra** y qué se descarta cuando no cabe.
- **El bucle del agente**: pasos, criterio de parada, manejo de errores.
- **Los permisos**: qué se ejecuta solo y qué requiere confirmación.

MCP resuelve el *cómo se conecta*, no el *cómo se decide*.

## Los permisos son tu problema

> «Las herramientas representan **ejecución de código arbitrario** y deben tratarse con la precaución apropiada.»
>
> «Las descripciones del comportamiento de una herramienta, como las anotaciones, **deben considerarse no confiables**, a menos que provengan de un servidor confiable.»
>
> «Los hosts **deben** obtener consentimiento explícito de la persona antes de invocar cualquier herramienta.»

Los cuatro principios de la especificación son consentimiento y control de la persona, privacidad de los datos, seguridad de las herramientas y control del *sampling*. Y el reconocimiento clave: **«MCP no puede hacer cumplir estos principios de seguridad a nivel del protocolo»**.

## Errores frecuentes

- **Creer que MCP es un modelo o un producto.** Es un protocolo.
- **Suponer que «servidor» significa remoto.** La mayoría corre en tu propia máquina por stdio.
- **Exponer todo como herramienta.** Lo que solo informa va como recurso.
- **Confiar en la descripción de una herramienta ajena.**
- **Instalar servidores sin mirar qué son.**
- **Conectar veinte servidores «por si acaso».** Cada herramienta ocupa contexto y agrega superficie de ataque.
- **Esperar que el protocolo ponga los límites.**

## Preguntas frecuentes

**¿Qué diferencia hay entre un chatbot y un agente?**
Un chatbot recibe un pedido y devuelve texto; un agente recibe un objetivo y trabaja en un bucle con herramientas hasta cumplirlo o quedarse sin permiso o sin pasos. La diferencia no está en el modelo sino en las piezas que lo rodean.

**¿Qué es el Model Context Protocol?**
Un estándar de código abierto para conectar aplicaciones de IA con sistemas externos, comparado con un puerto USB-C para aplicaciones de IA. Usa JSON-RPC 2.0 y define qué puede ofrecer un servidor a un cliente.

**¿Cuáles son las primitivas de MCP?**
Del servidor: herramientas, recursos y prompts. Del cliente: sampling, roots y elicitation.

**¿Qué es un host, un cliente y un servidor MCP?**
El host es la aplicación de IA que coordina; el cliente mantiene la conexión con un servidor y hay uno por servidor; el servidor es el programa que provee contexto, local o remoto.

**¿Qué transportes usa MCP?**
stdio para procesos locales en la misma máquina, y Streamable HTTP para servidores remotos, con OAuth recomendado para los tokens.

**¿MCP resuelve la seguridad de un agente?**
No. La especificación dice que «MCP no puede hacer cumplir estos principios de seguridad a nivel del protocolo». La seguridad queda del lado de la aplicación.

## Fuentes

Fecha de consulta: 27 de julio de 2026.

**Aportes de la comunidad Underc0de**

1. Underc0de, blog. [Google dona el protocolo Agent2Agent (A2A) a la Fundación Linux](https://blog.underc0de.org/google-dona-el-protocolo-agent2agent-a2a-a-la-fundacion-linux/), 25 de junio de 2025.
2. Underc0de, foro. [Sección Inteligencia artificial](https://underc0de.org/foro/inteligencia-artificial/).

**Documentación oficial**

3. Model Context Protocol. [What is the Model Context Protocol?](https://modelcontextprotocol.io/docs/getting-started/intro).
4. Model Context Protocol. [Architecture overview](https://modelcontextprotocol.io/docs/learn/architecture).
5. Model Context Protocol. [Specification](https://modelcontextprotocol.io/specification/latest), revisión 2025-11-25.
6. JSON-RPC. [JSON-RPC 2.0](https://www.jsonrpc.org/).

## Guías relacionadas

- [Seguridad de agentes y aplicaciones de inteligencia artificial](../seguridad-de-agentes-y-aplicaciones-de-ia/index.md)
- [Cómo ejecutar modelos de IA localmente con Ollama](../ejecutar-modelos-de-ia-localmente-con-ollama/index.md)
- [Cómo crear un sistema RAG con documentos propios](../como-crear-un-sistema-rag-con-documentos-propios/index.md)
- [Índice de Inteligencia artificial](../index.md)