Implementation de MCP-Zero : Découverte Active d'Outils dans un Agent AI
Ce projet présente l'implémentation de MCP-Zero, un framework innovant pour la découverte active d’outils dans les systèmes d’agents basés sur des grands modèles de langage (LLM). Contrairement aux approches traditionnelles qui injectent massivement les descriptions d’outils dans le contexte du modèle, MCP-Zero permet aux agents de demander dynamiquement les outils dont ils ont besoin, en fonction de leurs lacunes de capacités perçues.
Fonctionnalités principales
- ✅ Découverte active d’outils (Active Tool Request) : L’agent identifie de lui-même ses besoins en outils externes et génère des requêtes structurées via des blocs ``.
- 🔍 Routage sémantique hiérarchique : Un mécanisme en deux étapes filtre d’abord les serveurs MCP pertinents, puis classe les outils selon leur similarité sémantique.
- 🔄 Extension itérative des capacités : L’agent peut raffiner ses requêtes et découvrir de nouveaux outils au fil de l’exécution, assurant une adaptation continue.
- 📦 Construction du dataset MCP-Tools : Extraction, structuration et vectorisation des métadonnées des serveurs MCP pour une récupération efficace.
- ⚙️ Orchestration via PocketFlow : Intégration dans un workflow modulaire basé sur des nodes, permettant une exécution fluide et configurable.
- 🖥️ Interface interactive avec Gradio : Visualisation en temps réel des requêtes, décisions et outils découverts.
Objectifs du projet
- Réduire drastiquement la surcharge contextuelle liée à l’injection massive d’outils.
- Restaurer l’autonomie décisionnelle des agents en leur permettant de formuler activement leurs besoins.
- Valider l’efficacité de MCP-Zero dans des scénarios réels d’agents autonomes.
Technologies utilisées
- Python 3.8+
- OpenAI GPT-4o, Qwen2.5, DeepSeek-r1 (modèles évalués)
- text-embedding-3-large (OpenAI) pour les embeddings sémantiques
- MCP Python SDK pour l’interaction avec les serveurs MCP
- PocketFlow pour l’orchestration des workflows
- Gradio pour l’interface utilisateur interactive
- PyYAML pour le parsing des sorties structurées
Flow Diagram
Agent Architecture :```mermaid
flowchart TD
decide_node[Decide Node] -->|"Find Tool"| Tool_Matcher_Node[Tool Matcher Node]
Tool_Matcher_Node -->|"Return Found Tool"| decide_node
decide_node -->|"Call Tool"| execute_node[Execute Node]
decide_node -->|"Generate Final Response"| None((End))
execute_node -->|"Tool Result"| decide_node
decide_node -->|"On Error"| decide_node
## 📂 Structure du projet```plaintext
mcp-zero/
├── agent/ # Code principal de l'agent
│ ├── main.py # Point d'entrée - interface et orchestration
│ ├── flow.py # Définition du flux d'exécution (nodes)
│ ├── node_s.py # Implémentation des nodes (ToolMatcher, Decision, Execute)
│ ├── utils.py # Fonctions utilitaires (LLM call, embedding, etc.)
│ ├── server_config.json # Configuration des serveurs MCP (commandes de lancement)
│ └── requirements.txt # Dépendances Python
│
├── mcp_build_tools_dataset/ # Scripts pour construire le dataset MCP-tools
│ ├── get_server_summary.py # Génère les résumés et embeddings des serveurs
│ ├── server_summary.prompt # Prompt utilisé pour générer les résumés
│ ├── readmes/ # Dossier pour stocker les README des serveurs MCP
│ └── output/ # Dossier de sortie pour les fichiers générés
│ └── all_servers.json # Dataset final (sortie)
│
└── README.md # Ce fichier
🛠️ Comment builder le dataset
- Mettre les README des serveurs MCP dans
mcp_build_tools_dataset/readmes/. - Le script
get_server_summary.pyva extraire les infos et générer un dataset JSON (all_servers.json) sous le schéma suivant :```json
{
"server_name": "string",
"server_summary": "string",
"server_description": "string",
"tools": [
{
"name": "string",
"description": "string",
"parameter": {
"param1": "(type) description1",
"param2": "(Optional, type) description2"
},
"description_embedding": "..."
}
],
"description_embedding": "...",
"summary_embedding": "..."
}
3. Commande pour builder le dataset :```bash
cd mcp_build_tools_dataset
python get_server_summary.py
⚠️ Remarque importante :
Dans utils.py et get_server_summary.py, les fonctions call_llm et get_embedding et extract_info_for_readme ddéfinissent la manière d’appeler le modèle (LLM), de générer les embeddings, ainsi que de produire le JSON contenant les descriptions des serveurs et des outils à partir des fichiers README. La logique de ces fonctions reste à implémenter.
⚙️ Gestion des serveurs MCP
- Ajouter un serveur personnalisé dans le dossier
servers/. - Définir sa configuration de lancement dans
server_config.json(commandes pour démarrer le serveur et exécuter ses outils). - Dans
server_config.json, le champserver_namedoit correspondre exactement auserver_namedéfini dansall_servers.json.
🚀 Comment exécuter le projet
- Aller dans le dossier agent```bash
cd agent
2. Installer les dépendances```bash
pip install -r requirements.txt
- Lancer l’application
bash python main.py
📌 Description des fichiers
- main.py → Point principal pour démarrer l’application. Contient l’interface et lie l’agent avec cette interface.
- flow.py → Définition du flow de l’agent et instanciation des différents nodes.
- node_s.py → Contient les Nodes :
ToolMatcherNode→ Trouve le bon outil à utiliser.DecisionNode→ Décide l’action à entreprendre (via LLM).ExecuteNode→ Exécute l’outil sélectionné.- server_config.json → Configuration des serveurs MCP pour les démarrer et appeler leurs outils.
- utils.py → Fonctions utilitaires (appel LLM, génération d’embeddings, parsing, etc.).
- all_servers.json → Dataset MCP généré (conforme au schéma ci-dessus).
- server_summary.prompt → Prompt passé au LLM pour générer les résumés de serveurs.
