Hola, estoy iniciando con MCP, comparto la siguiente imagen que cree para ir entendiendo conceptos
!MCP_Server_Client
¿Cómo conectas un cliente MCP con un servidor que ya expone recursos y herramientas? Aquí aprendes a construir ese cliente en Python para consumir lo que el servidor ofrece, pensado para quien ya desplegó un servidor MCP y quiere cerrar el ciclo de comunicación.
Un servidor por sí solo no sirve de mucho si nadie consume lo que facilita. Por eso, después de tener un servidor con una herramienta y un recurso desplegados, el siguiente paso es crear a su media naranja: el cliente. Este cliente se encarga de consumir los recursos que el servidor pone a disposición.
¿Cómo organizas los archivos para un cliente MCP?
Todo empieza con el orden. Lo primero es crear una carpeta llamada clase cinco, escrita correctamente para que sea cómodo encontrarla dentro del repositorio.
Dentro de esa carpeta copias el mismo server.py que venías usando. ¿Por qué ahí mismo? Porque el cliente necesita ubicarlo para levantarlo. Luego creas un archivo nuevo: client.py, que será el corazón de esta comunicación [0:18].
¿Qué hace un cliente MCP? Se comunica con el servidor, consulta qué recursos y herramientas ofrece, y los ejecuta. Es el puente entre el servidor, que responde en un formato técnico, y el usuario final, que quiere respuestas legibles.
¿Qué necesitas importar para que el cliente hable con el servidor?
Dentro de client.py, lo primero es importar las bibliotecas de clases que harán posible la conexión.
Se importan ClientSession, StdioServerParameters y mcp.client.stdio. Estas dos sentencias de import permiten que el cliente se comunique con el servidor [0:55].
Después configuras los parámetros del servidor. Y aquí entra la lógica:
mcp.run y server.py.server.py dentro de la carpeta clase cinco.Con esos parámetros listos, ejecutas la función principal, la que inicializa la sesión de comunicación con el servidor. Al puro estilo de Python, usas una sentencia main para ejecutar esa función [1:38].
¿Cómo listas los recursos y herramientas del servidor?
Una vez que la sesión está inicializada y el servidor se comunica directamente contigo, quieres saber todo lo que ese servidor puede ofrecer.
Para eso agregas dos bloques dentro del método run: uno que enlista los recursos y otro que enlista las herramientas. No se verá tan pulido como en el inspector de MCP, sino de una forma más austera, pero cumple la misma función [2:30].
resources pides un listado de todos los recursos y los recorres con un for.tools y await session.list_tools obtienes el listado de herramientas, igual que aparecía en el inspector [3:14].print, ya sea print resource o print tool.Pero enlistar no es lo único interesante. También puedes leer un recurso directamente.
¿Cómo lees un recurso o ejecutas una herramienta desde el cliente?
Unas líneas más abajo agregas la opción de leer un recurso con session.read_resource, por ejemplo el recurso de saludo que ya sabes que existe en tu servidor.
Luego haces lo mismo con una herramienta. Tu servidor tiene una herramienta de suma, así que la llamas desde la sesión ya iniciada y le pasas dos parámetros, A y B, con los valores uno y siete. El cliente devuelve el resultado para mostrarlo en pantalla [4:20].
Un detalle importante: no agregas prompts porque el servidor no los tiene. Solo enlistas lo que realmente existe.
¿Por qué no necesitas ejecutar el servidor por separado?
Aquí viene lo interesante. Para probar todo, abres una nueva terminal, te mueves a la carpeta clase cinco y ejecutas python3 client.py.
No necesitas levantar el servidor manualmente. El cliente tiene la capacidad de levantar al servidor por sí mismo, así que basta con ejecutar el cliente [5:30].
Al presionar Enter ves el resultado: el listado de recursos, el listado de herramientas con add disponible, y la ejecución de esa herramienta.
¿Por qué el servidor devuelve un formato raro en vez de solo el número? Porque el servidor no habla humano. Sí ejecuta la operación, pero responde en un formato técnico. Si sumas uno y siete, el resultado real es ocho, pero viene envuelto en estructura adicional.
Como usuario final, a ti solo te interesa ese ocho. Y justamente para eso existe el cliente: para traducir esa respuesta cruda en algo útil.
¿Qué logras con esta interacción cliente-servidor?
Esta conexión entre las dos partes de un todo es lo que hace funcionar el protocolo.
Gracias a ella puedes:
¿Qué sigue después de conectar cliente y servidor? Poner un host al frente. Cuando agregas ese host, el resultado se muestra en combinación con el cliente de una forma mucho más visible para los usuarios.
Y así el servidor deja de ser un componente aislado para convertirse en algo consumible. ¿Ya probaste ejecutar tu propio client.py? Cuéntame en los comentarios qué resultado te devolvió.
¿Cómo conectas un cliente MCP con un servidor que ya expone recursos y herramientas? Aquí aprendes a construir ese cliente en Python para consumir lo que el servidor ofrece, pensado para quien ya desplegó un servidor MCP y quiere cerrar el ciclo de comunicación.
Un servidor por sí solo no sirve de mucho si nadie consume lo que facilita. Por eso, después de tener un servidor con una herramienta y un recurso desplegados, el siguiente paso es crear a su media naranja: el cliente. Este cliente se encarga de consumir los recursos que el servidor pone a disposición.
Todo empieza con el orden. Lo primero es crear una carpeta llamada clase cinco, escrita correctamente para que sea cómodo encontrarla dentro del repositorio.
Dentro de esa carpeta copias el mismo server.py que venías usando. ¿Por qué ahí mismo? Porque el cliente necesita ubicarlo para levantarlo. Luego creas un archivo nuevo: client.py, que será el corazón de esta comunicación [0:18].
¿Qué hace un cliente MCP? Se comunica con el servidor, consulta qué recursos y herramientas ofrece, y los ejecuta. Es el puente entre el servidor, que responde en un formato técnico, y el usuario final, que quiere respuestas legibles.
Dentro de client.py, lo primero es importar las bibliotecas de clases que harán posible la conexión.
Se importan ClientSession, StdioServerParameters y mcp.client.stdio. Estas dos sentencias de import permiten que el cliente se comunique con el servidor [0:55].
Después configuras los parámetros del servidor. Y aquí entra la lógica:
mcp.run y server.py.server.py dentro de la carpeta clase cinco.Con esos parámetros listos, ejecutas la función principal, la que inicializa la sesión de comunicación con el servidor. Al puro estilo de Python, usas una sentencia main para ejecutar esa función [1:38].
Una vez que la sesión está inicializada y el servidor se comunica directamente contigo, quieres saber todo lo que ese servidor puede ofrecer.
Para eso agregas dos bloques dentro del método run: uno que enlista los recursos y otro que enlista las herramientas. No se verá tan pulido como en el inspector de MCP, sino de una forma más austera, pero cumple la misma función [2:30].
resources pides un listado de todos los recursos y los recorres con un for.tools y await session.list_tools obtienes el listado de herramientas, igual que aparecía en el inspector [3:14].print, ya sea print resource o print tool.Pero enlistar no es lo único interesante. También puedes leer un recurso directamente.
Unas líneas más abajo agregas la opción de leer un recurso con session.read_resource, por ejemplo el recurso de saludo que ya sabes que existe en tu servidor.
Luego haces lo mismo con una herramienta. Tu servidor tiene una herramienta de suma, así que la llamas desde la sesión ya iniciada y le pasas dos parámetros, A y B, con los valores uno y siete. El cliente devuelve el resultado para mostrarlo en pantalla [4:20].
Un detalle importante: no agregas prompts porque el servidor no los tiene. Solo enlistas lo que realmente existe.
Aquí viene lo interesante. Para probar todo, abres una nueva terminal, te mueves a la carpeta clase cinco y ejecutas python3 client.py.
No necesitas levantar el servidor manualmente. El cliente tiene la capacidad de levantar al servidor por sí mismo, así que basta con ejecutar el cliente [5:30].
Al presionar Enter ves el resultado: el listado de recursos, el listado de herramientas con add disponible, y la ejecución de esa herramienta.
¿Por qué el servidor devuelve un formato raro en vez de solo el número? Porque el servidor no habla humano. Sí ejecuta la operación, pero responde en un formato técnico. Si sumas uno y siete, el resultado real es ocho, pero viene envuelto en estructura adicional.
Como usuario final, a ti solo te interesa ese ocho. Y justamente para eso existe el cliente: para traducir esa respuesta cruda en algo útil.
Esta conexión entre las dos partes de un todo es lo que hace funcionar el protocolo.
Gracias a ella puedes:
¿Qué sigue después de conectar cliente y servidor? Poner un host al frente. Cuando agregas ese host, el resultado se muestra en combinación con el cliente de una forma mucho más visible para los usuarios.
Y así el servidor deja de ser un componente aislado para convertirse en algo consumible. ¿Ya probaste ejecutar tu propio client.py? Cuéntame en los comentarios qué resultado te devolvió.
Hola, estoy iniciando con MCP, comparto la siguiente imagen que cree para ir entendiendo conceptos
!MCP_Server_Client
Para que el cliente pueda comunicarse con el servidor, el servidor debe estar disponible, pero no es necesario que esté corriendo de manera activa en el momento de la ejecución del cliente.
El cliente establece la comunicación utilizando una sesión de red que puede inicializarse a partir de la configuración previa del servidor. Esto permite que, cuando el cliente es ejecutado, se conecte y haga solicitudes al servidor, siempre y cuando el servidor esté configurado correctamente y en un estado accesible.
La interacción se realiza a través de peticiones y respuestas, donde el cliente utiliza funciones como session.list_resources() para obtener información del servidor. En resumen, el cliente actúa como intermediario, enviando solicitudes que se procesan cuando el servidor está disponible.
En el contexto de la creación de servidores inteligentes, un recurso se refiere a cualquier dato o servicio que el servidor ofrece, como información que puede ser consultada o utilizada. En cambio, una herramienta es una aplicación o funcionalidad que permite realizar tareas específicas, como operaciones matemáticas o manipulaciones de datos. Por ejemplo, en el transcript, se mencionan recursos como "saludo" y herramientas para realizar operaciones de suma.
Si quiero obtener datos desde una API, lo debería de hacer como una tool o un resource?
!Model Context Protocol (MCP) Explained - by Nir Diamant
from mcp import ClientSession, StdioServerParameters, types
from mcp.client.stdio import stdio_client
# Create server parameters for stdio connection
server_params = StdioServerParameters(
command="mcp", # Executable
args=["run", "server.py"], # Optional command line arguments
env=None, # Optional environment variables
)
async def run():
async with stdio_client(server_params) as (read, write):
async with ClientSession(
read, write
) as session:
# Initialize the connection
await session.initialize()
if __name__ == "__main__":
import asyncio
asyncio.run(run())
In the preceding code we've:
run that in turn calls stdio_client which starts a client session.run method to asyncio.run.lo que me doy cuenta es que en la respuesta del list resources no aparece el greetings, y en la llamada igual no respondió nada.
To invoke the features we need to ensure we specify the correct arguments and in some cases the name of what we're trying to invoke.
# Read a resource
print("READING RESOURCE")
content, mime_type = await session.read_resource("greeting://hello")
# Call a tool
print("CALL TOOL")
result = await session.call_tool("add", arguments={"a": 1, "b": 7})
print(result.content)
In the preceding code, we've:
greeting using read_resource.add using call_tool.# List available resources
resources = await session.list_resources()
print("LISTING RESOURCES")
for resource in resources:
print("Resource: ", resource)
# List available tools
tools = await session.list_tools()
print("LISTING TOOLS")
for tool in tools.tools:
print("Tool: ", tool.name)
Here we list the available resources, list_resources() and tools, list_tools and print them out.
asyncio in Python is a library designed for asynchronous programming, enabling you to write concurrent code using the async and await syntax. It is particularly useful for managing tasks that involve I/O-bound operations, such as network requests, file handling, or database queries, without blocking the execution of other tasks.
Rubén Orozco
Kevin Hernandez
Juan Jose Mayorga
Kevin Fiorentino
Fredy Reyes
Jeferson Stiven Parra Mahecha
Imagine Apps
Juan Morales
Andrea Alexandra Mora Vega
William Schnaider Torres Bermon
Brandon Sanchez
William Schnaider Torres Bermon
William Schnaider Torres Bermon
William Schnaider Torres Bermon
Jesús Ignacio García Fernández
Jhon Alexander Mosquera Vanegas
Juan Quevedo Sanchez
Nery Alberto Cano Ortigoza
Nery Alberto Cano Ortigoza
Nery Alberto Cano Ortigoza
Sander Álvarez Zuluga
DANIEL RUIZ
Amin Espinoza
ProfesorWilliam Schnaider Torres Bermon
Eduardo Rodriguez Cisneros
sebastián García
Hola, estoy iniciando con MCP, comparto la siguiente imagen que cree para ir entendiendo conceptos
!MCP_Server_Client
Se ve muy bueno! Gracias
Para que el cliente pueda comunicarse con el servidor, el servidor debe estar disponible, pero no es necesario que esté corriendo de manera activa en el momento de la ejecución del cliente.
El cliente establece la comunicación utilizando una sesión de red que puede inicializarse a partir de la configuración previa del servidor. Esto permite que, cuando el cliente es ejecutado, se conecte y haga solicitudes al servidor, siempre y cuando el servidor esté configurado correctamente y en un estado accesible.
La interacción se realiza a través de peticiones y respuestas, donde el cliente utiliza funciones como session.list_resources() para obtener información del servidor. En resumen, el cliente actúa como intermediario, enviando solicitudes que se procesan cuando el servidor está disponible.
El propio cliente de MCP se ocupa de correr el servidor cuando lo necesita, lo cual es genial, ni siquiera necesitas tener el VS Code abierto con el servidor o incluso puedes tener el código de forma remota en NPM.
En el contexto de la creación de servidores inteligentes, un recurso se refiere a cualquier dato o servicio que el servidor ofrece, como información que puede ser consultada o utilizada. En cambio, una herramienta es una aplicación o funcionalidad que permite realizar tareas específicas, como operaciones matemáticas o manipulaciones de datos. Por ejemplo, en el transcript, se mencionan recursos como "saludo" y herramientas para realizar operaciones de suma.
Si quiero obtener datos desde una API, lo debería de hacer como una tool o un resource?
Un tool, ya que es una aplicación o funcionalidad que permite realizar tareas específicas
y si esa api debe de tener un bearer token?
!Model Context Protocol (MCP) Explained - by Nir Diamant
from mcp import ClientSession, StdioServerParameters, types from mcp.client.stdio import stdio_client # Create server parameters for stdio connection server_params = StdioServerParameters( command="mcp", # Executable args=["run", "server.py"], # Optional command line arguments env=None, # Optional environment variables ) async def run(): async with stdio_client(server_params) as (read, write): async with ClientSession( read, write ) as session: # Initialize the connection await session.initialize() if __name__ == "__main__": import asyncio asyncio.run(run())
In the preceding code we've:
run that in turn calls stdio_client which starts a client session.run method to asyncio.run.lo que me doy cuenta es que en la respuesta del list resources no aparece el greetings, y en la llamada igual no respondió nada.
To invoke the features we need to ensure we specify the correct arguments and in some cases the name of what we're trying to invoke.
# Read a resource print("READING RESOURCE") content, mime_type = await session.read_resource("greeting://hello") # Call a tool print("CALL TOOL") result = await session.call_tool("add", arguments={"a": 1, "b": 7}) print(result.content)
In the preceding code, we've:
greeting using read_resource.add using call_tool.# List available resources resources = await session.list_resources() print("LISTING RESOURCES") for resource in resources: print("Resource: ", resource) # List available tools tools = await session.list_tools() print("LISTING TOOLS") for tool in tools.tools: print("Tool: ", tool.name)
Here we list the available resources, list_resources() and tools, list_tools and print them out.
asyncio in Python is a library designed for asynchronous programming, enabling you to write concurrent code using the async and await syntax. It is particularly useful for managing tasks that involve I/O-bound operations, such as network requests, file handling, or database queries, without blocking the execution of other tasks.
En el código se listan recursos y herramientas desde el cliente. Al ejecutarlo, el cliente solicita al servidor que le proporcione una lista de ambos. Los recursos son elementos accesibles desde el servidor, como funciones o datos, mientras que las herramientas son las utilidades que el servidor ofrece para realizar operaciones específicas. La salida muestra cada recurso y herramienta en un formato sencillo, permitiéndote ver qué puedes utilizar en tu aplicación. Esto asegura que el cliente pueda interactuar efectivamente con el servidor.
Me parece curioso que el cliente arranque el servidor por sí mismo y no haga falta dejarlo corriendo aparte.
me generaba un error por la tupla, aqui lo corrijo
import asyncio from mcp import ClientSession, StdioServerParameters from mcp.client.stdio import stdio_client # Configuración de los parámetros del servidor server_params = StdioServerParameters( command="mcp", args=["run", "server.py"], env=None, ) async def run(): async with stdio_client(server_params) as (read, write): async with ClientSession(read, write) as session: # Inicializar la sesión con el servidor MCP await session.initialize() # 1. LISTAR RECURSOS (Corregido para acceder a .resources) resources_result = await session.list_resources() print("LISTING RESOURCES") for resource in resources_result.resources: print(f"Resource: {resource.name} ({resource.uri})") # 2. LISTAR HERRAMIENTAS tools_result = await session.list_tools() print("\nLISTING TOOLS") for tool in tools_result.tools: print("Tool: ", tool.name) # 3. LEER RECURSO (Corregido: Maneja ReadResourceResult) print("\nREADING RESOURCE") try: resource_result = await session.read_resource("greeting://hello") for content_item in resource_result.contents: # Comprobar si el contenido es texto plano if hasattr(content_item, 'text') and content_item.text: print(f"Content:\n{content_item.text}") # Comprobar si es contenido binario (blob) elif hasattr(content_item, 'blob') and content_item.blob: print(f"Blob Content (Base64): {content_item.blob}") except Exception as e: print(f"Error reading resource: {e}") # 4. LLAMAR HERRAMIENTA print("\nCALL TOOL") try: result = await session.call_tool("add", arguments={"a": 1, "b": 7}) for content_item in result.content: if hasattr(content_item, 'text'): print(f"Result text: {content_item.text}") except Exception as e: print(f"Error calling tool: {e}") if __name__ == "__main__": asyncio.run(run())
¿Por qué la respuesta tiene formato extraño?
Porque los servidores MCP están diseñados para hablar con máquinas, no con humanos. El formato "extraño" que observas es típicamente un objeto estructurado que contiene metadatos vitales: estado de la ejecución, tipos de contenido y el resultado crudo.
Imagina que pides una pizza. El servidor no te entrega una rebanada servida en un plato de porcelana; te entrega una caja de cartón sellada con una etiqueta de ingredientes. Ese formato estructurado garantiza que cualquier cliente (sea un script de Python, una interfaz gráfica o un agente de Inteligencia Artificial) pueda procesar la información sin ambigüedades. Tu trabajo como desarrollador del cliente es extraer exclusivamente la "pizza" (el valor útil, como el resultado de una operación) y desechar la "caja" (los metadatos del protocolo) antes de mostrarle el resultado final al usuario. Utilizarás métodos de acceso a diccionarios o atributos de clase en Python para aislar exactamente el dato que necesitas renderizar.
¿Dónde encaja esto con un usuario final?
El cliente que acabas de construir es el motor invisible detrás de la interfaz de usuario. El usuario final nunca verá la terminal, ni los scripts de Python, ni los objetos de respuesta crudos.
En una aplicación real, este cliente se conecta a un Host (como una aplicación web, un bot corporativo o una interfaz de chat de IA). Cuando el usuario hace clic en un botón que dice "Calcular" o escribe una petición, el Host envía esa intención a tu cliente Python. Tu cliente traduce esa acción, despierta al servidor, ejecuta la herramienta necesaria, extrae el resultado limpio y se lo devuelve al Host. Finalmente, el Host muestra un mensaje amigable en pantalla. El cliente actúa como el traductor diplomático indispensable entre la interfaz visual que el usuario ama y la lógica profunda y estructurada que el servidor ejecuta en las sombras.
¿Cómo levanta el cliente al servidor directamente?
El cliente utiliza un canal de comunicación estándar llamado STDIO (Standard Input/Output) para despertar al servidor. Piensa en esto como si el cliente fuera un director de orquesta que llama a un músico específico a la tarima. En lugar de requerir que el servidor esté ejecutándose en un puerto de red (como un servidor web tradicional), el cliente ejecuta el archivo server.py como un subproceso utilizando los parámetros de configuración adecuados.
Esto significa que el ciclo de vida del servidor está completamente atado al cliente. Cuando el cliente inicia, el servidor nace; cuando el cliente termina su ejecución, el servidor se apaga automáticamente. Para lograr esto en código, configuras los parámetros indicando el comando base y el archivo objetivo. Es una arquitectura sumamente eficiente para herramientas locales, ya que evita conflictos de puertos y reduce el consumo de memoria en tu máquina al no tener procesos fantasma corriendo en segundo plano.
Creamos un cliente en Python para comunicarnos con el servidor MCP. Aprendimos a importar componentes, inicializar la sesión, enlistar recursos y herramientas, y ejecutar funciones del servidor directamente desde el cliente, Sander.
En el minuto 6:10 dice los recursoso mostrados, PERO esos no son los recursos q estan definidos en el server.py..... no entendi esa parte
Excelente observación! Lo que tú estás viendo aquí son los recursos obtenidos por medio del cliente pero que se encuentran disponibles en el servidor. Es ahí donde están los recursos que mencioné.
What goes into writing a client?
To write a client, you'll need to do the following:
Pues seguí todas las indicaciones y no jala:
Asegurate de estar en la carpeta donde se creo el venv. En este caso "demo-mcp-server" y que este activo ese entorno virtual .venv.
Para ejecutarlo usa python client.py en vez depython3 client.py.
A mi me funciono asi