Adaptateur LangChain MCP - Présentation détaillée du projet
Aperçu du projet
L'adaptateur LangChain MCP est une bibliothèque wrapper légère conçue pour intégrer de manière transparente les outils du protocole de contenu de modèle (MCP) d'Anthropic avec les écosystèmes LangChain et LangGraph. Ce projet résout les problèmes de compatibilité entre différents frameworks d'outils d'IA, permettant aux développeurs d'utiliser directement les outils MCP dans un environnement LangChain/LangGraph, afin de construire des applications d'agents d'IA plus puissantes et flexibles.
Adresse du projet: https://github.com/langchain-ai/langchain-mcp-adapters
Fonctionnalités et caractéristiques principales
🔧 Conversion et adaptation d'outils
- Conversion d'outils MCP en outils LangChain: Conversion automatique des outils MCP au format d'outil LangChain.
- Intégration transparente: Les outils convertis peuvent être utilisés directement avec les agents LangGraph.
- Sécurité des types: Maintien des informations de type et de la validation des paramètres des outils d'origine.
- Support asynchrone: Support complet des opérations d'outils asynchrones.
📦 Client multi-serveurs
- Connexion multi-serveurs: Connexion simultanée à plusieurs serveurs MCP.
- Gestion unifiée des outils: Chargement et gestion des outils à partir de différents serveurs.
- Configuration du serveur: Prise en charge d'une configuration flexible des paramètres du serveur.
- Gestion du pool de connexions: Gestion efficace des ressources de connexion.
🌐 Support des protocoles de transport
- Transport STDIO: Prise en charge du protocole de transport d'entrée/sortie standard.
- Transport SSE: Prise en charge du protocole de transport d'événements envoyés par le serveur (Server-Sent Events).
- Mixte multi-protocoles: Différents serveurs peuvent utiliser différents protocoles de transport.
- Reconnexion automatique: Mécanisme de reconnexion automatique en cas de déconnexion.
🤖 Intégration LangGraph
- Agent React: Intégration parfaite avec l'agent React de LangGraph.
- Agent asynchrone: Prise en charge de l'exécution asynchrone des agents.
- Combinaison de chaînes d'outils: Prise en charge de chaînes d'outils et de workflows complexes.
- Gestion de l'état: Maintien de l'état d'exécution de l'agent.
Architecture technique
Composants principaux
Application LangChain/LangGraph
↓
Adaptateurs LangChain MCP
↓
Implémentation du client MCP
↓
Plusieurs serveurs MCP (Math, Météo, etc.)
Processus de conversion des outils
- Découverte des outils MCP: Obtention de la liste des outils disponibles à partir du serveur MCP.
- Analyse des métadonnées des outils: Analyse du nom, de la description et des paramètres des outils.
- Création d'outils LangChain: Création d'objets d'outils LangChain compatibles.
- Intégration de l'agent: Enregistrement des outils dans l'agent LangGraph.
- Redirection de l'exécution: Redirection des appels d'outils LangChain vers le serveur MCP.
Installation et utilisation
Installation rapide
# Installation de base
pip install langchain-mcp-adapters
# Environnement de développement complet
pip install langchain-mcp-adapters langgraph langchain-openai
Configuration de l'environnement
# Définir la clé API OpenAI
export OPENAI_API_KEY=<votre_clé_api>
Exemples d'utilisation
Exemple de base : Serveur mathématique
1. Créer un serveur MCP
# math_server.py
from mcp.server.fastmcp import FastMCP
mcp = FastMCP("Math")
@mcp.tool()
def add(a: int, b: int) -> int:
"""Add two numbers"""
return a + b
@mcp.tool()
def multiply(a: int, b: int) -> int:
"""Multiply two numbers"""
return a * b
if __name__ == "__main__":
mcp.run(transport="stdio")
2. Créer un agent LangGraph
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from langchain_mcp_adapters.tools import load_mcp_tools
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
# Initialiser le modèle
model = ChatOpenAI(model="gpt-4o")
# Configurer les paramètres du serveur
server_params = StdioServerParameters(
command="python",
args=["/path/to/math_server.py"],
)
# Créer et exécuter l'agent
async with stdio_client(server_params) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
# Charger les outils MCP
tools = await load_mcp_tools(session)
# Créer l'agent
agent = create_react_agent(model, tools)
# Exécuter la requête
response = await agent.ainvoke({
"messages": "what's (3 + 5) x 12?"
})
Exemple avancé : Intégration multi-serveurs
1. Serveur météo
# weather_server.py
from mcp.server.fastmcp import FastMCP
mcp = FastMCP("Weather")
@mcp.tool()
async def get_weather(location: str) -> str:
"""Get weather for location."""
return f"It's always sunny in {location}"
if __name__ == "__main__":
mcp.run(transport="sse")
2. Client multi-serveurs
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
model = ChatOpenAI(model="gpt-4o")
# Configuration multi-serveurs
async with MultiServerMCPClient({
"math": {
"command": "python",
"args": ["/path/to/math_server.py"],
"transport": "stdio",
},
"weather": {
"url": "http://localhost:8000/sse",
"transport": "sse",
}
}) as client:
# Créer l'agent
agent = create_react_agent(model, client.get_tools())
# Opération mathématique
math_response = await agent.ainvoke({
"messages": "what's (3 + 5) x 12?"
})
# Requête météo
weather_response = await agent.ainvoke({
"messages": "what is the weather in NYC?"
})
Intégration du serveur API LangGraph
1. Fichier de configuration du graphe
# graph.py
from contextlib import asynccontextmanager
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_anthropic import ChatAnthropic
model = ChatAnthropic(model="claude-3-5-sonnet-latest")
@asynccontextmanager
async def make_graph():
async with MultiServerMCPClient({
"math": {
"command": "python",
"args": ["/path/to/math_server.py"],
"transport": "stdio",
},
"weather": {
"url": "http://localhost:8000/sse",
"transport": "sse",
}
}) as client:
agent = create_react_agent(model, client.get_tools())
yield agent
2. Configuration LangGraph
{
"dependencies": ["."],
"graphs": {
"agent": "./graph.py:make_graph"
}
}
Cas d'utilisation et avantages
🎯 Cas d'utilisation
Agents d'IA d'entreprise
- Intégration multifonctionnelle: Intégration de divers outils et API métier.
- Automatisation des flux de travail: Construction d'une automatisation complexe des processus métier.
- Traitement des données: Intégration de différentes sources de données et outils de traitement.
Chaîne d'outils pour développeurs
- Génération de code: Intégration d'outils de génération et d'analyse de code.
- Automatisation des tests: Construction d'agents de test intelligents.
- Intégration DevOps: Automatisation du déploiement et de la surveillance.
Recherche et éducation
- Calcul scientifique: Intégration d'outils de calcul mathématique et scientifique.
- Analyse de données: Construction d'assistants d'analyse de données intelligents.
- Assistant pédagogique: Création d'outils d'apprentissage interactifs.
✨ Avantages techniques
Interopérabilité de l'écosystème
- Interface standardisée: Respect du protocole standard MCP.
- Large compatibilité: Intégration transparente avec l'écosystème LangChain.
- Extensibilité: Prise en charge de l'extension d'outils et de protocoles personnalisés.
Amélioration de l'efficacité du développement
- Intégration rapide: Intégration des outils MCP en quelques lignes de code.
- Sécurité des types: Conseils de type et validation complets.
- Gestion des erreurs: Gestion des erreurs et mécanisme de nouvelle tentative améliorés.
Performance et fiabilité
- Support asynchrone: Opérations asynchrones hautes performances.
- Gestion des connexions: Pool de connexions intelligent et mécanisme de reconnexion.
- Optimisation des ressources: Utilisation et gestion efficaces des ressources.
Spécifications techniques
Versions de protocole prises en charge
- Protocole MCP: Compatible avec les dernières spécifications du protocole MCP.
- LangChain: Prise en charge de LangChain version 0.1+.
- LangGraph: Prise en charge de la dernière version de LangGraph.
Protocoles de transport
- STDIO: Transport d'entrée/sortie standard.
- SSE: Événements envoyés par le serveur.
- HTTP: API RESTful basée sur HTTP.
- WebSocket: Communication bidirectionnelle en temps réel (en cours de planification).
Support des types d'outils
- Outils synchrones: Outils de fonction synchrone traditionnels.
- Outils asynchrones: Outils asynchrones hautes performances.
- Outils de streaming: Prise en charge de la sortie en streaming.
- Outils d'état: Outils prenant en charge la gestion de l'état.
Bonnes pratiques
🔧 Conseils de développement
Conception des outils
- Fonctionnalité unique: Chaque outil se concentre sur une seule fonctionnalité.
- Paramètres clairs: Fournir une description et un type de paramètres clairs.
- Gestion des erreurs: Mettre en œuvre une logique de gestion des erreurs améliorée.
- Documentation complète: Fournir une documentation détaillée de l'outil.
Optimisation des performances
- Réutilisation des connexions: Réutiliser les connexions au serveur MCP.
- Priorité asynchrone: Utiliser en priorité les outils et opérations asynchrones.
- Gestion des ressources: Libérer rapidement les ressources inutiles.
- Stratégie de cache: Utiliser le cache de manière appropriée pour améliorer les performances.
Considérations de sécurité
- Contrôle d'accès: Mettre en œuvre des contrôles d'accès appropriés.
- Validation des entrées: Valider strictement les paramètres d'entrée.
- Journalisation: Enregistrer les opérations et les erreurs critiques.
- Gestion des clés: Gérer en toute sécurité les clés API et les informations d'identification.
Conclusion
Le projet d'adaptateur LangChain MCP est une infrastructure importante dans l'écosystème des outils d'IA, qui a réussi à combler le fossé entre le protocole MCP et le framework LangChain. Grâce à cet adaptateur, les développeurs peuvent :
🎯 Valeur fondamentale
- Écosystème d'outils unifié: Unifier les outils d'IA sous différents protocoles dans l'écosystème LangChain.
- Amélioration de l'efficacité du développement: Réduire considérablement la complexité et la charge de travail du développement d'agents d'IA.
- Extensibilité des fonctionnalités: Intégrer facilement divers outils et services tiers.
- Support standardisé: Respecter les normes de l'industrie pour assurer une compatibilité à long terme.
🌟 Points forts du projet
- Conception légère: Dépendances minimales, faciles à intégrer et à déployer.
- Fonctionnalité complète: Couvre l'ensemble du processus, de la conversion des outils à l'exécution de l'agent.
- Prêt pour la production: Fournit une stabilité et des performances de niveau entreprise.
- Piloté par la communauté: Communauté open source active et itération continue des fonctionnalités.
🔮 Perspectives d'application
Avec le développement rapide de la technologie des agents d'IA, l'intégration et l'interopérabilité des outils deviendront de plus en plus importantes. L'adaptateur LangChain MCP, en tant que pont reliant différents écosystèmes d'outils d'IA, jouera un rôle clé dans le futur développement d'applications d'IA. Il simplifie non seulement les processus de développement actuels, mais jette également des bases solides pour la construction d'applications d'agents d'IA plus intelligentes et riches en fonctionnalités.
Que vous soyez un développeur d'applications d'IA, un décideur technique d'entreprise ou un chercheur, ce projet mérite d'être étudié et appliqué en profondeur. Il représente les meilleures pratiques dans le domaine de l'intégration des outils d'IA et vous aidera à construire des solutions d'IA plus puissantes et flexibles.