Entrada

MCP vs function calling: lo medí en tokens

Con 200 herramientas, contestar una pregunta de una línea cuesta 38.684 tokens de entrada. MCP no ahorra ni uno: lo medí con el mismo modelo y la misma tarea.

MCP vs function calling: lo medí en tokens
0:00 / 22:13
Más formatos
Diapositiva 1 de 15

Le hice una pregunta de una línea a un modelo de lenguaje: «¿cuántos posts tengo sobre Docker?». Para contestarla, el modelo gastó 38.684 tokens de entrada. Mi pregunta apenas ocupaba unos pocos. Casi todo lo demás era la lista de 200 herramientas (funciones que mi programa puede ejecutar cuando el modelo se lo pide) que le envío en cada petición para que sepa qué puede hacer.

Un token es la unidad en la que un modelo lee el texto: un trozo de palabra. En inglés, 100 tokens equivalen a unas 75 palabras, y en español hacen falta algunos más. Importan por dos motivos: los proveedores cobran por token, y cada modelo tiene un límite de tokens que puede leer de una vez.

Esa cifra cambia la discusión habitual sobre las dos formas de dar herramientas a un modelo, tool calling (también llamado function calling) y MCP, que explico enseguida. En esa discusión se mezclan dos preguntas distintas: una trata del formato con que el modelo pide una herramienta y la otra, de dónde se guardan esas herramientas. Monté un banco de pruebas para separarlas y medí cada opción con el mismo modelo, la misma pregunta y la misma herramienta.

Resumen en 30 segundos: function calling y MCP gastan exactamente los mismos tokens, porque los dos envían el catálogo completo al modelo. Lo que dispara la factura es cuántas herramientas le envías a la vez: con 200, una pregunta cuesta 38.684 tokens de entrada. Si en lugar del catálogo le das un buscador y le pasas cada herramienta solo cuando la pide, la misma pregunta baja a 2.100.

1. El modelo pide; la cocina ejecuta

Antes de comparar nada, conviene dejar claro qué hace el modelo y qué hace tu programa. Un modelo de lenguaje no tiene acceso a tu base de datos, ni a tus ficheros, ni a internet. Lo único que hace cuando «usa una herramienta» es escribir un texto con una forma pactada que dice qué herramienta quiere usar y con qué datos. La ejecuta el agente: el programa que habla con el modelo, le ofrece las herramientas y hace lo que el modelo pide. Y es el agente quien decide qué está permitido.

Es la diferencia entre pedir y hacer, y la guía de agentes de Anthropic la usa como criterio: el modelo decide, el agente actúa. Piensa en un restaurante: el camarero apunta el pedido en una nota, pero quien entra en la cocina y cocina es otro. Si la nota pide un plato que no existe, la cocina la devuelve y el camarero vuelve a preguntar. El modelo es el camarero: no toca nada.

Todo lo que el modelo lee en cada petición se llama contexto: tus instrucciones, la conversación hasta ese momento y la lista de herramientas disponibles. Tiene un tamaño máximo, la ventana de contexto, y cada token que entra se paga. Por eso importa tanto cuántas herramientas metes en él.

Que un modelo aprenda cuándo llamar a una herramienta no es nuevo: Toolformer ya lo demostró en 2023. Después, esa capacidad pasó a expresarse con un formato fijo en vez de con texto libre que hay que interpretar. Con eso claro, ya se puede explicar qué es cada cosa.

2. Un formato de petición y un mostrador de herramientas

Function calling es dos cosas a la vez: un formato y una habilidad entrenada. El formato es la lista que el agente envía al modelo junto a la pregunta: cada función con su nombre, para qué sirve y qué datos necesita. La habilidad es que el modelo ha sido entrenado para usar esa lista. OpenAI lo lanzó en junio de 2023 y lo explicó así: sus modelos se ajustaron para «detectar cuándo hay que llamar a una función» y para «responder con un JSON que cumpla su firma», en vez de con texto.

Un ejemplo sencillo. En él intervienen tres piezas, y conviene no mezclarlas:

PiezaQué esQué hace
El modeloEl modelo de lenguaje, en los servidores de su proveedorLee texto y escribe texto. Nada más
El agenteEl programa que escribes túHabla con el modelo y ejecuta las funciones
El servicio del tiempoUna web externa con datos meteorológicosResponde a quien le pregunta

La función consultar_tiempo no viene con el modelo: la escribe quien programa el agente, y es código normal que consulta esa web.

1
2
3
4
def consultar_tiempo(ciudad):
    # Código del agente: pregunta a un servicio meteorológico (dirección de ejemplo)
    respuesta = requests.get(f"https://tiempo.example.com/hoy/{ciudad}")
    return respuesta.json()["resumen"]   # por ejemplo, "18 °C y soleado"

Así se reparte el trabajo cuando alguien pregunta por el tiempo:

  1. El agente envía al modelo la pregunta «¿Qué tiempo hace en Madrid?» y, junto a ella, la descripción de la función: se llama consultar_tiempo, da el tiempo de hoy y necesita el nombre de una ciudad. No le envía el código, solo esa descripción.
  2. El modelo no sabe qué tiempo hace hoy, pero al leer la descripción reconoce que esa función le daría el dato. Así que no contesta con texto: escribe {"name": "consultar_tiempo", "arguments": {"ciudad": "Madrid"}}. Es solo una petición; no se ejecuta nada.
  3. El agente lee esa nota, ejecuta su función consultar_tiempo("Madrid"), que pregunta a la web del tiempo y obtiene «18 °C y soleado», y envía ese resultado al modelo en una segunda petición.
  4. El modelo, ahora con el dato delante, redacta la respuesta para la persona: «En Madrid hace 18 grados y sol».

¿Y dónde van exactamente esas funciones? En cada petición que el agente envía al modelo, en un campo propio llamado tools, separado de las instrucciones del system prompt y de la pregunta. La petición del paso 1 es, recortada, esto:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
{
  "model": "deepseek-chat",
  "messages": [
    {"role": "system", "content": "Eres un asistente útil."},
    {"role": "user", "content": "¿Qué tiempo hace en Madrid?"}
  ],
  "tools": [{
    "type": "function",
    "function": {
      "name": "consultar_tiempo",
      "description": "Da el tiempo de hoy en una ciudad.",
      "parameters": {
        "type": "object",
        "properties": {"ciudad": {"type": "string"}},
        "required": ["ciudad"]
      }
    }
  }]
}

El proveedor coge ese campo y lo mete en el contexto del modelo junto al resto. Anthropic lo documenta para Claude: las definiciones de tools cuentan como tokens de entrada, y la API añade además unas instrucciones propias para que el modelo sepa usarlas. Como el modelo no recuerda nada entre una petición y la siguiente, el agente tiene que volver a enviar la lista también en la segunda petición, la del paso 3.

Que la función esté en la lista no obliga a usarla: el modelo decide en cada petición. Si con esa misma lista la persona escribe «Hola, ¿qué tal?», el modelo contesta con texto y no pide nada, porque ninguna función le hace falta. Y si la lista tuviera también consultar_saldo y enviar_correo, para la pregunta del tiempo elegiría solo consultar_tiempo.

Entonces, ¿qué tiene de entrenado el modelo? Nada que ver con el tiempo: no conoce esa web ni esa función, y de consultar_tiempo solo sabe lo que dice su descripción en esa petición. Lo que aprendió en su entrenamiento es la habilidad general de leer cualquier lista de funciones, decidir si alguna le sirve y escribir la petición con el formato exacto. Mañana le describes consultar_saldo o enviar_correo y hace lo mismo.

Hoy todos los proveedores ofrecen esta habilidad, con variaciones mínimas y nombres distintos: function calling en OpenAI, tool use en Anthropic, tool calling en general. Son lo mismo. Martin Fowler lo desarrolla con un agente de compras completo si quieres ver el formato antes de seguir.

MCP (Model Context Protocol) es un protocolo de conexión. En vez de que cada agente escriba sus herramientas, un servidor las publica y el agente le pregunta qué hay. Así, la misma herramienta la pueden usar Claude, Cursor, VS Code o tu propio agente sin escribir la integración en cada uno. La visión general del protocolo lo resume en dos pantallas y este catálogo de servidores muestra cuántos hay ya.

La imagen que mejor los separa: function calling es cómo se escribe la petición; MCP es el mostrador donde están las herramientas. Puedes pedir sin mostrador, llevando tus propias herramientas, y puedes tener mostrador sin que cambie la forma de pedir.

Function callingMCP
Qué esUn formato de petición y respuesta, y la habilidad entrenada del modelo para usarloUn protocolo entre el agente y un servidor
Quién describe las herramientasTú, en cada peticiónEl servidor, cuando el agente se lo pregunta
Dónde están las herramientasEn tu agenteEn el servidor, en tu máquina o en otra
Quién ejecutaTu agenteEl servidor, con sus permisos
Qué resuelveQue el modelo pida con datos bien estructuradosQue N aplicaciones usen M herramientas sin escribir N×M integraciones
Qué no resuelveCompartir herramientas entre aplicacionesEl formato de la petición, que sigue haciendo falta
Cuándo bastaSi solo las usa tu agenteSi varias aplicaciones comparten las herramientas

Dos paneles comparados: a la izquierda, tres aplicaciones (tu agente, Cursor y Claude) conectadas con flechas a tres servicios (GitHub, base de datos y correo), nueve conexiones en total; a la derecha, las mismas tres aplicaciones conectadas a un nodo central MCP, que a su vez conecta con los tres servicios, seis conexiones

Y hay cuatro ideas equivocadas sobre MCP que se repiten a menudo:

  • «Es un framework». En realidad es un acuerdo sobre qué mensajes se envían; FastMCP es una de las bibliotecas que lo cumplen.
  • «Sustituye a function calling». Se apoya en él: el modelo sigue pidiendo la herramienta con el mismo formato, solo que la descripción de la herramienta la trajo un servidor.
  • «Es un producto de una empresa». La especificación es abierta y hay aplicaciones compatibles y servidores de muchas empresas.
  • «Es una API más». Una API es la puerta por la que un programa habla con otro sistema, con direcciones fijas a las que llamar. MCP no tiene direcciones que memorizar, sino mensajes con un orden fijo, como se ve en la sección 4.

Con las definiciones separadas, toca ver cada una por dentro.

3. Function calling: la descripción está en tu agente

En la vía clásica, cada petición al modelo lleva adjunta la descripción de las herramientas disponibles. Esa descripción es un JSON Schema: un JSON que dice cómo se llama la herramienta, para qué sirve y qué datos necesita. El modelo responde con un campo tool_calls que dice qué quiere usar; el agente lo ejecuta y le devuelve el resultado como un mensaje más.

Así es una respuesta real de la API de DeepSeek, por la que el agente habla con el modelo a través de internet, con una sola herramienta declarada:

1
2
3
4
5
6
7
8
9
10
11
12
13
{
  "choices": [{
    "message": {
      "role": "assistant",
      "tool_calls": [{
        "id": "call_00_2cRXMgNKOlIkH2e7IysT1157",
        "type": "function",
        "function": { "name": "contar_posts", "arguments": "{\"tema\": \"Docker\"}" }
      }]
    }
  }],
  "usage": { "prompt_tokens": 301, "completion_tokens": 41 }
}

La petición se ve entera: el nombre de la herramienta, los datos y un identificador de la llamada. Lo que no está en el JSON es el permiso. El modelo pidió contar_posts; si esa función borrase la base de datos, la habría pedido igual, porque no distingue entre leer y borrar. Comprobar los datos, decidir quién puede hacer qué y guardar un registro es trabajo del agente.

Y aquí aparece el coste que casi nadie mira: la descripción de las herramientas viaja en cada petición, aunque el modelo no use ninguna. La documentación de function calling de OpenAI lo dice sin rodeos: las definiciones van dentro de la petición y cuentan como tokens de entrada. Además, una pregunta con herramienta necesita dos peticiones, como en el ejemplo del tiempo de la sección 2:

  1. Primera petición: el agente envía la pregunta y el catálogo de herramientas. El modelo contesta pidiendo una herramienta.
  2. Segunda petición: el agente ejecuta la herramienta y vuelve a enviárselo todo al modelo (la pregunta, otra vez el catálogo, la petición del modelo y el resultado de la herramienta) para que redacte la respuesta final.

El catálogo viaja en las dos. Así son las dos peticiones que envía el agente para la pregunta de este post, recortadas (tools lleva la descripción de contar_posts que ya has visto en la sección 2 y en el ejemplo del tiempo):

1
2
3
4
5
6
7
{
  "model": "deepseek-chat",
  "messages": [
    {"role": "user", "content": "¿Cuántos posts tengo sobre Docker? Usa una herramienta."}
  ],
  "tools": [ …el catálogo completo… ]
}

El modelo contesta con la respuesta de arriba: no escribe texto, pide contar_posts con {"tema": "Docker"}. El agente ejecuta su función, que devuelve «Hay 8 posts sobre docker.», y envía la segunda petición:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
  "model": "deepseek-chat",
  "messages": [
    {"role": "user", "content": "¿Cuántos posts tengo sobre Docker? Usa una herramienta."},
    {"role": "assistant", "tool_calls": [{
      "id": "call_00_2cRXMgNKOlIkH2e7IysT1157",
      "type": "function",
      "function": {"name": "contar_posts", "arguments": "{\"tema\": \"Docker\"}"}
    }]},
    {"role": "tool", "tool_call_id": "call_00_2cRXMgNKOlIkH2e7IysT1157",
     "content": "Hay 8 posts sobre docker."}
  ],
  "tools": [ …el catálogo completo, otra vez… ]
}

Fíjate en lo que se repite: la pregunta y el catálogo entero. Lo nuevo son los dos últimos mensajes, la petición que hizo el modelo y el resultado de la herramienta, unidos por el mismo identificador. Con eso delante, el modelo ya contesta con texto, algo como «Tienes 8 posts sobre Docker».

Con una sola herramienta, la primera petición de la respuesta de arriba ocupó 301 tokens de entrada: es el valor de prompt_tokens. La segunda ocupó algo más, unos 380, porque además del catálogo lleva la petición del modelo y el resultado. En total, la pregunta completa costó 682 tokens de entrada. Con doscientas herramientas, que se repiten en las dos peticiones, 38.684. El cookbook de OpenAI tiene una comparación parecida con el ciclo completo, si prefieres leerla en código.

4. MCP: la descripción pasa a un servidor

Con MCP, la descripción de las herramientas cambia de sitio. En vez de que el agente la escriba, un servidor la publica y el agente pregunta qué herramientas hay. En la conversación participan tres piezas:

  • el host, que es el nombre que da MCP al agente: la aplicación que habla con el modelo (Claude, Cursor o la tuya) y decide qué se aprueba;
  • el cliente, una pieza dentro del agente que se encarga de la conexión con un servidor. El agente crea un cliente por cada servidor al que se conecta;
  • y el servidor, que publica las herramientas y las ejecuta.

Los mensajes entre cliente y servidor van en JSON-RPC 2.0, un formato de 2010 para pedirle a otro programa que ejecute algo y recibir la respuesta, todo en JSON. Viajan por una de dos vías, que la especificación llama transportes: stdio, que usa la entrada y la salida estándar de un proceso cuando el servidor se ejecuta en tu propia máquina, o HTTP cuando está en otra. La especificación de MCP fija además un orden: primero el cliente y el servidor se presentan y acuerdan qué sabe hacer cada uno, y después piden herramientas. Anthropic lo presentó en noviembre de 2024 como estándar abierto.

Diagrama de secuencia con tres columnas: Agente y Cliente MCP, dentro de un recuadro discontinuo rotulado tu agente (el host), y Servidor MCP. En tres fases, presentarse, descubrir herramientas y usar una, diez mensajes numerados van de una columna a otra: initialize y la respuesta con la versión; la pregunta por las herramientas, tools/list y la lista de vuelta al agente; y la petición de contar_posts, tools/call, el resultado «Hay 8 posts sobre docker.» y su vuelta al agente. Las peticiones van en trazo continuo y las respuestas en discontinuo

Un servidor puede ofrecer tres cosas distintas, y la distinción importa porque solo una se parece a function calling:

  • Herramientas: funciones que hacen algo y piden datos de entrada. Es lo comparable.
  • Recursos: datos que el host puede leer, como ficheros o filas de una tabla. El modelo no los «llama»; los consulta el host.
  • Prompts: plantillas de instrucciones que el servidor ofrece al usuario.

Este es el mensaje real con el que un servidor de pruebas describe una de sus herramientas, en respuesta a tools/list:

1
2
3
4
5
6
7
{"jsonrpc":"2.0","id":2,"result":{"tools":[{
  "name":"contar_posts",
  "description":"Cuenta cuántos posts del blog tratan un tema concreto.",
  "inputSchema":{"type":"object",
    "properties":{"tema":{"type":"string","description":"Tema a contar"}},
    "required":["tema"]}
}]}}

Es casi el mismo objeto que en function calling. La diferencia de fondo es quién lo mantiene y para cuántos agentes. Un servidor MCP lo escribe una vez el dueño del sistema y lo usan Claude, Cursor, VS Code o tu agente, sin que cada uno repita la integración. Así, un problema de N aplicaciones por M herramientas pasa a ser N más M. Pero fíjate en lo que no cambia: para que el modelo pueda elegir, el host tiene que meter esa descripción en el contexto, igual que en function calling.

Diagrama de componentes de izquierda a derecha: el modelo emite la llamada, el host la aprueba y la registra, el cliente MCP envía mensajes JSON-RPC 2.0 a un servidor local por stdio o a uno remoto por HTTP; los dos terminan en el sistema real, con sus datos y permisos

5. Montar la misma herramienta dos veces

Para comparar de verdad hay que construir las dos vías con la misma herramienta, y una tercera variante, el descubrimiento progresivo, que se explica en la sección 6. Uso una consulta sencilla sobre el blog, contar_posts(tema), que devuelve cuántos posts hay de un tema. El código completo está en el dossier del post y aquí van las piezas que importan. Para montarlo hace falta un entorno de Python aislado, y con uv, la herramienta de Astral, son dos comandos.

5.1 El catálogo, definido en un solo sitio

Para que la comparación sea justa, las dos vías tienen que ofrecer al modelo exactamente las mismas herramientas. Por eso el catálogo sale de una sola función, build(size), y tanto la vía de function calling como la de MCP la usan: así es imposible que una tenga una herramienta de más o una descripción distinta.

La función devuelve tantas herramientas como se le pidan: 1, 10, 50 o 200. Solo una sirve para la pregunta, contar_posts. El resto son distractores: herramientas inventadas que también tratan del blog y tienen nombres parecidos, como contar_visitas, contar_redirecciones o resumir_posts_etiqueta. Están ahí para comprobar que el modelo sigue eligiendo la correcta cuando la lista crece:

1
2
3
4
5
6
7
8
9
10
11
12
def build(size):
    tools = [{
        "name": "contar_posts",
        "description": "Cuenta cuántos posts del blog tratan un tema concreto.",
        "parameters": {
            "type": "object",
            "properties": {"tema": {"type": "string", "description": "Tema a contar"}},
            "required": ["tema"],
        },
    }]
    # ... size - 1 distractores con nombres y esquemas realistas
    return tools[:size]

5.2 La vía de function calling

Cuarenta líneas y ningún servidor: se envía el catálogo, se recibe la petición del modelo y la función se ejecuta dentro del propio agente.

1
2
3
4
5
6
7
8
9
10
11
tools = [{"type": "function", "function": entry} for entry in build(size)]
messages = [{"role": "user", "content": "¿Cuántos posts tengo sobre Docker? Usa una herramienta."}]

payload = chat(messages, tools)          # POST a /chat/completions
calls = payload["choices"][0]["message"]["tool_calls"]
if calls:
    result = catalog.call(calls[0]["function"]["name"],
                          json.loads(calls[0]["function"]["arguments"]))
    messages += [payload["choices"][0]["message"],
                 {"role": "tool", "tool_call_id": calls[0]["id"], "content": result}]
    chat(messages, tools)                # segunda vuelta con el resultado

5.3 La vía MCP

El servidor es un fichero con FastMCP, una biblioteca que se apoya en el SDK oficial de Python de MCP y ahorra escribir los mensajes del protocolo a mano. Registrar el catálogo tal cual no funciona: FastMCP rechaza las funciones con **kwargs, porque necesita conocer cada argumento para escribir la descripción de la herramienta. La solución es generar una función por herramienta y devolverle la descripción original.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from fastmcp import FastMCP
from fastmcp.tools.base import Tool

mcp = FastMCP("banco-de-pruebas")

def make_function(entry):
    names = list(entry["parameters"]["properties"])
    signature = ", ".join(f"{name}=None" for name in names)
    body = ", ".join(f"'{name}': {name}" for name in names)
    source = f"def {entry['name']}({signature}):\n    return _call('{entry['name']}', {{{body}}})\n"
    namespace = {"_call": catalog.call}
    exec(source, namespace)
    return namespace[entry["name"]]

for entry in catalog.build(SIZE):
    tool = Tool.from_function(make_function(entry), name=entry["name"],
                              description=entry["description"])
    tool.parameters = entry["parameters"]   # conserva required y descripciones
    mcp.add_tool(tool)

Del lado del agente, el cliente de FastMCP pregunta y llama sin saber qué hay detrás:

1
2
3
4
5
6
from fastmcp import Client

async with Client({"mcpServers": {"bench": {
        "command": sys.executable, "args": ["server.py"], "env": env}}}) as client:
    listing = await client.list_tools()
    resultado = await client.call_tool("contar_posts", {"tema": "docker"})

Tres trampas que te hacen perder una tarde.

  • FastMCP lanza ValueError: Functions with **kwargs are not supported as tools si intentas registrar una función genérica.
  • El Client de FastMCP 4 no acepta un argumento env. Las variables de entorno del servidor se pasan con la configuración estándar mcpServers, que sí lleva el campo env.
  • En el SDK 2 de MCP, los campos pasaron a llamarse en snake_case: leer tool.inputSchema da AttributeError y hay que usar tool.input_schema.

5.4 La variante del descubrimiento progresivo

Es la vía de function calling con un cambio: en lugar del catálogo, el modelo recibe un buscador. Así es en el banco, recortado. Primero, la descripción del buscador y la función que busca, que es del agente y se limita a contar cuántas palabras de la consulta aparecen en el nombre y la descripción de cada herramienta:

1
2
3
4
5
6
7
8
9
10
11
12
13
SEARCH_TOOL = {"type": "function", "function": {
    "name": "buscar_tools",
    "description": "Busca herramientas disponibles por descripción. Devuelve los esquemas que coinciden.",
    "parameters": {"type": "object",
                   "properties": {"consulta": {"type": "string", "description": "Qué necesitas hacer"}},
                   "required": ["consulta"]}}}

def search(entries, consulta, top=3):
    # Puntúa cada herramienta por las palabras que comparte con la consulta del modelo
    words = {w for w in re.findall(r"\w+", consulta.lower()) if len(w) > 2}
    scored = [(sum(w in f"{e['name']} {e['description']}".lower() for w in words), e)
              for e in entries]
    return [e for hits, e in sorted(scored, key=lambda pair: -pair[0]) if hits][:top]

Y las peticiones al modelo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
entries = catalog.build(size)
messages = [{"role": "user", "content": "¿Cuántos posts tengo sobre Docker? Usa una herramienta."}]

# 1.ª petición: el modelo solo tiene el buscador, y lo usa
first = chat(messages, [SEARCH_TOOL])
call = first["choices"][0]["message"]["tool_calls"][0]
matches = search(entries, json.loads(call["function"]["arguments"])["consulta"])

# 2.ª petición: el buscador y las tres herramientas que mejor encajan
messages += [first["choices"][0]["message"],
             {"role": "tool", "tool_call_id": call["id"], "content": json.dumps(matches)}]
tools = [SEARCH_TOOL] + [{"type": "function", "function": e} for e in matches]
second = chat(messages, tools)          # aquí el modelo pide contar_posts

# 3.ª petición: el agente ejecuta contar_posts y el modelo redacta la respuesta,
# igual que en la vía de function calling

El catálogo de 200 herramientas no sale nunca del agente: al modelo solo le llegan el buscador y, en la segunda petición, tres descripciones.

Con las tres vías montadas, toca ver qué cambia al usarlas.

6. Cuatro caminos, la misma pregunta

El banco ejecuta la misma tarea con cuatro configuraciones y cuatro tamaños de catálogo: el mismo modelo (deepseek-chat), la misma pregunta y la misma herramienta. Las cuatro configuraciones son function calling, MCP por stdio, MCP por HTTP y el descubrimiento progresivo, que es la única que cambia la forma de trabajar del agente.

Qué es el descubrimiento progresivo. Es una forma de trabajar en la que el modelo no recibe la lista de herramientas, sino un buscador para encontrarlas: primero busca la que necesita y solo entonces recibe su descripción. Es lo que haces en una biblioteca grande: no te lees el catálogo entero antes de pedir un libro, sino que preguntas en el mostrador y te traen los tres que encajan con lo que buscas.

En las otras tres configuraciones, el agente envía el catálogo completo en cada petición. En el descubrimiento progresivo no lo envía nunca: le da al modelo una sola herramienta, un buscador llamado buscar_tools, y le pasa las demás solo cuando las pide. Con la pregunta de este post, eso son tres peticiones:

  1. Primera petición: la pregunta y una única herramienta, buscar_tools. El modelo no ve las 200 herramientas; solo sabe que puede buscar. Así que contesta pidiendo una búsqueda, con algo como «contar posts sobre un tema».
  2. Segunda petición: el agente hace esa búsqueda en su catálogo, comparando las palabras de la consulta con el nombre y la descripción de cada herramienta, y se queda con las tres que más coinciden. Se las envía al modelo junto con el buscador. Entre esas tres está contar_posts, y el modelo la pide.
  3. Tercera petición: el agente ejecuta contar_posts y le envía el resultado al modelo, que redacta la respuesta.

El modelo nunca carga más de cuatro descripciones (el buscador y tres resultados), tenga el catálogo 10 herramientas o 200. A cambio, hace una petición más.

Cada combinación de camino y tamaño de catálogo se ejecutó tres veces, y la tabla da la mediana: el valor del medio de las tres. Los tokens son los de entrada de la pregunta completa (las dos peticiones, o las tres del descubrimiento progresivo), según la propia API, y la latencia es el tiempo hasta tener la respuesta. Es la misma pregunta que se hizo MCPBench, pero con function calling al lado y no solo con servidores de búsqueda.

HerramientasCaminoTokensLatenciaAcierto
1Function calling6822.017 ms3/3
1MCP stdio6821.975 ms3/3
1MCP HTTP6821.814 ms3/3
1Descubrimiento progresivo1.4553.181 ms3/3
10Function calling2.4021.889 ms3/3
10MCP stdio2.4022.339 ms3/3
10MCP HTTP2.4021.742 ms3/3
10Descubrimiento progresivo2.2082.760 ms3/3
50Function calling10.0382.111 ms3/3
50MCP stdio10.0382.196 ms3/3
50MCP HTTP10.0381.795 ms3/3
50Descubrimiento progresivo2.0922.734 ms3/3
200Function calling38.6842.178 ms3/3
200MCP stdio38.6842.498 ms3/3
200MCP HTTP38.6842.173 ms3/3
200Descubrimiento progresivo2.1003.808 ms3/3
Fig 1 Lo que cuesta cada camino

HerramientasFunction callingMCPProgresivo
16826821.455
102.4022.4022.208
5010.03810.0382.092
20038.68438.6842.100
Elige el número de herramientas y compara los tres caminos. Son los tokens de entrada de una pregunta completa, según la API. Function calling envía todas las herramientas en cada petición; MCP también, venga por stdio o por HTTP; el descubrimiento progresivo solo envía un buscador y pide la descripción de cada herramienta cuando hace falta. Function calling y MCP dan la misma barra porque gastan exactamente lo mismo.

Los cinco resultados, por orden de importancia:

  1. Function calling y MCP gastan exactamente los mismos tokens. Ni uno de diferencia, en ninguno de los cuatro tamaños. Se entiende al mirar el flujo: en los dos casos la descripción de todas las herramientas acaba dentro de la petición. Elegir uno u otro por el contexto que ocupan no tiene sentido.
  2. El coste lo pone el catálogo. Con 200 herramientas, una pregunta de una línea cuesta 38.684 tokens de entrada. Con el precio actual de DeepSeek para su modelo rápido, entre 0,14 y 0,27 € por millón de tokens de entrada según la hora, eso es alrededor de un céntimo por pregunta, y casi todo se va en enviar la lista de herramientas, no en la pregunta.1
  3. El descubrimiento progresivo apenas crece. Como solo hay un buscador en el contexto, cuesta casi lo mismo con 10 herramientas que con 200: 2.100 tokens con 200, 18 veces menos. Es la idea que Anthropic propone con ejecución de código, aplicada aquí a la lista de herramientas.
  4. El ahorro se paga con espera. Con 200 herramientas, 3.808 ms frente a 2.178: la petición extra y la búsqueda añaden 1,6 segundos. Y esa espera es solo una parte del total; si lo que tarda es generar la respuesta, las cuentas cambian, como conté en GGUF vs MLX y en FP16 vs BF16.
  5. La elección no empeoró. El modelo eligió la herramienta correcta en las 48 ejecuciones de la tabla, también con 200 herramientas, entre ellas distractores con nombres que se parecen mucho al de contar_posts, como contar_visitas o contar_redirecciones.

Lo que esta prueba no dice. Es una tarea de un solo paso, con una pregunta explícita y un único modelo. Demuestra que este modelo no se pierde con 200 herramientas en esta tarea; no demuestra que nunca se pierda, ni cubre conversaciones largas, ni herramientas que cambian datos. Las latencias incluyen la red y varían con el día. Y en el descubrimiento progresivo, si la búsqueda no encuentra nada, el banco le pasa al modelo la herramienta correcta: su acierto mide cómo elige el modelo, no lo bueno que es el buscador, que en un sistema real habría que medir aparte.

Conectar con un servidor MCP también tiene su coste, y es lo que separa los dos transportes. En el banco, arrancar el servidor como proceso local por stdio tardó entre 100 y 143 ms, mientras que el mismo servidor por HTTP, ya arrancado, respondió en 2 a 11 ms. Si el agente arranca muchas veces al día, esos cien milisegundos pesan; si el proceso sigue vivo, no.

7. Cuando el servidor miente

Llevar las herramientas a un servidor tiene una consecuencia que no se ve hasta que causa un problema: el modelo lee la descripción de cada herramienta como si fuera texto de confianza, y no tiene por qué serlo. Quien escribe esa descripción es el dueño del servidor, no tú.

La guía rápida de seguridad para MCP que publica OWASP recoge los ataques conocidos, y los tres primeros se aprovechan de esa confianza:

  • Envenenamiento de herramientas (tool poisoning): instrucciones maliciosas escondidas en la descripción, en el esquema o en el resultado. El modelo las obedece porque para él son parte de las instrucciones.
  • El cambiazo (rug pull): el servidor muestra una herramienta inofensiva, el usuario la aprueba y, después, el servidor cambia su definición por otra que no lo es.
  • Tool shadowing: la descripción de un servidor malicioso le dice al modelo cómo usar las herramientas de otro servidor de confianza, por ejemplo, que copie a una dirección ajena los correos que envía.

A eso se suman dos problemas más corrientes. El primero es el confused deputy: el servidor actúa con sus propios permisos y no con los del usuario que pidió la acción, así que un servidor con acceso amplio se convierte en la puerta de entrada para todos. El segundo, los permisos de más: dar acceso completo a un buzón cuando bastaba con leerlo. OAuth, el sistema con el que una aplicación pide permiso para actuar en tu nombre sin conocer tu contraseña, permite limitar ese acceso, y la especificación de MCP lo adopta para los servidores remotos.

RiesgoQué hacer
Descripción manipuladaMostrar la descripción completa al aprobar, no solo el nombre
Definición que cambiaGuardar una huella (hash) de la definición y pedir revisión si cambia
Permisos del servidorEjecutar con los permisos del usuario que pide, no con los del servicio
Permisos de OAuthPedir el mínimo y poder revocarlo a mano
Servidores de tercerosRevisar el código o quedarse con los oficiales

Hay dos trabajos que miden estos ataques en vez de enumerarlos. MCPSecBench reúne 17 ataques en un entorno que cualquiera puede reproducir. Y una comparación entre function calling y MCP con 3.250 escenarios de ataque y siete modelos encontró que con function calling tuvo éxito el 73,5 % de los ataques y con MCP el 62,6 %, que cada arquitectura falla por un sitio distinto y que, al encadenar varios ataques, el éxito subió al 91–96 %. Ningún protocolo es seguro por sí solo. Lo que protege es el host: mostrar lo que se aprueba, vigilar que no cambie y limitar lo que puede hacer después. Es el mismo trabajo que ya hacías con tus herramientas locales, pero ahora la descripción la escribe alguien a quien no conoces.

8. La decisión depende de quién usa la herramienta

En una frase: herramientas solo para tu programa, function calling; herramientas que comparten varias aplicaciones, MCP; más de veinte herramientas, descubrimiento progresivo encima de lo que elijas.

8.1 Los tres casos que deciden

Function calling, cuando las herramientas son tuyas y de nadie más. Escribes la función, la describes en la petición y la ejecutas en tu agente. Sin servidor, sin transporte, sin permisos que repartir. Es la opción sencilla y debería ser la de partida: si no tienes el problema que resuelve MCP, no lo necesitas.

MCP, cuando la herramienta deja de ser solo tuya. Da igual que la usen varias aplicaciones de tu equipo, una aplicación de terceros o el mismo servicio conectado desde Claude, Cursor y VS Code: la escribes una vez y la conectas en todas. Y tiene una ventaja difícil de conseguir por tu cuenta: cada usuario entra con su propia cuenta, da su consentimiento y puede revocarlo, en vez de compartir una clave escrita en el código.

Descubrimiento progresivo, cuando la lista no cabe. No es una alternativa a las dos anteriores, sino una capa encima: en el contexto deja solo un buscador y pide la descripción de cada herramienta cuando hace falta. Sirve con function calling y con MCP, y solo compensa si tienes muchas herramientas.

Tu casoQué usar
Herramientas propias, un solo agente, pocas herramientasFunction calling
Varias aplicaciones o personas comparten las herramientasMCP, con un servidor
Cada usuario con su propia cuentaMCP con OAuth por usuario
El agente arranca muchas veces al díaMCP por HTTP; stdio arranca el proceso cada vez
Más de veinte herramientas, y creciendoDescubrimiento progresivo, encima de lo que elijas
Necesitas controlar tú los permisos y el registroFunction calling, o MCP con un host que lo haga

8.2 Lo que no cambia al elegir

El resultado de las pruebas cabe en una frase: MCP ocupa en el contexto lo mismo que function calling, ni un token más ni uno menos. Lo que cambia es quién escribe la descripción de las herramientas y, sobre todo, cuántas envías de golpe. Cambiar de protocolo no te va a ahorrar contexto; recortar la lista, sí.

Para no escribir lo que ya existe, el catálogo oficial de servidores MCP es el punto de partida. La lista de aplicaciones compatibles dice en qué aplicaciones funciona sin tocar nada, y los ejemplos oficiales muestran uno de cada tipo.

Si tu agente tiene más de veinte herramientas, mide los tokens del catálogo antes de cambiar de protocolo: en esta prueba, con 200 herramientas, una pregunta costaba 38.684 tokens de entrada, y descubrirlas sobre la marcha lo dejaba en 2.100.

9. Enlaces y vídeos de interés

9.1 Artículos

9.2 Vídeos

Clase de Stanford (CS329Z): el mismo recorrido del post —el modelo elige la herramienta y el agente la ejecuta— con function calling y MCP en la misma pizarra. En inglés.

Taller completo de AI Engineer sobre agentes con MCP: presentación entre cliente y servidor, servidores y clientes en vivo. Largo, pero es el que mejor muestra el protocolo funcionando. En inglés.

Montar un servidor MCP en Python y conectarlo a un cliente, paso a paso. Complementa la sección 5 con lo que el código no muestra: qué se ve al arrancarlo. En inglés.

  1. Al cambio de referencia del BCE del 13 de noviembre de 2026, 1 dólar = 0,905 €. DeepSeek publica 0,15 dólares fuera de hora punta y 0,30 dólares en hora punta por millón de tokens de entrada sin caché. ↩︎

Esta entrada está licenciada bajo CC BY 4.0 por el autor.