Estamos al borde de un nuevo tipo de software. En su reciente keynote en YC Startup School, Andrej Karpathy describió el Software 3.0, un mundo donde el lenguaje natural se convierte en la interfaz de programación principal, y los grandes modelos de lenguaje sirven tanto como motores de cómputo como colaboradores autónomos.
A diferencia del Software 1.0, donde los desarrolladores escribían instrucciones explícitas, o del Software 2.0, donde las redes neuronales aprendían patrones a partir de datos, el Software 3.0 funciona con lenguaje natural. Nuestros prompts se convierten en programas, y los LLMs traducen nuestras intenciones en comportamiento ejecutable.
En este tutorial, construiremos un servidor MCP que proporciona acceso remoto a un sandbox de Novita AI donde nuestro agente de IA puede ejecutar código de forma segura. El agente en sí se creará con la librería mcp-use, que también gestiona automáticamente la comunicación con el servidor MCP.
¿Qué es MCP (Model Context Protocol)?
El Protocolo de Contexto de Modelo (MCP) es un estándar abierto desarrollado por Anthropic para que los modelos de IA se comuniquen con servicios, herramientas y fuentes de datos externos. Piénsalo como un “USB-C para la IA”; proporciona una interfaz estándar entre los agentes y el mundo exterior.
Los tres componentes principales:
- Herramientas: Funciones/APIs invocables que expone el servidor (por ejemplo, navegación web, ejecución de código).
- Recursos: Datos externos proporcionados por el servidor, generalmente destinados como contexto para el agente de IA (por ejemplo, archivos, metadatos, conjuntos de datos).
- Prompts: Estas instrucciones detalladas están destinadas a guiar el comportamiento del agente al interactuar con las herramientas o recursos anteriores.
Para una mirada más profunda a MCP, su arquitectura y componentes, consulta nuestro blog sobre cómo construir tu primer servidor MCP
Por qué MCP es importante para la integración de herramientas de IA
MCP establece una comunicación bidireccional entre los agentes de IA y los sistemas externos. Esto facilita “conectar” los LLMs a herramientas personalizadas, reduciendo el trabajo de integración y minimizando la posibilidad de errores.
Introducción a la librería mcp-use
La librería mcp-use es un paquete de Python que simplifica la construcción de agentes de IA que interactúan con servidores MCP. Maneja la creación del agente y gestiona la comunicación con los servidores MCP para acceder a herramientas y fuentes de datos externas, permitiéndote centrarte solo en la lógica de tu aplicación.
Descripción general de Novita AI Sandbox y la API de modelos
Qué es un Sandbox y por qué es importante
Un sandbox es un entorno de ejecución seguro y aislado donde se puede ejecutar código no confiable sin afectar al sistema anfitrión. Básicamente es una computadora virtual liviana para que tu agente de IA ejecute código, comandos, cree archivos, etc.
Novita AI proporciona este sandbox en la nube para que tu agente acceda rápidamente bajo demanda, con facturación flexible por segundo según los recursos utilizados.
Características clave del sandbox de Novita:
- Aislamiento seguro: Cada sandbox obtiene su propio sistema de archivos y entorno aislados, protegiendo los datos y evitando interacciones no deseadas.
- Inicio rápido: Las instancias del sandbox se lanzan en un promedio de ~200 ms, lo que lo hace ideal para escenarios de baja latencia.
- Soporte multi-lenguaje: Puedes ejecutar código en múltiples lenguajes de programación, incluyendo Python, JavaScript, TypeScript y más.
- Pausa y reanudación rápida: Pausa el sandbox en cualquier momento y reanúdalo cuando sea necesario, con el sistema de archivos y el estado de los procesos completamente restaurados.
- Ejecución en segundo plano: Admite la ejecución de tareas en segundo plano y es adecuado para escenarios que requieren esperar un resultado.
API de modelos de Novita:
Novita ofrece una amplia biblioteca de modelos de IA de código abierto de laboratorios de investigación líderes como OpenAI, Google, DeepSeek, Qwen, etc. Estos incluyen modelos para lenguaje, visión, audio, video y embeddings. Nuestros modelos de lenguaje también son totalmente compatibles con el SDK de OpenAI, por lo que cambiar de OpenAI a Novita solo requiere actualizar la URL base y la clave API en tu cliente, y luego seleccionar un modelo de Novita.
| from openai import OpenAI client = OpenAI( base_url=“https://api.novita.ai/v3/openai”, api_key=“ ) |
Configuración de tu entorno de desarrollo
Para comenzar, clonaremos el repositorio de GitHub, configuraremos un entorno Python limpio, instalaremos todas las dependencias necesarias y obtendremos las claves de Novita AI.
Clonar el repositorio de GitHub e instalar las dependencias con uv.
1. Instala uv (un gestor de paquetes Python ligero)
| pip install uv |
2. Clona el repositorio (repositorio de GitHub) y navega hacia él.
| git clone https://github.com/Studio1HQ/mcp\_remote\_execution.git cd mcp_remote_execution |
3. Crea y activa el entorno virtual de uv
| # Crea un entorno virtual uv venv # Activa el entorno virtual source .venv/bin/activate # Para Mac/Linux # o .venv\Scripts\activate # Para Windows |
4. Instala las dependencias del proyecto
| # Instala las dependencias uv sync |
Crear una cuenta de Novita AI y obtener una clave API
1. Regístrate en novita.ai.
2. En el panel de control, coloca el cursor sobre el icono de perfil de usuario y haz clic en API Keys en la ventana emergente.
3. En la página de Gestión de Claves, haz clic en Add New Key. En la ventana emergente, ingresa un nombre para tu clave, haz clic en Confirm, y luego copia la clave generada.
4. Ahora, dentro del directorio del proyecto, crea un archivo .env y pega lo siguiente.
| NOVITA_API_KEY=“<PEGA TU CLAVE API DE NOVITA AQUÍ>” NOVITA_BASE_URL=“https://api.novita.ai/v3/openai” NOVITA_E2B_DOMAIN=“sandbox.novita.ai” NOVITA_E2B_TEMPLATE=“code-interpreter-v1” |
Agregar créditos a la cuenta de Novita AI.
Para usar el sandbox de Novita, necesitas agregar créditos a tu cuenta. En la pestaña del panel de control, haz clic en ‘Billing’. Luego, en la página de facturación, agrega un método de pago y recarga al menos $10 en créditos.
Construyendo el servidor MCP y la integración del agente de IA
Ahora que nuestro entorno está configurado, comencemos a construir. Este proceso tendrá dos partes: primero, repasaremos la creación del servidor MCP, y luego construiremos la aplicación del agente de IA (que actúa como el cliente MCP). Pero antes de comenzar, creemos el gestor de sandbox que usará el servidor MCP.
El Gestor de Sandbox
Este será responsable de iniciar y detener las instancias del sandbox. En nuestra configuración, restringiremos el servidor a una sola instancia de sandbox a la vez. El Gestor de Sandbox también se encargará de ejecutar código Python y comandos de shell en el sandbox.
Primero, en sandbox_manager.py, tenemos la clase SandboxManager, que toma los siguientes parámetros:
- sandbox_template: La plantilla utilizada para crear una instancia de sandbox. Usaremos “code-interpreter-v1”, que viene preinstalado con paquetes de Python de uso común (por ejemplo, pandas, numpy).
- sandbox_domain: El endpoint del dominio utilizado para conectarse a la instancia del sandbox de Novita AI.
- sandbox_timeout: La duración (en segundos) que determina cuánto tiempo permanece activo el sandbox antes de ser terminado automáticamente.
| from novita_sandbox.code_interpreter import Sandbox class SandboxManager: def __init__( self, sandbox_template: str, sandbox_domain: str, sandbox_timeout: int, ): self.sandbox_template = sandbox_template self.sandbox_domain = sandbox_domain self.sandbox_timeout = sandbox_timeout |
Ahora agregaremos métodos para crear y detener un sandbox.
- Para la creación, tomamos una sandbox_api_key, la usamos para iniciar una nueva instancia de sandbox para el usuario, y devolvemos un mensaje de éxito con el ID del sandbox o un mensaje de excepción si algo sale mal.
- Para detener, tomamos tanto la sandbox_api_key como el sandbox_id, nos conectamos al sandbox y lo detenemos si existe. Al igual que antes, devolvemos un mensaje de éxito o un mensaje de excepción según el resultado.
| … class SandboxManager: … # código existente debajo def create_sandbox_session(self, sandbox_api_key: str) -> str: “”“ Esto creará una nueva instancia de sandbox. Args: sandbox_api_key (str): La clave API para el sandbox. Returns: str: Mensaje de éxito con el ID del sandbox del nuevo sandbox o mensaje de error. ”“” try: # crea el nuevo sandbox sandbox = Sandbox.create( template=self.sandbox_template, api_key=sandbox_api_key, domain=self.sandbox_domain, timeout=self.sandbox_timeout, ) return f"Sandbox creado exitosamente. ID del Sandbox: {sandbox.sandbox_id}“ except Exception as e: return f"Error al crear nuevo sandbox:{str(e)}” def stop_sandbox_session(self, sandbox_api_key: str, sandbox_id: str) -> str: “”“ Esto eliminará una instancia de sandbox si existe. Args: sandbox_api_key (str): La clave API para el sandbox. sandbox_id (str): El ID del sandbox. Returns: str: Mensaje de éxito con el ID del sandbox eliminado o mensaje de error. ”“” try: # conectar al sandbox sandbox = Sandbox.connect( api_key=sandbox_api_key, sandbox_id=sandbox_id, ) sandbox.kill() return f"Sandbox ID {sandbox_id} eliminado exitosamente" except Exception as e: return f"Error al eliminar Sandbox ID: {sandbox_id}\ {str(e)}" |
Finalmente, agregamos métodos para ejecutar código Python y comandos de shell en el sandbox de un usuario después de conectarnos a él mediante la clave API y el ID. Todos los resultados del sandbox (incluyendo excepciones y errores) se devuelven en un diccionario.
| … class SandboxManager: … # código existente debajo def run_python_code( self, python_code: str, sandbox_api_key: str, sandbox_id: str ) -> dict: “”“ Ejecuta el código Python en el sandbox; si hay salidas de imagen, se omiten. Args: python_code (str): El código Python a ejecutar. sandbox_api_key (str): La clave API para el sandbox. sandbox_id (str): El ID del sandbox. Returns: dict: Contiene stdout, logs, error, etc. ”“” try: # conectar al sandbox sandbox = Sandbox.connect( api_key=sandbox_api_key, sandbox_id=sandbox_id, ) execution = sandbox.run_code(python_code, language=“python”) return { # omitiremos las salidas de imagen. “outputs”: [result for result in execution.results if not result.png], “logs”: execution.logs, “error”: execution.error, } except Exception as e: return {“error”: str(e)} def run_on_command_line( self, command: str, sandbox_api_key: str, sandbox_id: str ) -> dict: “”“ Ejecuta el comando en el sandbox. Args: command (str): El comando a ejecutar. sandbox_api_key (str): La clave API para el sandbox. sandbox_id (str): El ID del sandbox. Returns: dict: Contiene la salida del comando y el error de ejecución si lo hay. ”“” try: # conectar al sandbox sandbox = Sandbox.connect( api_key=sandbox_api_key, sandbox_id=sandbox_id, ) result = sandbox.commands.run(command) return { “output”: { “stdout”: result.stdout, “stderr”: result.stderr, “exit_code”: result.exit_code, “error”: result.error, }, “execution error”: None, } except Exception as e: return {“output”: None, “execution error”: str(e)} |
Creando el servidor MCP
Ahora que el Gestor de Sandbox está configurado, es momento de trabajar en mcp_server.py. Primero, creamos una instancia de FastMCP, el framework que ejecutará el servidor, junto con un Gestor de Sandbox. También creamos una instancia de consola rich para una impresión hermosa en la terminal.
Nota: El tiempo de espera del sandbox (sandbox timeout) pasado al Gestor de Sandbox se usa para cada sandbox iniciado en este servidor. Es el tiempo máximo (en segundos) que cada sandbox puede permanecer activo (en ejecución), a menos que se detenga antes.
| import asyncio import os from dotenv import load_dotenv from mcp.server.fastmcp import Context, FastMCP from rich.console import Console from rich.panel import Panel from rich.table import Table from starlette.requests import Request from sandbox_manager import SandboxManager # cargar variables de .env load_dotenv() console = Console() # Inicializar servidor FastMCP mcp = FastMCP(“MCP_Server”) # Inicializar gestor de sandbox para la instancia única de sandbox. sandbox_manager = SandboxManager( sandbox_template=os.getenv(“NOVITA_E2B_TEMPLATE”), sandbox_domain=os.getenv(“NOVITA_E2B_DOMAIN”), sandbox_timeout=900, # 900 segundos (15 minutos), la instancia del sandbox se eliminará automáticamente después. ) |
Ahora, como necesitamos una clave API para conectarnos al sandbox de un usuario, la obtendremos de la solicitud del usuario al servidor. Como veremos más adelante en el cliente MCP, esta clave se enviará en el encabezado de autorización de cada solicitud. Eso significa que necesitamos una forma de extraer la clave API de este encabezado en el lado del servidor.
FastMCP proporciona un objeto Context que en tiempo de ejecución contiene información sobre el usuario que realiza la solicitud. Así que crearemos un método auxiliar get_user_api_key que toma un objeto de contexto, extrae la clave API del encabezado y la devuelve o lanza una excepción si falta.
| … # código existente debajo def get_user_api_key(ctx: Context) -> str: “”“ Devuelve la clave API del encabezado de la solicitud si existe; de lo contrario, lanza una excepción. ”“” request: Request = ctx.request_context.request # Acceder a los datos de la solicitud auth_header = request.headers.get(“Authorization”) if auth_header: auth_header = auth_header.split(" ")[1] if not auth_header: raise Exception(“Falta la clave API en el encabezado Authorization Bearer”) return auth_header |
Es hora de exponer prompts, herramientas y recursos en nuestro servidor. Para hacer esto, simplemente agregamos el decorador @mcp.{prompt, tool, resource}() a la función de Python. Comenzando con nuestro prompt, que devuelve instrucciones sobre cómo nuestro agente debe usar el sandbox.
| … # código existente debajo (Nota: los métodos auxiliares de visualización de la consola se omitieron por brevedad) @mcp.prompt() def instructions_for_sandbox_use() -> str: “”“ DEVUELVE INSTRUCCIONES DE LECTURA OBLIGATORIA PARA EL USO DEL SANDBOX. ”“” return “”“ Cuando quieras usar la función del sandbox, primero debes crear una nueva sesión de sandbox llamando a la función create_sandbox_session(). Luego puedes usar la función run_python_code() o run_on_command_line() para ejecutar en el sandbox. Cuando hayas terminado, debes eliminar la sesión del sandbox llamando a la función stop_sandbox_session(). Nota: - El sandbox ya viene preinstalado con los paquetes de análisis de datos habituales, pero si no estás seguro de que exista un paquete o tu código tuvo un error de importación debido a un paquete faltante, puedes verificar si está instalado y, si no, instalarlo. ”“” |
Para las herramientas, exponemos métodos que utilizan la instancia de sandbox_manager para crear, detener y ejecutar código o comandos en el sandbox de un usuario.
Nota: Entre los argumentos que toman los siguientes métodos de herramientas, incluiremos un ctx: Context. Esto le dice a FastMCP que inserte automáticamente el contexto de la solicitud en ese parámetro, un proceso conocido como inyección de dependencias. Luego obtenemos la clave API si existe pasando este contexto a nuestro método auxiliar (get_user_api_key).
| … # código existente debajo @mcp.tool() def create_sandbox_session(ctx: Context) -> str: “”“ Esto creará una instancia de sandbox y devolverá un mensaje de éxito con el ID del sandbox o un mensaje de error. ”“” try: return sandbox_manager.create_sandbox_session(get_user_api_key(ctx)) except Exception as e: return e @mcp.tool() def stop_sandbox_session(sandbox_id: str, ctx: Context) -> str: “”“ Esto eliminará una instancia de sandbox si existe. ”“” try: return sandbox_manager.stop_sandbox_session(get_user_api_key(ctx), sandbox_id) except Exception as e: return e @mcp.tool() def run_python_code(python_code: str, sandbox_id: str, ctx: Context) -> dict: “”“ Ejecuta el código Python en el sandbox; si hay salidas de imagen, se omiten. Args: python_code (str): El código Python a ejecutar. sandbox_id (str): El ID del sandbox. Nota: El ctx (Context) es un objeto de inyección de dependencias que se pasa automáticamente. Returns: dict: Contiene stdout, logs, error, etc. ”“” console.print( Panel( python_code, title=“Agente ejecutando código Python”, border_style=“blue”, ) ) try: result = sandbox_manager.run_python_code( python_code, get_user_api_key(ctx), sandbox_id ) # mostrar el resultado. Nota: solo hacer esto en pruebas, no en producción. display_sandbox_code_output(result) return result except Exception as e: return {“error”: str(e)} @mcp.tool() def run_on_command_line(command_line: str, sandbox_id: str, ctx: Context) -> dict: “”“ Ejecuta el comando en el sandbox. Args: command_line (str): El comando a ejecutar. sandbox_id (str): El ID del sandbox. Nota: El ctx (Context) es un objeto de inyección de dependencias que se pasa automáticamente. Returns: dict: Contiene la salida del comando y el error de ejecución si lo hay. ”“” console.print( Panel( command_line, title=“Agente ejecutando línea de comandos”, border_style=“blue”, ) ) try: result = sandbox_manager.run_on_command_line( command_line, get_user_api_key(ctx), sandbox_id ) # mostrar el resultado. Nota: solo hacer esto en pruebas, no en producción. display_sandbox_command_output(result) return result except Exception as e: return {“execution error”: str(e)} |
Ahora expondremos un único recurso para uno de nuestros escenarios de demostración, que veremos más adelante. Este recurso devuelve un simulacro del portafolio de acciones de un usuario. A diferencia de los prompts y las herramientas, los recursos requieren especificar una URL donde serán accesibles.
| … # código existente debajo @mcp.resource(“data://user_stock_portfolio”) def get_user_portfolio() -> dict: “”“ Devuelve las tenencias del portafolio del usuario en los principales ETFs de índices y acciones individuales. Returns: dict: Portafolio con símbolos de cotización, cantidades y precios de compra promedio ”“” portfolio = { “holdings”: [ # ETFs de índices principales { “ticker”: “SPY”, “name”: “SPDR S&P 500 ETF”, “quantity”: 4, “avg_purchase_price”: 670.13, “asset_type”: “ETF”, }, … # omitido por brevedad ] } return portfolio |
Finalmente, agregamos el código que inicia nuestro servidor. No usaremos el transporte MCP stdio porque la consola Rich imprime en la terminal, lo cual es una operación bloqueante que interferiría. En su lugar, usaremos el transporte MCP streamable-http (esto es lo que también usarás en producción, ya que es el más adecuado para la conexión remota entre cliente y servidor a través de HTTP).
| … # código existente debajo if __name__ == “__main__”: # ejecutar el servidor # Nota: Usamos streamable-http como protocolo de transporte en lugar de stdio porque estamos imprimiendo en la consola, lo que bloquearía stdio. # También en producción deberías usar SSE o streamable-http en lugar de stdio. asyncio.run(mcp.run(transport=“streamable-http”)) |
¡Vaya! Vamos a iniciar nuestro servidor MCP para obtener la URL en la que se ejecuta, que necesitaremos para conectar nuestro agente de IA. Ejecuta el siguiente comando en la terminal.
| uv run mcp_server.py |
Deberías ver el servidor ahora en ejecución. Toma nota de la URL en la que se ejecuta.
Integrando el Agente de IA con el Servidor MCP
Ahora comenzaremos a trabajar en el agente de IA en mcp_client.py. La librería mcp-use facilita este proceso. Primero, establecemos el nivel de depuración en INFO para ver lo que el agente está haciendo. En el método principal, creamos un diccionario de configuración para el cliente MCP. Este especifica los servidores MCP disponibles, usando un nombre (usé “stock&sandbox”) y la URL en la que se ejecuta el servidor MCP (recuerda agregar /mcp), también incluimos la clave API del usuario como valor para “auth”; esto será insertado automáticamente por mcp-use en el encabezado Authorization Bearer de cada solicitud.
Dado que mcp-use depende de langchain-openai, pasamos la URL base de Novita, la clave API y el nombre del modelo LLM, lo que funciona porque Novita es compatible con OpenAI.
Y además de la respuesta del agente, nos gustaría incluir el ID del sandbox que utilizó en el servidor, si lo hubiera (explicaremos por qué más adelante). Para ello, definiremos una clase Pydantic para representar nuestro formato de respuesta.
| import asyncio import os from datetime import datetime from typing import Optional import mcp_use from dotenv import load_dotenv from langchain_openai import ChatOpenAI from mcp_use import MCPAgent, MCPClient from pydantic import BaseModel, Field from rich.console import Console from rich.panel import Panel from rich.prompt import Prompt # Cargar variables de entorno load_dotenv() console = Console() # Nota: 1 para nivel INFO, 2 para nivel DEBUG completo y 0 para ninguna salida de depuración. mcp_use.set_debug(1) class ResponseFormat(BaseModel): response: str id_of_used_sandbox: Optional[str] = Field( …, description=“El ID del sandbox utilizado, si lo hay” ) async def main(model: str, base_url: str, api_key: str): # Crear diccionario de configuración config = { “mcpServers”: { “stock&sandbox”: { # Si la URL en la que se ejecuta el servidor MCP es diferente, reemplázala a continuación, # también recuerda agregar /mcp. “url”: “http://127.0.0.1:8000/mcp”, “auth”: api_key, } } } # Crear MCPClient a partir del diccionario de configuración client = MCPClient(config) # Crear LLM llm = ChatOpenAI(model=model, base_url=base_url, api_key=api_key) … |
Luego creamos el agente MCP pasando el LLM, el cliente MCP, el número máximo de pasos (que limita las acciones que el agente puede tomar antes de responder) y habilitando la memoria para que mcp-use maneje nuestro historial de conversación. También proporcionamos un prompt del sistema que incluye la fecha y hora actuales, junto con instrucciones personalizadas para usar el sandbox (agregué esto porque algunos modelos olvidan leer los prompts de instrucciones expuestos en el servidor).
Finalmente, configuramos el bucle de conversación estándar: obtener la entrada del usuario, pasarla a agent.run() e imprimir la respuesta. Si se utilizó un sandbox, creamos una sesión para llamar manualmente al método de detención en el servidor como medida de seguridad, en caso de que el modelo olvide cerrarlo.
| … async def main(model: str, base_url: str, api_key: str): … # código existente debajo # Crear agente con el cliente agent = MCPAgent( llm=llm, client=client, max_steps=25, memory_enabled=True, # mcp-use manejará automáticamente el historial de la conversación. system_prompt=f"“” Eres un asistente útil y la fecha actual es {datetime.now().strftime(‘%Y-%m-%d’)} DEBES RECORDAR: - Antes de cualquier llamada a herramienta, primero llama a instructions_for_sandbox_use() para que puedas leerlas. - Asegúrate de llamar a stop_sandbox_session() después de usar el sandbox antes de responder al usuario. “”“, ) console.print( Panel( ”[bold green]Sesión MCP iniciada[/bold green]\ Escribe ‘quit()’ para salir.“, title=“Sesión MCP”, border_style=“green”, ) ) while True: user_input = Prompt.ask(”\ [bold yellow]>>> Mensaje del usuario[/bold yellow]“) if user_input.lower().strip() == “quit()”: break # Pasa la consulta al agente y espera la respuesta. response_obj = await agent.run(user_input, output_schema=ResponseFormat) console.print( f”\ [bold green]>>> Respuesta del asistente: {response_obj.response} [/]" ) if response_obj.id_of_used_sandbox: # Forzará el cierre del sandbox en el servidor MCP si aún está activo. session = await client.create_session(“stock&sandbox”) await session.call_tool( name=“stop_sandbox_session”, arguments={“sandbox_id”: response_obj.id_of_used_sandbox}, ) await session.disconnect() |
Por último, agregamos el código que inicia el cliente:
| … # código existente debajo if __name__ == “__main__”: asyncio.run( main( model=“qwen/qwen3-coder-480b-a35b-instruct”, base_url=os.getenv(“NOVITA_BASE_URL”), api_key=os.getenv(“NOVITA_API_KEY”), ) ) |
Probar la ejecución de nuestro agente de IA MCP:
Puedes iniciar la aplicación del agente de IA ejecutando el siguiente comando en la terminal
| uv run mcp_client.py |
A continuación, se muestran enlaces de video de ejecuciones de demostración para los siguientes prompts:
- Prompt de usuario 1: “Tengo $2,000. Obtén el rendimiento de los principales índices bursátiles de EE. UU. desde yfinance durante los últimos 6 meses y ejecuta modelos de ML para predecir cómo asignar esta inversión para maximizar los rendimientos potenciales durante los próximos 2 meses.” (Insertar enlace aquí)
- Prompt de usuario 2: “Ejecuta múltiples simulaciones de un colapso económico de deflación en EE. UU., elige la más probable y explica el impacto que tendrá en mi cartera de acciones.” (Insertar enlace aquí)
Consejos para servidores MCP en producción
Si bien este tutorial se centró en construir un servidor MCP funcional con Novita Sandbox, el despliegue en producción requiere consideraciones adicionales:
Usa el transporte adecuado: Si bien “stdio” funciona para el desarrollo local, los servidores MCP de producción deben usar “streamable-http” para habilitar conexiones remotas, tal como lo hicimos anteriormente.
Implementa autenticación: Como hicimos anteriormente, asegúrate de proteger los endpoints de tu servidor MCP con autenticación. Asegúrate de que cada cliente solo tenga permiso para acceder a las herramientas y recursos que necesita. Puedes leer más sobre métodos de autenticación en Autenticación FastMCP
Habilita el registro (logging): Usa un logger para monitorear la actividad del servidor, depurar problemas y rastrear patrones de uso. Esto es vital para el mantenimiento y la resolución de problemas.
Límites de tasa y cuotas: Protege tu servidor del abuso implementando límites de tasa y cuotas. Esto es especialmente importante cuando se exponen herramientas que consumen muchos recursos.
Documentación y versionado: Mantén una documentación clara de la API de tu servidor MCP y el versionado para facilitar la integración a desarrolladores y LLMs.
Conclusión
¡Vaya! Finalmente puedes construir un servidor MCP donde los agentes de IA puedan ejecutar código de forma remota mediante instrucciones en lenguaje natural, una implementación práctica del Software 3.0 en acción.
En este tutorial, aprendiste a construir un servidor MCP con capacidad de ejecución de código, gestionar ciclos de vida de sandbox y crear un agente de IA usando mcp-use que se conecta a tu servidor. A continuación, intenta extenderlo con acceso a bases de datos, búsqueda web o vinculando múltiples servidores a un solo agente. Dirígete a Novita, tenemos las herramientas que necesitas para construir tus agentes de IA.
Novita AI es una plataforma en la nube de IA que ofrece a los desarrolladores una forma sencilla de implementar modelos de IA usando nuestra API simple, al mismo tiempo que proporciona GPU en la nube asequible y confiable para construir y escalar.
