Nous sommes à l’aube d’un nouveau type de logiciel. Dans son récent discours d’ouverture à l’école de démarrage YC, Andrej Karpathy a décrit le Software 3.0, un monde où le langage naturel devient l’interface de programmation principale, et les grands modèles de langage servent à la fois de moteurs de calcul et de collaborateurs autonomes.
Contrairement au Software 1.0, où les développeurs écrivaient des instructions explicites, ou au Software 2.0, où les réseaux de neurones apprenaient des modèles à partir de données, le Software 3.0 fonctionne sur la base du langage naturel. Nos prompts deviennent des programmes, et les LLM traduisent nos intentions en comportements exécutables.
Dans ce tutoriel, nous allons construire un serveur MCP qui donne un accès à distance à un bac à sable Novita AI où notre agent IA pourra exécuter du code en toute sécurité. L’agent lui-même sera créé avec la bibliothèque mcp-use, qui gère également automatiquement la communication avec le serveur MCP.
Qu’est-ce que le MCP (Model Context Protocol) ?
Le protocole de contexte de modèle (Model Context Protocol, MCP) est une norme ouverte développée par Anthropic pour permettre aux modèles IA de communiquer avec des services externes, des outils et des sources de données. Considérez-le comme un « USB-C pour l’IA » ; il fournit une interface standard entre les agents et le monde extérieur.
Les trois composants principaux :
- Outils : Fonctions / API appelables exposées par le serveur (ex. navigation web, exécution de code).
- Ressources : Données externes fournies par le serveur, généralement destinées à servir de contexte pour l’agent IA (ex. fichiers, métadonnées, jeux de données).
- Prompts : Ces instructions détaillées sont destinées à guider le comportement de l’agent lors de l’interaction avec les outils ou ressources ci-dessus.
Pour une analyse plus approfondie du MCP, de son architecture et de ses composants, consultez notre article sur la construction de votre premier serveur MCP
Pourquoi le MCP est important pour l’intégration d’outils IA
Le MCP établit une communication bidirectionnelle entre les agents IA et les systèmes externes. Cela permet de « brancher » facilement les LLM sur des outils personnalisés, tout en réduisant le travail d’intégration et en minimisant les risques d’erreurs.
Introduction à la bibliothèque mcp-use
La bibliothèque mcp-use est un package Python qui simplifie la construction d’agents IA interagissant avec des serveurs MCP. Elle gère la création de l’agent et la communication avec les serveurs MCP pour accéder à des outils et sources de données externes, vous permettant de vous concentrer uniquement sur la logique de votre application.
Présentation de Novita AI Sandbox et de l’API de modèle
Qu’est-ce qu’un bac à sable et pourquoi c’est important
Un bac à sable (sandbox) est un environnement d’exécution sécurisé et isolé où du code non fiable peut être exécuté sans affecter le système hôte. C’est essentiellement un ordinateur virtuel léger que votre agent IA peut utiliser pour exécuter du code, des commandes, créer des fichiers, etc.
Novita AI propose ce bac à sable dans le cloud pour que votre agent y accède rapidement à la demande, avec une facturation flexible à la seconde en fonction des ressources utilisées.
Fonctionnalités clés du bac à sable Novita :
- Isolation sécurisée : Chaque bac à sable dispose de son propre système de fichiers et environnement isolés, protégeant les données et empêchant les interactions involontaires.
- Démarrage rapide : Les instances de bac à sable se lancent en moins de ~200ms en moyenne, ce qui est idéal pour les scénarios à faible latence.
- Prise en charge de plusieurs langages : Vous pouvez exécuter du code dans plusieurs langages de programmation, notamment Python, JavaScript, TypeScript, et bien d’autres.
- Pause et reprise rapides : Mettez le bac à sable en pause à tout moment et reprenez-le lorsque vous en avez besoin, l’état du système de fichiers et des processus étant entièrement restauré.
- Exécution en arrière-plan : Prend en charge l’exécution de tâches en arrière-plan et est adapté aux scénarios nécessitant d’attendre un résultat.
API de modèle Novita :
Novita propose une vaste bibliothèque de modèles IA open source provenant de laboratoires de recherche leaders comme OpenAI, Google, DeepSeek et Qwen, entre autres. Cela inclut des modèles pour le langage, la vision, l’audio, la vidéo et les embeddings. Nos modèles de langage sont également entièrement compatibles avec le SDK OpenAI, donc passer d’OpenAI à Novita ne nécessite que la mise à jour de l’URL de base et de la clé API dans votre client, puis la sélection d’un modèle Novita.
| from openai import OpenAI client = OpenAI( base_url=“https://api.novita.ai/v3/openai”, api_key=“<Votre clé API Novita>”, ) |
Configuration de votre environnement de développement
Pour commencer, nous allons cloner le dépôt GitHub, configurer un environnement Python propre, installer toutes les dépendances requises et obtenir les clés Novita AI.
Cloner le dépôt GitHub et installer les dépendances avec uv.
1. Installez uv (un gestionnaire de packages Python léger)
| pip install uv |
2. Clonez le dépôt (dépôt GitHub) et naviguez à l’intérieur.
| git clone https://github.com/Studio1HQ/mcp\_remote\_execution.git cd mcp_remote_execution |
3. Créez et activez l’environnement virtuel uv
| # Crée un environnement virtuel uv venv # Active l’environnement virtuel source .venv/bin/activate # Pour Mac/Linux # ou .venv\Scripts\activate # Pour Windows |
4. Installez les dépendances du projet
| # Installe les dépendances uv sync |
Créer un compte Novita AI et obtenir une clé API
1. Inscrivez-vous sur novita.ai.
2. Dans le tableau de bord, survolez l’icône de profil utilisateur et cliquez sur Clés API dans le menu contextuel.
3. Sur la page de gestion des clés, cliquez sur Ajouter une nouvelle clé. Dans la fenêtre contextuelle, entrez un nom pour votre clé, cliquez sur Confirmer, puis copiez la clé générée.
4. Maintenant, dans le répertoire du projet, créez un fichier .env et collez ce qui suit dedans.
| NOVITA_API_KEY=“<COLLEZ VOTRE CLÉ API NOVITA ICI>” NOVITA_BASE_URL=“https://api.novita.ai/v3/openai” NOVITA_E2B_DOMAIN=“sandbox.novita.ai” NOVITA_E2B_TEMPLATE=“code-interpreter-v1” |
Ajouter des crédits au compte Novita AI.
Pour utiliser le bac à sable Novita, vous devez ajouter des crédits à votre compte. Dans l’onglet du tableau de bord, cliquez sur ‘Facturation’. Ensuite, sur la page de facturation, ajoutez un moyen de paiement et rechargez au moins 10 $ de crédits.
Construction de l’intégration du serveur MCP et de l’agent IA
Maintenant que notre environnement est configuré, commençons à construire. Ce processus comportera deux parties : d’abord, nous allons créer le serveur MCP, puis nous construirons l’application d’agent IA (qui agit comme client MCP). Mais avant de commencer, créons le gestionnaire de bac à sable que le serveur MCP utilisera.
Le gestionnaire de bac à sable
Celui-ci sera responsable du démarrage et de l’arrêt des instances de bac à sable. Dans notre configuration, nous allons restreindre le serveur à une seule instance de bac à sable à la fois. Le gestionnaire de bac à sable gérera également l’exécution de code Python et l’exécution de commandes shell dans le bac à sable.
Tout d’abord, dans sandbox_manager.py, nous avons la classe SandboxManager, qui prend les paramètres suivants :
- sandbox_template : Le modèle utilisé pour créer une instance de bac à sable. Nous utiliserons « code-interpreter-v1 », qui est préinstallé avec les packages Python couramment utilisés (ex. pandas, numpy).
- sandbox_domain : Le point de terminaison de domaine utilisé pour se connecter à l’instance de bac à sable Novita AI.
- sandbox_timeout : La durée (en secondes) qui détermine la durée pendant laquelle le bac à sable reste actif avant d’être automatiquement terminé.
| 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 |
Maintenant, nous allons ajouter des méthodes pour créer et arrêter un bac à sable.
- Pour la création, nous prenons une sandbox_api_key, l’utilisons pour démarrer une nouvelle instance de bac à sable pour l’utilisateur, et renvoyons un message de succès avec l’ID du bac à sable ou un message d’exception si quelque chose se passe mal.
- Pour l’arrêt, nous prenons à la fois la sandbox_api_key et le sandbox_id, nous connectons au bac à sable, et l’arrêtons s’il existe. Comme précédemment, nous renvoyons un message de succès ou un message d’exception selon le résultat.
| … class SandboxManager: … # below existing code def create_sandbox_session(self, sandbox_api_key: str) -> str: “”“ This will create a new sandbox instance. Args: sandbox_api_key (str): The API key for the sandbox. Returns: str: Success message with the sandbox ID of the new sandbox or error message. ”“” try: # create the new sandbox sandbox = Sandbox.create( template=self.sandbox_template, api_key=sandbox_api_key, domain=self.sandbox_domain, timeout=self.sandbox_timeout, ) return f"Successfully created sandbox. Sandbox ID: {sandbox.sandbox_id}“ except Exception as e: return f"Failed to create new sandbox:{str(e)}” def stop_sandbox_session(self, sandbox_api_key: str, sandbox_id: str) -> str: “”“ This will kill a sandbox instance if it exists. Args: sandbox_api_key (str): The API key for the sandbox. sandbox_id (str): The ID of the sandbox. Returns: str: Success message with the sandbox ID of the killed sandbox or error message. ”“” try: # connect to sandbox sandbox = Sandbox.connect( api_key=sandbox_api_key, sandbox_id=sandbox_id, ) sandbox.kill() return f"Successfully killed Sandbox ID: {sandbox_id}“ except Exception as e: return f"Failed to kill Sandbox ID: {sandbox_id}\ {str(e)}” |
Enfin, nous ajoutons des méthodes pour exécuter du code Python et des commandes shell dans le bac à sable d’un utilisateur après s’être connecté via la clé API et l’ID. Toutes les sorties du bac à sable (y compris les exceptions et les erreurs) sont renvoyées dans un dictionnaire.
| … class SandboxManager: … # below existing code def run_python_code( self, python_code: str, sandbox_api_key: str, sandbox_id: str ) -> dict: “”“ Runs the python code on the sandbox, and if there any image outputs they are skipped. Args: python_code (str): The python code to run. sandbox_api_key (str): The API key for the sandbox. sandbox_id (str): The ID of the sandbox. Returns: dict: Containing stdout, logs, error, etc. ”“” try: # connect to sandbox sandbox = Sandbox.connect( api_key=sandbox_api_key, sandbox_id=sandbox_id, ) execution = sandbox.run_code(python_code, language=“python”) return { # we will skip image outputs. “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: “”“ Runs the command on the sandbox. Args: command (str): The command to run. sandbox_api_key (str): The API key for the sandbox. sandbox_id (str): The ID of the sandbox. Returns: dict: Containing the output of the command and the execution error if any. ”“” try: # connect to 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)} |
Création du serveur MCP
Maintenant que le gestionnaire de bac à sable est configuré, il est temps de travailler sur mcp_server.py. Tout d’abord, nous créons une instance de FastMCP, le framework qui fera fonctionner le serveur, ainsi qu’un gestionnaire de bac à sable. Nous créons également une instance de console rich pour un affichage beau dans le terminal.
Remarque : Le délai d’expiration du bac à sable transmis au gestionnaire de bac à sable est utilisé pour chaque bac à sable démarré sur ce serveur. Il s’agit du temps maximum (en secondes) pendant lequel chaque bac à sable peut rester actif (en cours d’exécution), sauf s’il est arrêté plus tôt.
| 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 # load .env variables load_dotenv() console = Console() # Initialize FastMCP server mcp = FastMCP(“MCP_Server”) # Initialize sandbox manager for the singleton sandbox instance. sandbox_manager = SandboxManager( sandbox_template=os.getenv(“NOVITA_E2B_TEMPLATE”), sandbox_domain=os.getenv(“NOVITA_E2B_DOMAIN”), sandbox_timeout=900, # 900 seconds (15 minutes), sandbox instance will be killed automatically after. ) |
Maintenant, comme nous avons besoin d’une clé API pour nous connecter au bac à sable d’un utilisateur, nous allons l’extraire de la requête de l’utilisateur vers le serveur. Comme nous le verrons plus tard dans le client MCP, cette clé sera envoyée dans l’en-tête d’autorisation de chaque requête. Cela signifie que nous avons besoin d’un moyen d’extraire la clé API de cet en-tête côté serveur.
FastMCP fournit un objet Context qui, au moment de l’exécution, contient des informations sur l’utilisateur qui effectue la requête. Nous allons donc créer une méthode d’assistance get_user_api_key qui prend un objet contexte, extrait la clé API de l’en-tête et la renvoie, ou lève une exception si elle est manquante.
| … # below existing code def get_user_api_key(ctx: Context) -> str: “”“ Returns the API key from the request header if it exists otherwise raise an exception. ”“” request: Request = ctx.request_context.request # Access request data auth_header = request.headers.get(“Authorization”) if auth_header: auth_header = auth_header.split(" ")[1] if not auth_header: raise Exception(“Missing API Key in Authorization Bearer header”) return auth_header |
Il est temps d’exposer des prompts, des outils et des ressources sur notre serveur. Pour cela, nous ajoutons simplement le décorateur @mcp.{prompt, tool, resource}() à la fonction Python. Commençons par notre prompt, qui renvoie des instructions sur la façon dont notre agent doit utiliser le bac à sable.
| … # below existing code (Note: Console display helper methods were skipped for brevity) @mcp.prompt() def instructions_for_sandbox_use() -> str: “”“ RETURNS MUST READ INSTRUCTIONS FOR SANDBOX USE. ”“” return “”“ When you want to use the sandbox function, you must first create a new sandbox session by calling the create_sandbox_session() function. Then you can use the run_python_code() or run_on_command_line() function to run on the sandbox. When you are done, you must kill the sandbox session by calling the stop_sandbox_session() function. Note: - The sandbox already comes pre-installed with the usual data analysis packages but if there’s a package you are not sure exists or your code had an import error due to a missing package, you can check if it’s installed and if not install it. ”“” |
Pour les outils, nous exposons des méthodes qui utilisent l’instance sandbox_manager pour créer, arrêter et exécuter du code ou des commandes sur le bac à sable d’un utilisateur.
Remarque : Parmi les arguments que prennent les méthodes d’outil ci-dessous, nous inclurons un ctx: Context. Cela indique à FastMCP d’insérer automatiquement le contexte de la requête dans ce paramètre, un processus appelé injection de dépendances. Nous récupérons ensuite la clé api si elle existe en passant ce contexte à notre méthode d’assistance (get_user_api_key).
| … # below existing code @mcp.tool() def create_sandbox_session(ctx: Context) -> str: “”“ This will create a sandbox instance and return success message with the sandbox id or error message. ”“” 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: “”“ This will kill a sandbox instance if it exists. ”“” 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: “”“ Runs the python code on the sandbox, and if there any image outputs they are skipped. Args: python_code (str): The python code to run. sandbox_id (str): The ID of the sandbox. Note: The ctx (Context) is a dependency injection object that is automatically passed. Returns: dict: Containing stdout, logs, error, etc. ”“” console.print( Panel( python_code, title=“Agent Executing Python Code”, border_style=“blue”, ) ) try: result = sandbox_manager.run_python_code( python_code, get_user_api_key(ctx), sandbox_id ) # display the result. Note: only do this in test not in prod. 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: “”“ Runs the command on the sandbox. Args: command_line (str): The command to run. sandbox_id (str): The ID of the sandbox. Note: The ctx (Context) is a dependency injection object that is automatically passed. Returns: dict: Containing the output of the command and the execution error if any. ”“” console.print( Panel( command_line, title=“Agent Executing Command Line”, border_style=“blue”, ) ) try: result = sandbox_manager.run_on_command_line( command_line, get_user_api_key(ctx), sandbox_id ) # display the result. Note: only do this in test not in prod. display_sandbox_command_output(result) return result except Exception as e: return {“execution error”: str(e)} |
Maintenant, nous allons exposer une seule ressource pour l’un de nos scénarios de démonstration, que nous verrons plus tard. Cette ressource renvoie une simulation du portefeuille boursier d’un utilisateur. Contrairement aux prompts et aux outils, les ressources nécessitent de spécifier une URL où elles seront accessibles.
| … # below existing code @mcp.resource(“data://user_stock_portfolio”) def get_user_portfolio() -> dict: “”“ Returns the user’s portfolio holdings across major index ETFs and individual stocks. Returns: dict: Portfolio with ticker symbols, quantities, and average purchase prices ”“” portfolio = { “holdings”: [ # Major Index ETFs { “ticker”: “SPY”, “name”: “SPDR S&P 500 ETF”, “quantity”: 4, “avg_purchase_price”: 670.13, “asset_type”: “ETF”, }, … # skipped for brevity ] } return portfolio |
Enfin, nous ajoutons le code qui démarre notre serveur. Nous n’utiliserons pas le transport mcp stdio car la console Rich s’imprime dans le terminal, ce qui est une opération de blocage qui interférerait. À la place, nous utiliserons le transport mcp streamable-http (c’est ce que vous utiliserez également en production, car il est le mieux adapté pour les connexions à distance entre client et serveur via HTTP).
| … # below existing code if __name__ == “__main__”: # run the server # Note: We use streamable-http as the transport protocol instead of stdio because we are printing to the console which would block stdio. # Also in production you should use SSE or streamable-http rather than stdio. asyncio.run(mcp.run(transport=“streamable-http”)) |
Ouf, lançons notre serveur MCP pour obtenir l’URL à laquelle il s’exécute, dont nous aurons besoin pour connecter notre agent IA. Exécutez la commande ci-dessous dans le terminal.
| uv run mcp_server.py |
Vous devriez voir le serveur maintenant en cours d’exécution. Notez l’URL à laquelle il s’exécute
Intégration de l’agent IA avec le serveur MCP
Maintenant, nous allons commencer à travailler sur l’agent IA dans mcp_client.py. La bibliothèque mcp-use rend ce processus facile. Tout d’abord, nous définissons le niveau de débogage sur INFO pour voir ce que fait l’agent. Dans la méthode principale, nous créons un dictionnaire de configuration pour le client mcp. Il spécifie les serveurs mcp disponibles, en utilisant un nom (j’ai utilisé « stock&sandbox ») et l’URL à laquelle le serveur mcp s’exécute (n’oubliez pas d’ajouter /mcp), nous incluons également la clé API de l’utilisateur comme valeur pour « auth » ; celle-ci sera automatiquement insérée par mcp-use dans l’en-tête d’autorisation bearer de chaque requête.
Comme mcp-use repose sur langchain-openai, nous transmettons l’URL de base Novita, la clé API et le nom du modèle LLM, ce qui fonctionne car Novita est compatible avec OpenAI.
Et en plus de la réponse de l’agent, nous aimerions inclure l’ID du bac à sable qu’il a utilisé sur le serveur, le cas échéant (nous expliquerons pourquoi plus tard). Pour cela, nous allons définir une classe Pydantic pour représenter notre format de réponse.
| 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 # Load environment variables load_dotenv() console = Console() # Note: 1 for INFO level, 2 for full verbose DEBUG level and 0 for NO debug output. mcp_use.set_debug(1) class ResponseFormat(BaseModel): response: str id_of_used_sandbox: Optional[str] = Field( …, description=“The id of the sandbox used if any” ) async def main(model: str, base_url: str, api_key: str): # Create configuration dictionary config = { “mcpServers”: { “stock&sandbox”: { # If the url the mcp server is running at is different replace below, # also remember to add /mcp. “url”: “http://127.0.0.1:8000/mcp”, “auth”: api_key, } } } # Create MCPClient from configuration dictionary client = MCPClient(config) # Create LLM llm = ChatOpenAI(model=model, base_url=base_url, api_key=api_key) … |
Nous créons ensuite l’agent MCP en lui transmettant le LLM, le client MCP, le nombre maximum d’étapes (qui limite les actions que l’agent peut effectuer avant de répondre), et en activant la mémoire pour que mcp-use gère notre historique de conversation. Nous fournissons également un prompt système qui inclut la date et l’heure actuelles, ainsi que des instructions personnalisées pour l’utilisation du bac à sable (j’ai ajouté cela car certains modèles oublient de lire les prompts d’instructions exposés sur le serveur).
Enfin, nous configurons la boucle de conversation standard : nous récupérons la saisie de l’utilisateur, la transmettons à agent.run(), et affichons la réponse. Si un bac à sable a été utilisé, nous créons ensuite une session pour appeler manuellement la méthode d’arrêt sur le serveur comme mesure de sécurité, au cas où le modèle oublierait de le fermer.
| … async def main(model: str, base_url: str, api_key: str): … # below existing code # Create agent with the client agent = MCPAgent( llm=llm, client=client, max_steps=25, memory_enabled=True, # mcp-use will auto handle the conversation history. system_prompt=f"“” You are a helpful assistant and the current date is {datetime.now().strftime(‘%Y-%m-%d’)} MUST REMEMBER: - Before any tool call first call instructions_for_sandbox_use() so you can read them. - Ensure you call stop_sandbox_session() after using the sandbox before responding to the user. “”“, ) console.print( Panel( ”[bold green]MCP Session Started[/bold green]\ Type ‘quit()’ to exit.“, title=“MCP Session”, border_style=“green”, ) ) while True: user_input = Prompt.ask(”\ [bold yellow]>>> User Message[/bold yellow]“) if user_input.lower().strip() == “quit()”: break # Pass the query to the agent and await the response. response_obj = await agent.run(user_input, output_schema=ResponseFormat) console.print( f”\ [bold green]>>> Assistant Response: {response_obj.response} [/]" ) if response_obj.id_of_used_sandbox: # Will trigger closure of sandbox on MCP server if it sill active. 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() |
Enfin, nous ajoutons le code qui démarre le client :
| … # below existing code 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”), ) ) |
Test de notre agent IA MCP :
Vous pouvez démarrer l’application d’agent IA en exécutant la commande ci-dessous dans le terminal
| uv run mcp_client.py |
Vous trouverez ci-dessous des liens vidéo de démonstrations des prompts suivants :
- Prompt utilisateur 1 : « J’ai 2 000 $. Récupérez la performance des principaux indices boursiers américains auprès de yfinance au cours des 6 derniers mois et exécutez des modèles ML pour prédire comment allouer cet investissement pour maximiser les rendements potentiels au cours des 2 prochains mois. »(Insérer le lien ici)
- Prompt utilisateur 2 : « Exécutez plusieurs simulations d’un crash déflationniste de l’économie américaine, choisissez le plus probable, et expliquez l’impact qu’il aura sur mon portefeuille boursier. »(Insérer le lien ici)
Conseils pour les serveurs MCP en production
Bien que ce tutoriel se soit concentré sur la construction d’un serveur MCP fonctionnel avec Novita Sandbox, le déploiement en production nécessite des considérations supplémentaires :
Utilisez le bon transport : Alors que « stdio » fonctionne pour le développement local, les serveurs MCP de production doivent utiliser « streamable-http » pour permettre les connexions à distance, comme nous l’avons fait ci-dessus.
Implémentez l’authentification : Comme nous l’avons fait ci-dessus, assurez-vous de sécuriser les points de terminaison de votre serveur mcp avec une authentification. Assurez-vous que chaque client n’a l’autorisation d’accéder qu’aux outils et ressources dont il a besoin. Vous pouvez en savoir plus sur les méthodes d’authentification sur Authentification FastMCP
Activez la journalisation : Utilisez un journal pour surveiller l’activité du serveur, déboguer les problèmes et suivre les modèles d’utilisation. C’est essentiel pour la maintenance et le dépannage.
Limitation de débit et quotas : Protégez votre serveur des abus en implémentant des limites de débit et des quotas. Ceci est particulièrement important lorsque vous exposez des outils gourmands en ressources.
Documentation et versionnement : Maintenez une documentation claire de l’API de votre serveur MCP et un versionnement pour faciliter l’intégration pour les développeurs et les LLM.
Conclusion
Ouf, vous pouvez enfin construire un serveur MCP où les agents IA peuvent exécuter du code à distance via des instructions en langage naturel, une implémentation pratique du Software 3.0 en action.
Dans ce tutoriel, vous avez appris à construire un serveur MCP avec capacité d’exécution de code, à gérer les cycles de vie des bac à sable, et à créer un agent IA utilisant mcp-use qui se connecte à votre serveur. Ensuite, essayez de l’étendre avec un accès à une base de données, une recherche web, ou en reliant plusieurs serveurs à un seul agent. Rendez-vous sur Novita, nous avons les outils dont vous avez besoin pour construire vos agents IA.
Novita AI est une plateforme cloud IA qui offre aux développeurs un moyen simple de déployer des modèles IA grâce à notre API simple, tout en fournissant un cloud GPU abordable et fiable pour construire et mettre à l’échelle.
