> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-docs-hivemind-launch.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Model Context Protocol (MCP) et Weave
> Suivez l'activité entre votre client MCP et votre serveur MCP avec Weave
Le Model Context Protocol (MCP) est un protocole de communication standardisé qui permet aux applications d'IA d'échanger des informations avec de grands modèles de langage (LLM). À l'image des connecteurs universels qui ont transformé la compatibilité matérielle, MCP fournit une interface permettant aux LLM d'accéder à diverses sources de données et d'interagir avec des outils externes, sans nécessiter d'intégrations personnalisées pour chaque nouveau service.
L'intégration Weave vous permet de suivre l'activité entre votre client MCP et votre serveur MCP. Elle vous offre une visibilité détaillée sur les appels d'outils, l'accès aux ressources et la génération de prompts dans les systèmes reposant sur MCP.
## Fonctionnement
Actuellement, l'intégration capture séparément les opérations côté client et côté serveur, mais ne fournit pas de visibilité de bout en bout sur leur interaction. Une proposition est en cours pour ajouter la prise en charge des traces OpenTelemetry à MCP afin de permettre une observabilité de bout en bout. Pour plus d'informations, voir [GitHub discussion #269](https://github.com/modelcontextprotocol/modelcontextprotocol/discussions/269).
L'intégration Weave trace automatiquement les composants clés du Model Context Protocol (MCP) en patchant les méthodes de base avec le décorateur [`weave.op()`](../tracking/ops). Plus précisément, elle patche des méthodes dans les classes [`mcp.server.fastmcp.FastMCP`](https://github.com/modelcontextprotocol/python-sdk/blob/b4c7db6a50a5c88bae1db5c1f7fba44d16eebc6e/src/mcp/server/fastmcp/server.py#L109) et [`mcp.ClientSession`](https://github.com/modelcontextprotocol/python-sdk/blob/b4c7db6a50a5c88bae1db5c1f7fba44d16eebc6e/src/mcp/client/session.py#L84).
Grâce à cette intégration, Weave trace les composants MCP suivants :
* [Outils](https://modelcontextprotocol.io/specification/2025-06-18/server/tools)
* [Ressources](https://modelcontextprotocol.io/specification/2025-06-18/server/resources)
* [Prompts](https://modelcontextprotocol.io/specification/2025-06-18/server/prompts)
[
](https://wandb.ai/ayut/mcp_example/weave/traces?filter=%7B%22opVersionRefs%22%3A%5B%22weave%3A%2F%2F%2Fayut%2Fmcp_example%2Fop%2Frun_client%3A*%22%5D%7D\&peekPath=%2Fayut%2Fmcp_example%2Fcalls%2F01966bbe-cc5e-7012-b45f-bf10617d8c1e%3FhideTraceTree%3D0)
## Utiliser l’intégration
L’intégration Weave fonctionne à la fois avec le serveur MCP et le client. Une fois installée, vous pouvez activer Tracing avec seulement deux lignes de code supplémentaires : l’une pour importer `weave`, et l’autre pour l’initialiser.
### Prérequis
Avant de commencer, installez les paquets requis :
```bash theme={null}
pip install -qq "mcp[cli]" weave
```
### Configuration
Configurez l’intégration MCP à l’aide de variables d’environnement :
* `MCP_TRACE_LIST_OPERATIONS` : définissez cette variable sur `true` pour activer le Tracing des opérations de liste (`list_tools`, `list_resources` et `list_prompts`) côté serveur et côté client.
### Intégration côté serveur
Pour tracer un serveur MCP, ajoutez deux lignes à votre configuration `FastMCP` existante : une pour importer Weave et une pour initialiser le client. Une fois ces lignes ajoutées, les opérations sur les outils, les ressources et les prompts seront automatiquement tracées.
```python lines theme={null}
# 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 serveur MCP
mcp = FastMCP("Demo")
# Définir un outil (cet appel sera tracé)
@mcp.tool()
def add(a: int, b: int) -> int:
"""Additionner deux nombres."""
return a + b
# Définir une ressource (cet appel sera tracé)
@mcp.resource("greeting://{name}")
def get_greeting(name: str) -> str:
"""Retourner un message de salutation personnalisé."""
return f"Hello, {name}!"
# Définir un prompt (cet appel sera tracé)
@mcp.prompt()
def review_code(code: str) -> str:
"""Retourner un prompt pour la révision de code."""
return f"Please review this code:\n\n{code}"
# Démarrer le serveur
mcp.run(transport="stdio")
```
### Intégration côté client
Côté client, le tracing ne nécessite lui aussi que deux modifications : importer Weave et l’initialiser. Tous les appels d’outil, les accès aux ressources et les requêtes de prompt seront automatiquement tracés.
```python lines theme={null}
# 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 (sera tracé)
result = await session.call_tool("add", arguments={"a": 1, "b": 2})
# Lire une ressource (sera tracé)
resource = await session.read_resource("greeting://user")
# Obtenir un prompt (sera tracé)
prompt = await session.get_prompt("review_code", arguments={"code": "print('Hello')"})
```
## Tutoriel : exemple `mcp_demo`
L’exemple `mcp_demo` présente une intégration entre le Model Context Protocol (MCP) et Weave pour le Tracing. Il montre comment instrumenter à la fois les composants client et serveur afin de capturer des traces détaillées de leurs interactions.
### Exécuter l’exemple
1. Clonez le dépôt de documentation, puis accédez à l’exemple `mcp_demo` :
```bash theme={null}
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 :
```bash theme={null}
pip install mcp[cli] weave
```
3. Exécutez la démonstration :
```bash theme={null}
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
L'interface client prend en charge les commandes suivantes :
| Commande | Description |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `tools` | Lister les outils disponibles |
| `resources` | Lister les ressources disponibles |
| `prompts` | Lister les prompts disponibles |
| `add ` | Additionner deux nombres |
| `bmi ` | Calculer l’indice de masse corporelle |
| `weather ` | Obtenir les données météo d’une ville |
| `greeting ` | Obtenir une salutation personnalisée |
| `user ` | Récupérer le profil d’un utilisateur |
| `config` | Récupérer la configuration de l’application |
| `code-review ` | Générer un prompt de revue de code |
| `debug ` | Générer un prompt de débogage |
| `demo` | Exécuter une démo complète de toutes les fonctionnalités disponibles. Cette commande exécute chaque fonctionnalité dans l’ordre et produit une chronologie complète des interactions dans la Weave UI. |
| `q` | Quitter la session |
### Comprendre l'exemple
Le serveur `example_server.py` définit les éléments suivants :
* *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()`
Toutes les opérations côté serveur sont automatiquement tracées par Weave lorsque vous initialisez le client avec `weave.init()`.
Le client `example_client.py` montre comment :
* 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()`](../tracking/ops) avec des méthodes ou fonctions personnalisées.
Weave trace tous les appels côté client afin de fournir une vue complète des interactions entre le client et le serveur.
## FAQ
### Pourquoi le tracing MCP est-il nécessaire ?
En tant que développeur d’applications LLM, vous appartenez à l’une des trois catégories suivantes :
* *Développeur côté serveur MCP* : vous souhaitez exposer plusieurs outils, ressources et prompts au client MCP. Vous exposez les outils, les ressources, etc. de votre application existante, ou vous avez créé des agents, voire 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.
Si vous appartenez à l’une des deux premières catégories, vous souhaitez savoir quand chaque outil est appelé, à quoi ressemble le flux d’exécution, ainsi que le nombre de tokens et la latence des différents composants de votre logique côté serveur ou côté client.
Si vous développez à la fois le serveur et le client, la possibilité de voir une chronologie unifiée des traces peut vous aider à itérer rapidement sur la logique côté serveur et côté client.
Dans tous les cas, une couche d’observabilité vous permet de :
* D’itérer rapidement sur votre application
* D’auditer le flux de travail ou la logique d’exécution
* D’identifier les goulots d’étranglement