English | 简体中文 | 日本語 | Español | Deutsch | Français
Implémentation officielle Python du protocole Google Agent-to-Agent (A2A), avec intégration du Model Context Protocol (MCP)
Python A2A est une bibliothèque complète et prête pour la production pour implémenter le protocole Agent-to-Agent (A2A) de Google, avec un support complet pour le Model Context Protocol (MCP). Elle fournit toutes les fonctionnalités nécessaires pour construire un écosystème d'agents d'IA interoperables capables de collaborer en douceur pour résoudre des problèmes complexes.
Le protocole A2A établit un format de communication standard permettant aux agents d'IA d'interagir, tandis que le MCP étend cette capacité en fournissant une méthode standardisée pour que les agents accèdent à des outils et des sources de données externes. Python A2A rend ces protocoles faciles à utiliser via une API intuitive, permettant aux développeurs de construire des systèmes d'agents d'IA complexes.
- Découverte d'agents: Support intégré pour le registre et la découverte d'agents avec une compatibilité totale avec le protocole A2A de Google
- Intégration LangChain: Intégration fluide avec les outils et agents de LangChain
- Écosystème d'outils étendu: Utilisez des outils provenant à la fois de LangChain et de MCP dans n'importe quel agent
- Interopérabilité accrue des agents: Conversion entre agents A2A et agents LangChain
- Moteur de workflow hybride: Création de workflows combinant les deux écosystèmes
- Développement simplifié des agents: Accès immédiat à des milliers d'outils prédéfinis
- Architecture de streaming avancée: Streaming amélioré avec les événements envoyés par le serveur (SSE), un meilleur gestion des erreurs et des mécanismes de secours robustes
- Streaming basé sur les tâches: Nouvelle méthode
tasks_send_subscribepour le streaming des mises à jour de tâches en temps réel - API de gestion des blocs de streaming: Amélioration de la gestion des blocs avec la classe
StreamingChunkpour des données structurées - Support multi-point de terminaison: Découverte automatique et mécanismes de secours entre plusieurs points de terminaison de streaming
- Système de réseau d'agents: Gestion et découverte de multiples agents avec la nouvelle classe
AgentNetwork - Streaming en temps réel: Implémentation de réponses en streaming avec
StreamingClientpour des interfaces utilisateur réactives - Moteur de workflow: Définition de workflows complexes de multiples agents à l'aide de l'API fluide avec des branchements conditionnels et une exécution parallèle
- Routeur d'IA: Routage automatique des requêtes vers l'agent le plus approprié avec
AIAgentRouter - Interface en ligne de commande: Contrôle des agents depuis le terminal avec l'outil CLI
- Support asynchrone amélioré: Meilleure prise en charge de async/await à travers toute la bibliothèque
- Nouvelles options de connexion: Gestion améliorée des erreurs et logique de réessai pour une communication d'agents plus robuste
- Implémentation complète: Implémente intégralement la spécification A2A officielle sans compromis
- Découverte d'agents: Registre et découverte d'agents intégrés pour la création d'écosystèmes d'agents
- Intégration MCP: Support de premier plan pour le Model Context Protocol pour des agents utilisant des outils puissants
- Prêt pour l'entreprise: Conçu pour les environnements de production avec une gestion robuste des erreurs et une validation rigoureuse
- Indépendant du framework: Fonctionne avec n'importe quel framework Python (Flask, FastAPI, Django, etc.)
- Flexibilité du fournisseur LLM: Intégrations natives avec OpenAI, Anthropic, AWS Bedrock, et plus encore
- Dépendances minimales: La fonctionnalité de base nécessite uniquement la bibliothèque
requests - Expérience développeur exceptionnelle: Documentation complète, indices de type et exemples
Installez le paquet de base avec toutes les dépendances:
pip install python-a2a # Inclut LangChain, MCP et d'autres intégrationsOu installez des composants spécifiques selon vos besoins:
# Pour le support du serveur basé sur Flask
pip install "python-a2a[server]"
# Pour l'intégration OpenAI
pip install "python-a2a[openai]"
# Pour l'intégration Anthropic Claude
pip install "python-a2a[anthropic]"
# Pour l'intégration AWS-Bedrock
pip install "python-a2a[bedrock]"
# Pour le support MCP (Model Context Protocol)
pip install "python-a2a[mcp]"
# Pour toutes les dépendances optionnelles
pip install "python-a2a[all]"UV est un outil moderne de gestion de paquets Python plus rapide et plus fiable que pip. Pour installer avec UV:
# Installez UV si ce n'est pas déjà fait
curl -LsSf https://astral.sh/uv/install.sh | sh
# Installez le paquet de base
uv install python-a2aPour le développement, UV est recommandé pour sa vitesse:
# Clonez le dépôt
git clone https://github.com/themanojdesai/python-a2a.git
cd python-a2a
# Créez un environnement virtuel et installez les dépendances de développement
uv venv
source .venv/bin/activate # Sous Windows: .venv\Scripts\activate
uv pip install -e ".[dev]"💡 Astuce: Cliquez sur les blocs de code pour les copier dans votre presse-papiers.
from python_a2a import A2AServer, skill, agent, run_server, TaskStatus, TaskState
@agent(
name="Weather Agent",
description="Provides weather information",
version="1.0.0"
)
class WeatherAgent(A2AServer):
@skill(
name="Get Weather",
description="Get current weather for a location",
tags=["weather", "forecast"]
)
def get_weather(self, location):
"""Get weather for a location."""
# Implémentation fictive
return f"It's sunny and 75°F in {location}"
def handle_task(self, task):
# Extraire l'emplacement à partir du message
message_data = task.message or {}
content = message_data.get("content", {})
text = content.get("text", "") if isinstance(content, dict) else ""
if "weather" in text.lower() and "in" in text.lower():
location = text.split("in", 1)[1].strip().rstrip("?.")
# Obtenir la météo et créer une réponse
weather_text = self.get_weather(location)
task.artifacts = [{
"parts": [{"type": "text", "text": weather_text}]
}]
task.status = TaskStatus(state=TaskState.COMPLETED)
else:
task.status = TaskStatus(
state=TaskState.INPUT_REQUIRED,
message={"role": "agent", "content": {"type": "text",
"text": "Please ask about weather in a specific location."}}
)
return task
# Démarrer le serveur
if __name__ == "__main__":
agent = WeatherAgent()
run_server(agent, port=5000)from python_a2a import AgentNetwork, A2AClient, AIAgentRouter
# Créer un réseau d'agents
network = AgentNetwork(name="Travel Assistant Network")
# Ajouter des agents au réseau
network.add("weather", "http://localhost:5001")
network.add("hotels", "http://localhost:5002")
network.add("attractions", "http://localhost:5003")
# Créer un routeur pour diriger intelligemment les requêtes vers l'agent le plus approprié
router = AIAgentRouter(
llm_client=A2AClient("http://localhost:5000/openai"), # LLM pour les décisions de routage
agent_network=network
)
# Router une requête vers l'agent approprié
agent_name, confidence = router.route_query("What's the weather like in Paris?")
print(f"Routage vers {agent_name} avec {confidence:.2f} de confiance")
# Obtenir l'agent sélectionné et poser la question
agent = network.get_agent(agent_name)
response = agent.ask("What's the weather like in Paris?")
print(f"Réponse: {response}")
# Lister tous les agents disponibles
print("\nAgents disponibles:")
for agent_info in network.list_agents():
print(f"- {agent_info['name']}: {agent_info['description']}")Obtenir des réponses en temps réel des agents avec un support de streaming complet:
import asyncio
from python_a2a import StreamingClient, Message, TextContent, MessageRole
async def main():
client = StreamingClient("http://localhost:5000")
# Créer un message avec le paramètre role requis
message = Message(
content=TextContent(text="Tell me about A2A streaming"),
role=MessageRole.USER
)
# Streamer la réponse et traiter les blocs en temps réel
try:
async for chunk in client.stream_response(message):
# Gérer différents formats de blocs (chaîne ou dictionnaire)
if isinstance(chunk, dict):
if "content" in chunk:
print(chunk["content"], end="", flush=True)
elif "text" in chunk:
print(chunk["text"], end="", flush=True)
else:
print(str(chunk), end="", flush=True)
else:
print(str(chunk), end="", flush=True)
except Exception as e:
print(f"Erreur de streaming: {e}")Consultez le répertoire examples/streaming/ pour des exemples complets de streaming:
- basic_streaming.py: Implémentation minimale de streaming (commencez ici!)
- 01_basic_streaming.py: Introduction complète aux bases du streaming
- 02_advanced_streaming.py: Streaming avancé avec différentes stratégies de blocage
- 03_streaming_llm_integration.py: Intégration du streaming avec les fournisseurs LLM
- 04_task_based_streaming.py: Streaming basé sur les tâches avec suivi de progression
- 05_streaming_ui_integration.py: Intégration du streaming avec les interfaces utilisateur (CLI et web)
- 06_distributed_streaming.py: Architecture de streaming distribué
Le nouveau moteur de workflow permet de définir des interactions complexes entre agents:
from python_a2a import AgentNetwork, Flow
import asyncio
async def main():
# Configurer le réseau d'agents
network = AgentNetwork()
network.add("research", "http://localhost:5001")
network.add("summarizer", "http://localhost:5002")
network.add("factchecker", "http://localhost:5003")
# Définir un workflow pour la génération de rapports de recherche
flow = Flow(agent_network=network, name="Research Report Workflow")
# D'abord, collecter la recherche initiale
flow.ask("research", "Research the latest developments in {topic}")
# Ensuite, traiter les résultats en parallèle
parallel_results = (flow.parallel()
# Branche 1: Créer un résumé
.ask("summarizer", "Summarize this research: {latest_result}")
# Branche 2: Vérifier les faits clés
.branch()
.ask("factchecker", "Verify these key facts: {latest_result}")
# Fin du traitement parallèle et collecte des résultats
.end_parallel(max_concurrency=2))
# Extraire des insights basés sur les résultats de vérification
flow.execute_function(
lambda results, context: f"Summary: {results['1']}\nVerified Facts: {results['2']}",
parallel_results
)
# Exécuter le workflow
result = await flow.run({
"topic": "quantum computing advancements in the last year"
})
print(result)
if __name__ == "__main__":
asyncio.run(main())Routage intelligent pour sélectionner l'agent le plus approprié pour chaque requête:
from python_a2a import AgentNetwork, AIAgentRouter, A2AClient
import asyncio
async def main():
# Créer un réseau avec des agents spécialisés
network = AgentNetwork()
network.add("math", "http://localhost:5001")
network.add("history", "http://localhost:5002")
network.add("science", "http://localhost:5003")
network.add("literature", "http://localhost:5004")
# Créer un routeur utilisant un LLM pour la prise de décision
router = AIAgentRouter(
llm_client=A2AClient("http://localhost:5000/openai"),
agent_network=network
)
# Exemples de requêtes à router
queries = [
"What is the formula for the area of a circle?",
"Who wrote The Great Gatsby?",
"When did World War II end?",
"How does photosynthesis work?",
"What are Newton's laws of motion?"
]
# Router chaque requête vers l'agent le plus approprié
for query in queries:
agent_name, confidence = router.route_query(query)
agent = network.get_agent(agent_name)
print(f"Requête: {query}")
print(f"Routée vers: {agent_name} (confiance: {confidence:.2f})")
# Obtenir la réponse de l'agent sélectionné
response = agent.ask(query)
print(f"Réponse: {response[:100]}...\n")
if __name__ == "__main__":
asyncio.run(main())from python_a2a import AgentNetwork, Flow, AIAgentRouter
import asyncio
async def main():
# Créer un réseau d'agents
network = AgentNetwork()
network.add("weather", "http://localhost:5001")
network.add("recommendations", "http://localhost:5002")
network.add("booking", "http://localhost:5003")
# Créer un routeur
router = AIAgentRouter(
llm_client=network.get_agent("weather"), # Utiliser un agent comme LLM pour le routage
agent_network=network
)
# Définir un workflow avec de la logique conditionnelle
flow = Flow(agent_network=network, router=router, name="Travel Planning Workflow")
# Commencer par obtenir la météo
flow.ask("weather", "What's the weather in {destination}?")
# Branche conditionnelle basée sur la météo
flow.if_contains("sunny")
# Si ensoleillé, recommander des activités en plein air
flow.ask("recommendations", "Recommend outdoor activities in {destination}")
# Fin de la condition et ajout d'une branche else
flow.else_branch()
# Si non ensoleillé, recommander des activités en intérieur
flow.ask("recommendations", "Recommend indoor activities in {destination}")
# Fin du bloc if-else
flow.end_if()
# Ajouter des étapes de traitement parallèle
(flow.parallel()
.ask("booking", "Find hotels in {destination}")
.branch()
.ask("booking", "Find restaurants in {destination}")
.end_parallel())
# Exécuter le workflow avec un contexte initial
result = await flow.run({
"destination": "Paris",
"travel_dates": "June 12-20"
})
print("Résultat du workflow:")
print(result)
if __name__ == "__main__":
asyncio.run(main())# Envoyer un message à un agent
a2a send http://localhost:5000 "What is artificial intelligence?"
# Streamer une réponse en temps réel
a2a stream http://localhost:5000 "Generate a step-by-step tutorial for making pasta"
# Démarrer un serveur A2A alimenté par OpenAI
a2a openai --model gpt-4 --system-prompt "You are a helpful coding assistant"
# Démarrer un serveur A2A alimenté par Anthropic
a2a anthropic --model claude-3-opus-20240229 --system-prompt "You are a friendly AI teacher"
# Démarrer un serveur MCP avec des outils
a2a mcp-serve --name "Data Analysis MCP" --port 5001 --script analysis_tools.py
# Démarrer un agent A2A avec MCP
a2a mcp-agent --servers data=http://localhost:5001 calc=http://localhost:5002
# Appeler un outil MCP directement
a2a mcp-call http://localhost:5001 analyze_csv --params file=data.csv columns=price,date
# Gérer les réseaux d'agents
a2a network --add weather=http://localhost:5001 travel=http://localhost:5002 --save network.json
# Exécuter un workflow à partir d'un script
a2a workflow --script research_workflow.py --context initial_data.jsonPython A2A inclut une intégration LangChain intégrée, facilitant la combinaison des meilleures fonctionnalités des deux écosystèmes:
from python_a2a.mcp import FastMCP, text_response
from python_a2a.langchain import to_langchain_tool
# Créer un serveur MCP avec un outil
mcp_server = FastMCP(name="Basic Tools", description="Simple utility tools")
@mcp_server.tool(
name="calculator",
description="Calculate a mathematical expression"
)
def calculator(input):
"""Simple calculator that evaluates an expression."""
try:
result = eval(input)
return text_response(f"Result: {result}")
except Exception as e:
return text_response(f"Error: {e}")
# Démarrer le serveur
import threading, time
def run_server(server, port):
server.run(host="0.0.0.0", port=port)
server_thread = threading.Thread(target=run_server, args=(mcp_server, 5000), daemon=True)
server_thread.start()
time.sleep(2) # Permettre au serveur de démarrer
# Convertir l'outil MCP vers LangChain
calculator_tool = to_langchain_tool("http://localhost:5000", "calculator")
# Utiliser l'outil dans LangChain
result = calculator_tool.run("5 * 9 + 3")
print(f"Résultat: {result}")from langchain.tools import Tool
from langchain_core.tools import BaseTool
from python_a2a.langchain import to_mcp_server
# Créer des outils LangChain
def calculator(expression: str) -> str:
"""Evaluate a mathematical expression"""
try:
result = eval(expression)
return f"Result: {expression} = {result}"
except Exception as e:
return f"Error: {e}"
calculator_tool = Tool(
name="calculator",
description="Evaluate a mathematical expression",
func=calculator
)
# Convertir vers un serveur MCP
mcp_server = to_mcp_server(calculator_tool)
# Démarrer le serveur
mcp_server.run(port=5000)from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import PromptTemplate
from python_a2a import A2AClient, run_server
from python_a2a.langchain import to_a2a_server
# Créer un LLM LangChain
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
# Convertir le LLM vers un serveur A2A
llm_server = to_a2a_server(llm)
# Créer une chaîne simple
template = "You are a helpful travel guide.\n\nQuestion: {query}\n\nAnswer:"
prompt = PromptTemplate.from_template(template)
travel_chain = prompt | llm | StrOutputParser()
# Convertir la chaîne vers un serveur A2A
travel_server = to_a2a_server(travel_chain)
# Démarrer les serveurs dans des threads d'arrière-plan
import threading
llm_thread = threading.Thread(
target=lambda: run_server(llm_server, port=5001),
daemon=True
)
llm_thread.start()
travel_thread = threading.Thread(
target=lambda: run_server(travel_server, port=5002),
daemon=True
)
travel_thread.start()
# Tester les serveurs
llm_client = A2AClient("http://localhost:5001")
travel_client = A2AClient("http://localhost:5002")
llm_result = llm_client.ask("What is the capital of France?")
travel_result = travel_client.ask('{"query": "What are some must-see attractions in Paris?"}')from python_a2a.langchain import to_langchain_agent
# Convertir un agent A2A vers un agent LangChain
langchain_agent = to_langchain_agent("http://localhost:5000")
# Utiliser l'agent dans LangChain
result = langchain_agent.invoke("What are some famous landmarks in Paris?")
print(result.get('output', ''))
# Utiliser dans un pipeline LangChain
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
llm = ChatOpenAI(temperature=0)
prompt = ChatPromptTemplate.from_template(
"Generate a specific, detailed travel question about {destination}."
)
# Créer un pipeline avec l'agent converti
chain = (
prompt |
llm |
StrOutputParser() |
langchain_agent |
(lambda x: f"Travel Info: {x.get('output', '')}")
)
result = chain.invoke({"destination": "Japan"})
print(result)LangChain est automatiquement installé en tant que dépendance avec python-a2a, donc tout fonctionne immédiatement:
pip install python-a2a
# C'est tout! LangChain est inclus automatiquementPython A2A inclut maintenant un système puissant pour gérer plusieurs agents:
from python_a2a import AgentNetwork, A2AClient
# Créer un réseau d'agents
network = AgentNetwork(name="Medical Assistant Network")
# Ajouter des agents de différentes manières
network.add("diagnosis", "http://localhost:5001") # À partir d'une URL
network.add("medications", A2AClient("http://localhost:5002")) # À partir d'une instance client
# Découvrir des agents à partir d'une liste d'URLs
discovered_count = network.discover_agents([
"http://localhost:5003",
"http://localhost:5004",
"http://localhost:5005"
])
print(f"{discovered_count} nouveaux agents découverts")
# Lister tous les agents dans le réseau
for agent_info in network.list_agents():
print(f"Agent: {agent_info['name']}")
print(f"URL: {agent_info['url']}")
if 'description' in agent_info:
print(f"Description: {agent_info['description']}")
print()
# Obtenir un agent spécifique
agent = network.get_agent("diagnosis")
response = agent.ask("What are the symptoms of the flu?")from python_a2a import AgentCard, A2AServer, run_server
from python_a2a.discovery import AgentRegistry, run_registry, enable_discovery, DiscoveryClient
import threading
import time
# Créer un serveur de registre
registry = AgentRegistry(
name="A2A Registry Server",
description="Registre central pour la découverte d'agents"
)
# Démarrer le registre dans un thread d'arrière-plan
registry_port = 8000
thread = threading.Thread(
target=lambda: run_registry(registry, host="0.0.0.0", port=registry_port),
daemon=True
)
thread.start()
time.sleep(1) # Permettre au registre de démarrer
# Créer un agent d'exemple
agent_card = AgentCard(
name="Weather Agent",
description="Provides weather information",
url="http://localhost:8001",
version="1.0.0",
capabilities={
"weather_forecasting": True,
"google_a2a_compatible": True # Activer la compatibilité A2A de Google
}
)
agent = A2AServer(agent_card=agent_card)
# Activer la découverte - cela enregistre l'agent dans le registre
registry_url = f"http://localhost:{registry_port}"
discovery_client = enable_discovery(agent, registry_url=registry_url)
# Démarrer l'agent dans un thread séparé
agent_thread = threading.Thread(
target=lambda: run_server(agent, host="0.0.0.0", port=8001),
daemon=True
)
agent_thread.start()
time.sleep(1) # Permettre à l'agent de démarrer
# Créer un client de découverte pour trouver des agents
client = DiscoveryClient(agent_card=None) # Aucune carte d'agent nécessaire pour la découverte seule
client.add_registry(registry_url)
# Découvrir tous les agents
agents = client.discover()
print(f"{len(agents)} agents découverts:")
for agent in agents:
print(f"- {agent.name} à {agent.url}")
print(f" Capacités: {agent.capabilities}")Python A2A est construit sur trois principes de conception clés:
-
Protocole en premier: Respect strict des spécifications des protocoles A2A et MCP pour une interopérabilité maximale
-
Modularité: Tous les composants sont conçus pour être composable et remplaçable
-
Amélioration progressive: Commencer simple et ajouter de la complexité uniquement si nécessaire
L'architecture se compose de huit composants principaux:
- Modèles: Structures de données représentant les messages A2A, les tâches et les cartes d'agents
- Client: Composants pour envoyer des messages aux agents A2A et gérer les réseaux d'agents
- Serveur: Composants pour construire des agents compatibles A2A
- Découverte: Mécanismes de registre et de découverte pour les écosystèmes d'agents
- MCP: Outils pour implémenter des serveurs et clients du Model Context Protocol
- LangChain: Composants pont pour l'intégration LangChain
- Workflow: Moteur pour orchestrer des interactions complexes entre agents
- Utils: Fonctions d'aide pour les tâches courantes
- CLI: Interface en ligne de commande pour interagir avec les agents
Python A2A peut être utilisé pour construire une vaste gamme de systèmes d'IA:
- Cadre d'expérimentation: Échange facile entre différents backends LLM tout en maintenant la même interface d'agent
- Benchmarks: Comparer les performances des différentes implémentations d'agents sur des tâches standardisées
- Assistants de recherche en streaming: Créer des outils de recherche réactifs avec une sortie en temps réel via le streaming
- Orchestration d'IA: Coordonner plusieurs agents d'IA entre différents départements via des réseaux d'agents
- Intégration de systèmes hérités: Emballer les systèmes hérités avec des interfaces A2A pour une accessibilité à l'IA
- Workflows complexes: Créer des processus métier sophistiqués avec des workflows multi-agents et des branchements conditionnels
- Assistants multi-étapes: Découper les requêtes complexes des utilisateurs en sous-tâches gérées par des agents spécialisés
- Agents utilisant des outils: Connecter des LLM à des agents de base de données, des agents de calcul, etc. via le MCP
- Interfaces de chat en temps réel: Construire des applications de chat réactives avec un support de réponse en streaming
- Éducation en IA: Créer des systèmes éducatifs démontrant la collaboration entre agents
- Environnements de simulation: Construire des environnements simulés où plusieurs agents interagissent
- Workflows éducatifs: Concevoir des processus d'apprentissage étape par étape avec des boucles de feedback
Consultez le répertoire examples/ pour des exemples concrets, y compris:
- Systèmes de support client multi-agents
- Assistants de recherche alimentés par LLM avec accès aux outils
- Implémentations de streaming en temps réel
- Exemples d'intégration LangChain
- Implémentations de serveurs MCP pour divers outils
- Exemples d'orchestration de workflows
- Gestion de réseaux d'agents
Voici quelques projets liés dans l'espace des agents d'IA et de l'interopérabilité:
- Google A2A - La spécification officielle du protocole A2A de Google
- LangChain - Framework pour construire des applications avec des LLM
- AutoGen - Framework de Microsoft pour les conversations multi-agents
- CrewAI - Framework pour orchestrer des agents de rôle
- MCP - Le Model Context Protocol pour les agents utilisant des outils
Merci à tous nos contributeurs!
Souhaitez-vous contribuer? Consultez notre guide de contribution.
- GitHub Issues: Signaler des bugs ou demander des fonctionnalités
- GitHub Discussions: Poser des questions et partager des idées
- Guide de contribution: Apprendre comment contribuer au projet
- ReadTheDocs: Visitez notre site de documentation
Si vous utilisez Python A2A dans vos travaux de recherche ou académiques, veuillez le citer comme suit:
@software{desai2025pythona2a,
author = {Desai, Manoj},
title = {Python A2A: A Comprehensive Implementation of the Agent-to-Agent Protocol},
url = {https://github.com/themanojdesai/python-a2a},
version = {0.5.0},
year = {2025},
}
Si vous trouvez cette bibliothèque utile, n'hésitez pas à lui donner une étoile sur GitHub! Cela aide les autres à la découvrir et motive le développement ultérieur.
- À l'équipe Google A2A pour avoir créé le protocole A2A
- À l'équipe Contextual AI pour le Model Context Protocol
- À l'équipe LangChain pour leur framework puissant de LLM
- À tous nos contributeurs pour leurs précieux commentaires
Manoj Desai
- GitHub: themanojdesai
- LinkedIn: themanojdesai
- Medium: @the_manoj_desai
Ce projet est sous licence MIT - voir le fichier LICENSE pour plus de détails.
Créé avec ❤️ par Manoj Desai