Model Context Protocol (MCP) et Weave

​

Fonctionnement

• Outils
• Ressources
• Prompts

​

Utiliser l’intégration

​

Prérequis

pip install -qq "mcp[cli]" weave

​

Configuration

​

Intégration côté serveur

# Importer Weave (requis pour le tracing)
import weave
from mcp.server.fastmcp import FastMCP

# Initialiser Weave avec le nom de votre projet
weave_client = weave.init("my-project")

# Configurer le MCP server
mcp = FastMCP("Demo")

# Définir un outil (cet appel sera tracé)
@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

# Définir une ressource (cet appel sera tracé)
@mcp.resource("greeting://{name}")
def get_greeting(name: str) -> str:
    """Return a personalized greeting."""
    return f"Hello, {name}!"

# Définir un prompt (cet appel sera tracé)
@mcp.prompt()
def review_code(code: str) -> str:
    """Return a prompt for reviewing code."""
    return f"Please review this code:\n\n{code}"

# Démarrer le serveur
mcp.run(transport="stdio")

​

Intégration côté client

# Importer Weave (requis pour le tracing)
import weave
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

# Initialiser Weave avec le nom de votre projet
weave_client = weave.init("my-project")

# Configurer et exécuter le client MCP
async with stdio_client(server_params) as (read, write):
    async with ClientSession(read, write) as session:
        # Initialiser la session
        await session.initialize()
        
        # Appeler un outil (cette opération sera tracée)
        result = await session.call_tool("add", arguments={"a": 1, "b": 2})
        
        # Lire une ressource (cette opération sera tracée)
        resource = await session.read_resource("greeting://user")
        
        # Obtenir un prompt (cette opération sera tracée)
        prompt = await session.get_prompt("review_code", arguments={"code": "print('Hello')"})

​

Tutoriel : exemple mcp_demo

​

Exécuter l’exemple

1. Clonez le dépôt de documentation, puis accédez à l’exemple mcp_demo :
   git clone https://github.com/wandb/docs
   cd docs/weave/examples/mcp_demo
   
   L’exemple comprend deux fichiers principaux :
   • example_server.py : un serveur MCP de démonstration créé avec FastMCP. Il définit des outils, des ressources et des prompts.
   • example_client.py : un client qui se connecte au serveur et interagit avec ses composants.
2. Installez manuellement les dépendances requises :
   pip install mcp[cli] weave
   
3. Exécutez la démonstration :
   python example_client.py example_server.py
   
   Cette commande lance à la fois le client et le serveur. Le client démarre un CLI interactif dans lequel vous pouvez tester différentes fonctionnalités.

​

Commandes CLI du client

​

Aperçu de l’exemple

• Outils : des fonctions comme add(), calculate_bmi(), fetch_weather()
• Ressources : des endpoints comme greeting://{name}, config://app, users://{id}/profile
• Prompts : des modèles comme review_code() et debug_error()

• Se connecter à un serveur MCP.
• Découvrir les outils, les ressources et les prompts disponibles.
• Appeler des outils avec des paramètres.
• Lire des données à partir d’URI de ressources.
• Générer des prompts avec des arguments.
• Illustrer l’utilisation de weave.op() avec des méthodes et des fonctions personnalisées.

​

FAQ

​

Pourquoi le tracing MCP est-il nécessaire ?

• Développeur côté serveur MCP : vous souhaitez exposer plusieurs outils, ressources et prompts au client MCP. Vous exposez les outils et les ressources de votre application existante, ou vous avez créé des agents ou disposez de plusieurs agents orchestrés par un agent orchestrateur.
• Développeur côté client MCP : vous souhaitez connecter votre application côté client à plusieurs serveurs MCP. Une partie essentielle de votre logique côté client consiste à effectuer des appels LLM pour décider quel outil appeler ou quelle ressource récupérer.
• Développeur serveur et client MCP : vous développez à la fois le serveur et le client.

• Itérer sur votre application.
• Auditer le flux de travail ou la logique d’exécution.
• Identifier les goulots d’étranglement.