> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Model Context Protocol (MCP) et Weave
> Tracez 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 les grands modèles de langage (LLM). MCP fournit une interface grâce à laquelle les LLM peuvent accéder à des sources de données et interagir avec des outils externes, sans qu’il soit nécessaire de développer des intégrations personnalisées pour chaque nouveau service.
L’intégration Weave vous permet de tracer l’activité entre votre client MCP et votre serveur MCP. Vous bénéficiez ainsi d’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 basés sur MCP, afin de déboguer, d’auditer et d’optimiser vos applications MCP.
Ce guide explique le fonctionnement de l’intégration et la manière d’activer le traçage côté serveur et côté client, puis présente un exemple complet que vous pouvez exécuter vous-même.
Fonctionnement
L'intégration capture séparément les opérations côté client et côté serveur, mais n'offre pas de visibilité de bout en bout sur leur interaction. Une proposition en cours vise à ajouter la prise en charge des traces OpenTelemetry à MCP afin de permettre une observabilité de bout en bout. Pour plus d'informations, voir [la discussion GitHub n° 269](https://github.com/modelcontextprotocol/modelcontextprotocol/discussions/269).
L'intégration Weave trace automatiquement les principaux composants du Model Context Protocol (MCP) en patchant ses méthodes essentielles avec le décorateur [`weave.op()`](/fr/products/wandb/weave/guides/tracking/ops). Plus précisément, elle patche des méthodes des 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://forge.coreweave.com/wandb/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 aussi bien avec le serveur MCP qu’avec le client MCP. Une fois l’intégration installée, il suffit d’ajouter deux lignes de code pour activer le traçage : l’une pour importer `weave`, l’autre pour l’initialiser.
Prérequis
Avant de commencer, installez les paquets requis :
```bash theme={"system"}
pip install -qq "mcp[cli]" weave
```
Configuration
Configurez l’intégration MCP à l’aide de la variable d’environnement `MCP_TRACE_LIST_OPERATIONS`. Définissez-la sur `true` pour tracer les opérations de listage (`list_tools`, `list_resources` et `list_prompts`) côté serveur comme côté client.
Intégration côté serveur
Consultez cette section si vous développez ou instrumentez un serveur MCP. Pour tracer un serveur MCP, ajoutez deux lignes à votre configuration `FastMCP` existante : l'une pour importer Weave, l'autre pour initialiser le client. Une fois ces lignes ajoutées, Weave trace automatiquement les opérations sur les outils, les ressources et les prompts.
```python lines theme={"system"}
# Importer Weave (requis pour le traçage)
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:
"""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
Consultez cette section si vous développez ou instrumentez un client MCP. Côté client, le traçage nécessite lui aussi deux modifications : importer Weave, puis l’initialiser. Weave trace automatiquement tous les appels d’outils, les accès aux ressources et les requêtes de prompts.
```python lines theme={"system"}
# Importer Weave (requis pour le traçage)
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 (cet appel sera tracé)
result = await session.call_tool("add", arguments={"a": 1, "b": 2})
# Lire une ressource (cette lecture sera tracée)
resource = await session.read_resource("greeting://user")
# Obtenir un prompt (cette requête sera tracée)
prompt = await session.get_prompt("review_code", arguments={"code": "print('Hello')"})
```
Tutoriel : exemple `mcp_demo`
L’exemple `mcp_demo` illustre l’intégration de MCP et de Weave pour le traçage. Il montre comment instrumenter à la fois les composants client et serveur afin de capturer des traces détaillées de leurs interactions. En exécutant ce code, vous pourrez visualiser les traces des deux côtés d’une application MCP dans l’interface de Weights & Biases, et disposer d’une référence concrète à adapter à vos propres projets.
Exécuter l’exemple
1. Clonez le dépôt de la documentation et accédez à l’exemple `mcp_demo` :
```bash theme={"system"}
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 conçu 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={"system"}
pip install mcp[cli] weave
```
3. Lancez la démonstration :
```bash theme={"system"}
python example_client.py example_server.py
```
Cette commande lance à la fois le client et le serveur. Le client ouvre une CLI interactive depuis laquelle vous pouvez tester différentes fonctionnalités.
Commandes du CLI 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 (IMC) |
| `weather ` | Obtenir les données météo d’une ville |
| `greeting ` | Obtenir un message d’accueil personnalisé |
| `user ` | Récupérer un profil 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émonstration complète de toutes les fonctionnalités disponibles. Exécute chaque fonctionnalité l’une après l’autre et génère une chronologie complète des traces d’interactions dans l’interface utilisateur de Weights & Biases. |
| `q` | Quitter la session |
Aperçu de l’exemple
Le serveur `example_server.py` définit les éléments suivants :
* *Outils* : des fonctions telles que `add()`, `calculate_bmi()`, `fetch_weather()`
* *Ressources* : des points de terminaison tels que `greeting://{name}`, `config://app`, `users://{id}/profile`
* *Prompts* : des modèles tels que `review_code()` et `debug_error()`
Weave trace automatiquement toutes les opérations côté serveur lorsque vous initialisez le client avec `weave.init()`.
Le client `example_client.py` montre comment :
* Se connecter à un serveur MCP.
* Découvrir les outils, ressources et prompts disponibles.
* Appeler des outils avec des paramètres.
* Lire des URI de ressources.
* Générer des prompts avec des arguments.
* Utiliser [`weave.op()`](/fr/products/wandb/weave/guides/tracking/ops) avec des méthodes et fonctions personnalisées.
Weave trace tous les appels côté client afin d’offrir une vue complète des interactions entre le client et le serveur.
FAQ
Cette section répond aux questions fréquentes sur l’intérêt du traçage MCP de Weave et sur la façon de l’utiliser.
Pourquoi le traçage MCP est nécessaire
En tant que développeur d’applications LLM, vous appartenez à l’une de ces trois catégories :
* *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, 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 part essentielle de votre logique côté client consiste à effectuer des appels LLM pour déterminer 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é et à quoi ressemble le flux d’exécution, et connaître le nombre de jetons ainsi que 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, une chronologie de trace unifiée vous aide à itérer sur la logique côté serveur comme côté client.
Dans tous les cas, une couche d’observabilité vous permet de :
* Itérer sur votre application.
* Auditer le flux de travail ou la logique d’exécution.
* Identifier les goulots d’étranglement.
## Related topics
- [CoreWeave Observe™](/observability.md)