Las herramientas nos facilitan la vida. Desde las lanzas que usaron nuestros antepasados hasta las computadoras que utilizamos para escribir este blog, las herramientas son una parte central de nuestra evolución como especie. Del mismo modo, esta misma afirmación sigue siendo válida para los modelos de grandes lenguajes (LLM) y su evolución reciente, especialmente con la introducción del protocolo de contexto modelo. No hace mucho tiempo, empezamos a proporcionar a los LLM herramientas personalizadas, ampliando enormemente sus capacidades y cambiando el paradigma. Como resultado, pasamos de usar los LLM exclusivamente para generar texto a darles la capacidad de realizar acciones y, por lo tanto, convertirlos en agentes autónomos. La búsqueda en la web, la ejecución de código y las interacciones con bases de datos, entre muchos otros, se encuentran en muchos de los agentes disponibles en el mercado.

Los primeros días del desarrollo de Agents implicaron la implementación de herramientas desde cero. Esto obligó a los desarrolladores a crear una gran cantidad de código estándar para sus propias herramientas y a adaptar el código al mecanismo de uso de las herramientas de cada proveedor, ya se tratara de las llamadas a funciones de OpenAI, las herramientas de CrewAI, las herramientas de LangChain o cualquier otra herramienta disponible. En consecuencia, en este contexto de prácticas no estandarizadas, Anthropic introdujo el Model Context Protocol (MCP), un estándar diseñado para poner orden en el caos.

Para aclarar, Anthropic presentó el Model Context Protocol (MCP), un estándar diseñado para dar coherencia al uso de las herramientas en diferentes plataformas. En este blog, analizaremos el protocolo Model Context y veremos cómo puede simplificar el desarrollo de sus propios agentes. Además, mostraremos cómo crear un servidor MCP básico para alimentar sus herramientas personalizadas es más fácil de lo que piensa.

¿Qué es el Model Context Protocol?

En primer lugar, para explicar qué es MCP, tomemos prestada la definición del sitio web oficial del protocolo:

El Model Context Protocol (MCP) es un protocolo abierto que permite una integración perfecta entre las aplicaciones de LLM y las fuentes y herramientas de datos externas. Ya sea que esté creando un IDE basado en inteligencia artificial, mejorando una interfaz de chat o creando flujos de trabajo de IA personalizados, MCP proporciona una forma estandarizada de conectar los LLM con el contexto que necesitan.

El equipo de MCP

Github

Suena increíble, ¿verdad? Bueno, lo es.

En pocas palabras, MCP se encarga de poner a disposición de los agentes recursos comunes de una manera amigable con la LLM, sin preocuparse por qué proveedor o vendedor de LLM está accediendo a ellos. Del mismo modo, del mismo modo que el USB-C estandariza la forma de conectar cualquier cosa a los ordenadores, MCP estandariza la forma de conectar los recursos a los agentes: a través de los servidores MCP.

Pero, ¿qué son los recursos? ¿No hablábamos de herramientas? En realidad, las herramientas son solo una cara de la historia. De hecho, el protocolo está diseñado para proporcionar una solución integral para todas las cosas habituales que queremos ofrecer a un agente: documentos, registros, imágenes, instrucciones, herramientas disponibles y más.

Estos servidores pueden ser creados por usted, para su propio uso, o pueden ser creados por un tercero. En cualquier caso, el concepto principal detrás de este protocolo es crear un entorno colaborativo para el desarrollo de agentes. Por ejemplo, imagine que un equipo o un desarrollador individual crea, prueba y mantiene un servidor MCP que puede usar en sus agentes. Luego, si el contenido o el formato de los recursos cambian, o si las funciones se amplían, basta con actualizar al servidor más reciente, lo que evita tener que preocuparse por los detalles de bajo nivel de cada implementación.

¿Cómo uso los servidores MCP con mi agente?

Antes de comenzar, definamos algunos conceptos clave:

• Anfitrión: Su agente personalizado o aplicación impulsada por LLM. También puede ser una aplicación o un IDE, como Cursor o Claude Desktop.
• Cliente: Responsable de mantener las conexiones 1:1 con los servidores, dentro de la aplicación host.
• Servidor: Proporcione contexto, herramientas e indicaciones a los clientes.

Con eso fuera del camino, exploraremos lo que necesitamos para que las cosas funcionen.

Estudio de caso: Supongamos que estamos desarrollando un sistema que se ocupa de los datos financieros relacionados con una empresa y sus filiales, y queremos crear un agente que pueda explorar la base de datos principal de Postgres de nuestra aplicación y proporcionarnos información útil para el equipo financiero. Vamos a crearlo con MCP.

Paso 1: Obtener los servidores

El primer paso es encontrar los servidores que nos gustaría usar en nuestro agente. Puedes crear los tuyos propios para tus herramientas y recursos personalizados, y lo haremos más adelante en el blog, pero por ahora nos centraremos en los de terceros. Hay muchas maneras de encontrar servidores MCP, pero nuestras favoritas son Mercado MCP y Servidores MCP.

Esta página es un catálogo actualizado de los servidores MCP más interesantes disponibles. Por un lado, están los servidores oficiales desarrollados directamente por los propios proveedores de recursos (Slack, AWS, Playwright y muchos más). Por otro lado, encontrarás los no oficiales, creados por los usuarios.

Durante la búsqueda, es posible que la mayoría de los servidores mencionen IDEs de escritorio o clientes como Claude Desktop o Cursor. No te preocupes por eso, también podemos usarlos con nuestros agentes de Python personalizados fuera de un entorno de desarrollo.

Alternativas de interacción

Los servidores vienen en dos tipos, según cómo se comuniquen con los clientes:

• Estudio O: Para empezar, se ejecutan localmente como ejecutables y se comunican directamente con el servidor a través de entrada/salida estándar. Por lo general, se distribuyen como paquetes de Node.js y se administran mediante npm. Esta es la versión original, lanzada inicialmente por Anthropic.
• SSE: Por el contrario, pueden ejecutarse de forma local o remota como servidores HTTP mediante eventos enviados por el servidor (SSE), lo que permite la comunicación con el cliente a través de ese protocolo. Suelen ser aplicaciones de Python, pero se puede utilizar cualquier backend capaz de gestionar el SSE. Se trata de un tipo más nuevo y no tan extendido, pero es la clave para proporcionar acceso remoto a los servidores MCP a los usuarios finales distribuidos.

Ahora, volvamos a nuestro agente financiero. Como se mencionó anteriormente, la información de la empresa se almacena en la base de datos PostgreSQL. En ese caso, podemos usar el Servidor Postgres proporcionado por el equipo oficial de MCP a agénicamente interactuar con nuestros datos. Esto permitirá al agente ver los esquemas de tablas y ejecutar consultas SQL de solo lectura, ¡sin necesidad de implementarlas!

Paso 2: configurar un cliente

Nuestro anfitrión necesita un cliente MCP para poder conectarse a los servidores. Si utilizas una aplicación basada en un LLM como Cursor, no dudes en saltarte esta parte, ya que la mayoría de ellas ya la incluyen (si no, reza para que los desarrolladores la añadan lo antes posible). Para la ruta de agente más personalizada, tenemos dos opciones: definitivamente podríamos crear la nuestra propia, siguiendo las instrucciones del protocolo guía, pero también podemos usar uno de los muchos marcos de Agent que lo admiten, como el ADK de Google o el Agent SDK de OpenAI.

Crearemos un agente de muestra con el SDK de Agent:

de agentes importar Agente

agent=agente (

name="Analizador de datos»,

instructions="Usted es un agente de análisis financiero responsable de recuperar y analizar los datos financieros y operativos de Wayne Industries desde una base de datos PostgreSQL. Utilice las herramientas disponibles para completar sus tareas de manera eficiente y precisa»,

mcp_servers= [servidor_postgresado]

)

Hecho, es bastante sencillo, ¿no? Ahora solo necesitamos servidor_postgres variable para apuntar al servidor real.

Paso 3: Conectar el cliente y el servidor

Este procedimiento variará en función del tipo de servidor al que quiera conectarse y del cliente. Sin embargo, por motivos de simplicidad, utilizaremos nuestro agente ficticio para ilustrar el procedimiento.

Los servidores StdIO vienen con un comando de consola como forma de funcionar. Por ejemplo, para nuestro servidor postgres tenemos:

npx -y @modelcontextprotocol /server-postgres postgresql: //localhost/mydb? usuario=otro&contraseña=secreto

Si descomponemos este comando, podemos extraer la siguiente información del paquete:

• Gestor de paquetes: npx
• Nombre: @modelcontextprotocol /server-postgres
• Args: postgresql: //localhost/mydbuser=other&password=secret (la cadena de conexión)

La mayoría de los servidores MCP siguen esta estructura, pero es posible que deba consultar la documentación de cada servidor para aclarar cualquier duda.

Los servidores SSE se conectan directamente con una URL. Por ejemplo, si lanzara uno en localhost, en el puerto 42, la URL de conexión sería:

http://localhost:42/sse

En lo que respecta al SDK del agente, se definen dos clases por separado para cada tipo de servidor, MCP Servers Studio y Servidores MCP See. A continuación se muestra el código para conectarse a cada uno de nuestros servidores.

de agentes.mcp importar MCPServers, MCPServerStdio

servidor_postgres= esperar Servidor MCP Studio (

parámetros = {

«comando»: «npx»,

«args»: [» -y» "@modelcontextprotocol /server-postgres «, «postgresql: //localhost/mydb? usuario=otro&contraseña=secreto "],

}

)

servidor_personalizado = esperar Servidores MPC (

name="Servidor Python SSE»,

parámetros = {

«url»: "http://localhost:42/sse «,

})

Al usar estas clases, puede empezar a aprovechar el mundo de servidores disponibles, ya sea StdIO o SSE.

Paso 4: Uso del servidor

Aunque este paso ocurre internamente en los agentes, podemos echar un vistazo al interior. Algunas de las funcionalidades que el servidor pone a disposición del agente son:

Herramientas

Se trata de funciones de código que el cliente puede ejecutar en el servidor, que puede conectarse a fuentes externas, bases de datos, API, etc. El agente elige cuándo usarlas y los argumentos con los que las llama. En concreto, los dos tipos de herramientas más básicos son:

• Listar herramientas: proporcione descripciones sobre las herramientas disponibles y sus firmas (parámetros).
• Ejecutar herramientas: permite al cliente ejecutar las herramientas de la lista.

Recursos de archivos

Para empezar, los recursos de archivo incluyen cualquier recurso de solo lectura que queramos proporcionar como contexto para el agente, normalmente insertado como parte del mensaje.

• Lista de recursos: proporciona descripciones de todos los archivos disponibles.
• Leer recurso: devuelve el archivo de recursos.

Indicaciones

Después de eso, las instrucciones definen plantillas de mensajes reutilizables para guiar las interacciones de LLM con los argumentos, que normalmente se utilizan en las GUI para interacciones fijas.

• Listar solicitudes: proporciona descripciones de las solicitudes disponibles y sus argumentos.
• Rellenar mensaje: permite al cliente rellenar un mensaje y devolver su texto completo.

Por último, en el caso de nuestro kit de herramientas Postgres, viene con dos funcionalidades

• Obtenga el esquema, como Recurso de archivo.
• Consulta, como Herramienta.

Perfecto, entonces tenemos que pasar la consulta como una herramienta a nuestro agente e insertar el esquema contexto como parte del mensaje. Sin embargo, si echamos un vistazo a la documentación del SDK de Agents, solo vemos menciones a las herramientas, ¿es extraño, verdad? ¿Qué pasa con el ADK o Langgraph de Google?

Bueno, después de profundizar, parece que el apoyo al MCP (en mayo de 2025) es dispar:

FrameworkTools Recursos de archivosPromptsAgents SDK ✅❌❌ Google ADK ✅❌❌ Langgraph ✅✅✅Adopción de las funcionalidades de MCP

Podríamos cambiar de marco, ya que ahora mismo nuestra base de código es bastante pequeña, sin embargo, eso no sería divertido. Hay otra forma de resolver eso, podemos ampliar la clase MCP de Open AI para añadir un lista_recursos y obtener_recurso. Bajo el capó, utiliza el SDK oficial de mcp python y su objeto de sesión de cliente, por lo que podemos hacerlo con unas pocas líneas de código.

de agentes.mcp importar MCP Servers Studio

clase MCPServerStdio extendido (MCPServerStdio):

def __init__ (self, *args, **kwargs):

súper (). __init__ (*args, **kwargs) # Inicializa la clase principal

asincrónico def list_resources (propio):

regresar esperar self.session.list_resources ()) .recursos

def get_resource (self, uri):

regresar esperar self.session.read_resource (uri) .content

Ahora probémoslo si ejecutamos el servidor, enumeramos los recursos y obtenemos la siguiente respuesta:

Recursos de servidor local: [Resource (URI=anyURL ('postgres: //localhost/last_quarter_subsidiary_financials/schema'), name='"esquema de base de datos last_quarter_subsidiary_financials», description=Ninguna, mimeType='Aplicación/JSON', tamaño=Ninguna, anotaciones=Ninguna)]

Nuestro código completo para el agente, para la consulta de prueba «Muéstreme las finanzas del último trimestre de las subsidiarias de Wayne Industries» tiene este aspecto:

importar asíncrono

importar os

importar envoltura de texto

asincrónico def principal ():

db = os.getenv («POSTGRES_DB»)

usuario = os.getenv («POSTGRES_USER»)

contraseña = os.getenv («POSTGRES_PASSWORD»)

connection_string = f"postgresql: //localhost/ {db}? usuario= {usuario} &contraseña= {contraseña}»

local_server = ExtendedMCPServerStdio (

name="Servidor Postgres»,

parámetros = {

«comando»: «npx»,

«argumentos»: [

«-y»,

"@modelcontextprotocol /server-postgres «,

f "{cadena de conexión}»,

],

},

)

asincrónico con servidor_local:

esquema = esperar local_server.get_resource («postgres: //localhost/last_quarter_subsidiary_financials/schema»)

prompt = textwrap.dedent (

f«" "Usted es un agente de análisis financiero responsable de recuperar y

analizar los datos financieros y operativos de Wayne Industries a partir de una base de datos PostgreSQL.

Usa las herramientas disponibles para completar tus tareas de manera eficiente y precisa»

El esquema de la base de datos es el siguiente:

{esquema} ""»

)

agente = Agente (

name="Asistente»,

instructions=prompt,

modelo = «gpt-4.1",

mcp_servers= [servidor_local],

MODEL_SETTINGS=Configuración del modelo (tool_choice="auto»),

)

resultado = esperar Runner.run (agent, «Muéstrame las finanzas del último trimestre de las subsidiarias de Wayne Industries», context= {})

imprimir (result.final_output)

si __nombre__ == «__principal__»:

asyncio.run (principal ())

Cuando se ejecuta, el agente debe fluir de la siguiente manera:

Y como resultado, obtenemos:

Estas son las finanzas del último trimestre de las subsidiarias de Wayne Industries:

| Empresa | Ingresos | Ganancias | Current|

|----------|---------------|---------------|------|

| TechCorp | 5 000 000 | 1 200 000 | USD |

| Innovate Ltd | 4 200 000 | 1 000 000 | EUR |

| Soluciones globales | 3 000 000 | 800 000 | GBP |

| FutureWorks | 600 000 000 | 150 000 000 | JPY |

| EcoWorld | 2.500.000 | 600.000 | AUD |

¡Éxito, el agente vive! Pero parece que nuestro conglomerado multinacional no unifica la moneda en sus datos financieros, por lo que los resultados son más difíciles de interpretar. Para solucionar este problema, nos gustaría añadir nuevas herramientas para que el agente pueda realizar conversiones de divisas. Pasemos a la siguiente sección y añadamos esto.

Creación de su propio servidor MCP

Para el propósito de nuestro ejemplo de agente financiero, imaginemos que necesitamos las siguientes capacidades:

• En cualquier momento, queremos recuperar el tipo de cambio entre dos monedas diferentes.
• También queremos poder convertir cualquier cantidad de dinero de una moneda determinada a otra diferente.
• Imaginemos también que solo se admite un subconjunto de monedas.

Con esto en mente, estamos listos para construir nuestro nuevo servidor, comenzaremos por crear algunas funciones auxiliares.

importar json

importar finanzas tan yf

def available_currencies () -> dictado:

con abrir («currencies.json», «r») tan archivo:

currencies = json.load (archivo)

regresar monedas

def fx_rate (desde_currency: str, a_currency: str) -> float:

monedas = divisas_monedas disponibles ()

si from_currency.upper () no en monedas o to_currency.upper () no en monedas:

subir ValueError (f"Código de divisa no válido: {from_currency} o {to_currency}»)

ticker = f "{from_currency.upper ()} {to_currency.upper ()} =X»

datos = yf.Ticker (ticker)

fx_data = data.history (período = «1d»)

si fx_data.vacío:

subir ValueError (F «No se pudo obtener el tipo de cambio de {from_currency} a {to_currency}»)

rate = fx_data ['Cerrar'] .iloc [-1]

regresar tasa

def currency_conversion (cantidad: flotante, from_currency: str, to_currency: str) -> float:

tasa = fx_rate (desde_divisa, a_divisa)

converted_amount = importe * tasa

regresar cantidad_convertida

Imagina también que currencies.json incluye algo como lo siguiente:

{

«USADO»: «Dólar estadounidense»,

«EURO»: «Euro»,

«GBP»: «Libra esterlina británica»,

«JPY»: «Yen japonés»,

«CHF»: «Franco suizo»,

«CANALLA»: «Dólar canadiense»,

«AYUDA»: «Dólar australiano»,

«NZD»: «Dólar neozelandés»,

«CNY»: «Yuan chino»

}

Esto servirá como el conjunto «estático» de monedas admitidas. Con estas funciones auxiliares, estamos listos para construir el servidor. Además, para los seguidores de Python, no hace mucho se lanzó una herramienta genial para construir servidores de forma pitónica, llamada FastMCP.

FastMCP nos permite declarar herramientas, recursos y consultas mediante una sintaxis de decorador, bastante similar a la forma en que se declaran las rutas HTTP en FastAPI. Siguiendo la sintaxis, este servidor simple sería algo así, ten en cuenta que proporcionar una buena descripción de las herramientas y los recursos es fundamental en este escenario:

desde fastmcp importar FastMCP

# Crear una instancia de servidor

mcp = FastMCP (

name="FXCalculatorServer»,

)

@mcp .resource («config: //monedas»)

def get_available_currencies () -> lista [str]:

«»

Busca todas las monedas disponibles, sus cotizaciones y nombres.

«»

regresar divisas_disponibles ()

@mcp .herramienta ()

def get_fx_rate (from_currency: str, a_currency: str) -> float:

«»

Obtiene el tipo de cambio actual de Yahoo Finance de from_currency a to_currency.

Las divisas deben proporcionarse como tickers, tal y como se puede encontrar en la fuente get_available_currencies ().

«»

regresar fx_rate (desde_divisa, a_divisa)

@mcp .herramienta ()

def convert_currency (cantidad: flotante, from_currency: str, to_currency: str) -> float:

«»

Convierte una cantidad determinada de una divisa a otra utilizando el tipo de cambio más reciente.

Las divisas deben proporcionarse como tickers, tal y como se puede encontrar en la fuente get_available_currencies ().

«»

regresar currency_conversion (importe, desde_divisa, a_divisa)

mcp.run ()

¡Y eso es todo! Estamos listos para implementar nuestro servidor e introducirlo en nuestro agente. Usaremos el SSE como capa de transporte en este ejemplo:

fastmcp run src/server/app.py --transport sse --port 9000

Ahora, podemos agregar un nuevo cliente y enviar ambos kits de herramientas a nuestro agente.

## conexión al servidor local

...

###

servidor_remoto = MCPServersSE (

name="Servidor Python SSE»,

parámetros = {

«url»: "http://127.0.0.1:9000/sse «,

})

asincrónico con servidor_local, servidor_remoto:

## creación de solicitudes

...

###

agente = Agente (

name="Asistente»,

instructions=prompt,

modelo = «gpt-4.1-2025-04-14",

mcp_servers= [servidor_local, servidor_remoto],

MODEL_SETTINGS=Configuración del modelo (tool_choice="auto»),

)

Y ahora lo probamos con el mensaje «Muéstreme las finanzas del último trimestre de las subsidiarias de Wayne Industries, todas en USD»,Veremos que el agente consulta los datos como antes y, a continuación, aplica las conversiones de divisas para generar el resultado final:

Estos son los datos financieros del último trimestre por Filiales de Wayne Industries, todos los importes convertidos a USD:

| Filial | Ingresos (USD) | Ganancia (USD) |

|--------------------------------------------|-----------------|

| TechCorp | 5.000.000,00$ | 1.200.000,00$ |

| Innovate Ltd | 4.699.563,50$ | 1.118.943,69$ |

| Soluciones globales | 3.982.212,78$ | 1.061.923,41$ |

| FutureWorks | 4.112.941,49$ | 1.028.235,37$ |

| EcoWorld | 1.600.194,57$ | 384.046,70$ |

¡Funciona a las mil maravillas!

Si quieres echar un vistazo, puedes encontrar el repositorio completo aquí: https://github.com/marvik-ai/mcp-financial-agent

Reflexiones finales

A lo largo de este blog, exploramos qué son los servidores MCP a un alto nivel y, luego, vimos que es bastante sencillo implementar una solución personalizada como servidor MCP para ampliar las capacidades de nuestros propios agentes. Sin embargo, está claro que la filosofía principal detrás de esta tecnología es estandarizar la forma en que conectamos a los agentes con las herramientas y los recursos, con el objetivo final de reutilizar los servidores ya existentes.

Además, también comprobamos que actualmente los marcos más comunes para desarrollar agentes «admiten» a MCP. Sin embargo, no están lo suficientemente maduros como para aprovechar al máximo todo el potencial del MCP, además de utilizar herramientas. En última instancia, solo el tiempo dirá si esta tecnología se convierte en un estándar global en la comunidad de IA, pero por el momento parece bastante prometedora.

Referencias

• Protocolo de contexto del modelo de Anthropic
• FastMCP: La forma rápida y pitónica de crear servidores y clientes MCP.
• ¿Qué es el MCP? Descripción general del protocolo de contexto modelo
• Medio: Creación de servidores MCP

‍