multi agent reasoning
1.0.0
Une solution basée sur Python qui utilise le raisonnement multi-agents , dans lequel plusieurs agents d'IA collaborent pour générer des réponses optimales aux invites des utilisateurs. En simulant les interactions entre agents et en intégrant le Swarm Framework for Intelligence , le système améliore les capacités de raisonnement pour fournir des réponses précises et raffinées. Des agents personnalisés peuvent être ajoutés via JSON, vous permettant de personnaliser leurs personnalités, leurs styles d'interaction, etc. Le système exploite la mise en cache des invites pour optimiser les performances et réduire la latence et les coûts des invites répétées.
Le script de raisonnement multi-agents crée une expérience de chatbot interactive dans laquelle plusieurs agents d'IA collaborent via un processus de raisonnement structuré pour fournir des réponses optimales. Chaque agent apporte des perspectives et une expertise uniques, et grâce à des étapes itératives de discussion, de vérification, de critique et d’affinement, ils convergent vers une réponse précise et de haute qualité.
De plus, le système intègre le Swarm Framework for Intelligence pour améliorer la collaboration entre les agents. Swarm permet aux agents de se coordonner efficacement, en tirant parti de l'intelligence collective pour résoudre des tâches complexes.
Les utilisateurs peuvent également discuter avec des agents individuels . Les agents connaissent les uns les autres, y compris leurs personnalités et leurs particularités, et peuvent répondre aux questions les uns sur les autres, offrant ainsi une expérience riche et interactive.
Clonez le dépôt :
git clone https://github.com/AdieLaine/multi-agent-reasoning.gitAccédez au répertoire du projet :
cd multi-agent-reasoningInstallez les packages requis :
pip install openai colorama tiktokenInstallez Swarm :
pip install git+ssh://[email protected]/openai/swarm.git
or
pip install git+https://github.com/openai/swarm.gitReportez-vous au référentiel GitHub de Swarm pour des instructions d'installation détaillées.
Définissez votre clé API OpenAI :
Définissez votre clé API comme variable d'environnement :
export OPENAI_API_KEY= ' your-api-key-here ' Vous pouvez également le définir directement dans votre script ou utiliser un fichier .env .
Exécutez le script en utilisant Python :
python reasoning.pyLors de l'exécution du script, un menu vous sera présenté :
═════════════════════════════════════════════════════════════════════════════════════════════
║ Multi-Agent Reasoning Chatbot ║
═════════════════════════════════════════════════════════════════════════════════════════════
Please select an option:
1. Chat with an agent
2. Use reasoning logic
3. Use Swarm-based reasoning
4. Exit
Enter your choice (1/2/3/4):
Option 1 : Discutez avec un agent
Option 2 : Utiliser la logique de raisonnement
Option 3 : Utiliser le raisonnement basé sur Swarm
Option 4 : Quitter
Le système de raisonnement multi-agents utilise des modèles OpenAI spécifiques :
o1-preview-2024-09-12 pour les tâches de raisonnement.gpt-4o pour les interactions de chat avec les agents.gpt-4o .Ces modèles prennent en charge des fonctionnalités avancées et des rapports sur l'utilisation des jetons, permettant au système de fournir des informations détaillées sur l'utilisation des jetons après chaque réponse.
Objectif : Permet à l'utilisateur de discuter directement avec un agent sélectionné.
Exemple :
Le cœur des fonctionnalités du chatbot réside dans le processus de raisonnement employé par les agents. Ce processus est conçu pour simuler un environnement collaboratif dans lequel les agents réfléchissent de manière critique, vérifient les faits, remettent en question les points de vue de chacun et affinent leurs réponses sur la base de commentaires constructifs.
Objectif : Les agents génèrent leurs réponses initiales à l'invite de l'utilisateur en fonction de leur raisonnement et de leurs connaissances individuelles.
Exemple :
Objectif : Les agents vérifient l'exactitude et la validité de leurs propres réponses pour garantir l'exactitude factuelle.
Exemple :
Objectif : Les agents critiquent les réponses vérifiées des autres pour identifier les domaines d'amélioration, les omissions ou les préjugés.
Exemple :
Objectif : Les agents affinent leurs propres réponses en intégrant les retours des critiques et en améliorant leur raisonnement initial.
Exemple :
Objectif : Combiner les réponses affinées de tous les agents en une réponse unique, cohérente et complète.
blend_responses .Exemple :
Objectif : Intégrer les retours de l'utilisateur pour affiner davantage la réponse, garantissant satisfaction et exactitude.
MAX_REFINEMENT_ATTEMPTS .Exemple :
Objectif : Permettre à la conversation de conserver son contexte à travers plusieurs invites utilisateur pour un dialogue cohérent.
Exemple :
L'intégration Swarm améliore le système de raisonnement multi-agents en permettant une coordination dynamique des agents et une délégation de tâches. Swarm permet aux agents de collaborer efficacement, en tirant parti de l'intelligence collective pour résoudre des tâches complexes et améliorer la réactivité.
Swarm s’efforce de rendre la coordination et l’exécution des agents légères, hautement contrôlables et facilement testables. Il y parvient grâce à deux abstractions primitives : Agents et Handoffs . Un agent comprend des instructions et des outils et peut, à tout moment, choisir de confier une conversation à un autre agent.
Initialisation du client Swarm : le système initialise un client Swarm pour gérer les interactions des agents.
from swarm import Agent , Swarm
client = Swarm ()Initialisation de l'agent :
agents.json .Gestion des conversations :
Objectif : Utiliser Swarm Framework for Intelligence pour coordonner les agents de manière dynamique, permettant une collaboration et une délégation de tâches efficaces.
Initialisation :
agents.json .Discussion :
client.run() de Swarm.Vérification :
Critique :
Raffinement :
Réponses mixtes :
blend_responses .Exemple :
Objectif : Fournir une interface de chat qui exploite les capacités de Swarm pour une interaction transparente avec les agents.
Agent Swarm pour le chat :
Gestion des conversations :
def swarm_chat_interface ( conversation_history ):
# Load Swarm agent's configuration
swarm_agent = ... # Initialize Swarm agent
messages = [{ "role" : "system" , "content" : swarm_agent . instructions }]
messages . extend ( conversation_history )
response = client . run ( agent = swarm_agent , messages = messages )
swarm_reply = response . messages [ - 1 ][ 'content' ]. strip ()
return swarm_replyRéponses dynamiques :
Exemple :
Conception des agents :
Définitions des fonctions :
Variables de contexte :
Gestion des erreurs :
Tests :
Qu’est-ce que Swarm et comment améliore-t-il le système ?
Dois-je modifier mes agents existants pour fonctionner avec Swarm ?
Agent Swarm. Les agents existants peuvent être adaptés en incorporant la structure et les conventions de Swarm.Puis-je ajouter plus d'agents au système Swarm ?
agents.json et les initialiser dans le système.Comment Swarm gère-t-il les transferts d’agents ?
Swarm est-il compatible avec les modèles utilisés dans le système ?
gpt-4o . La mise en cache des invites améliore l'efficacité du système de raisonnement multi-agents en réduisant la latence et les coûts lors du traitement d'invites répétées ou longues. Il fonctionne en mettant en cache les préfixes communs d'invites les plus longs, permettant un traitement plus rapide des demandes ultérieures qui réutilisent ces préfixes.
Durée du cache :
usage affichant les détails de l'utilisation du jeton. "usage" : {
"prompt_tokens" : 2006 ,
"completion_tokens" : 300 ,
"total_tokens" : 2306 ,
"prompt_tokens_details" : {
"cached_tokens" : 1920
},
"completion_tokens_details" : {
"reasoning_tokens" : 0
}
}cached_tokens indique combien de jetons d'invite ont été récupérés du cache. Les agents sont configurés via un fichier agents.json , permettant une personnalisation facile de leurs attributs.
Emplacement : Doit être placé dans le même répertoire que le script reasoning.py .
Structure :
{
"agents" : [
{
"name" : " Agent 47 " ,
"system_purpose" : " You are a logical and analytical assistant, focusing on facts and clear reasoning. " ,
"interaction_style" : { ... },
"ethical_conduct" : { ... },
"capabilities_limitations" : { ... },
"context_awareness" : { ... },
"adaptability_engagement" : { ... },
"responsiveness" : { ... },
"additional_tools_modules" : { ... },
"personality" : {
"logical" : " Yes " ,
"analytical" : " Yes " ,
"humor_style" : " ... " ,
"friendly_demeanor" : " ... " ,
"personality_traits" : [ " Methodical " , " Precise " ],
"empathy_level" : " Moderate " ,
"interaction_style_with_humor" : " Dry wit " ,
"quirks" : [ " Uses technical jargon " ]
}
},
{
"name" : " Agent 74 " ,
"system_purpose" : " You are a creative and empathetic assistant, emphasizing imaginative solutions and understanding. " ,
"interaction_style" : { ... },
"ethical_conduct" : { ... },
"capabilities_limitations" : { ... },
"context_awareness" : { ... },
"adaptability_engagement" : { ... },
"responsiveness" : { ... },
"additional_tools_modules" : { ... },
"personality" : {
"creative" : " Yes " ,
"empathetic" : " Yes " ,
"humor_style" : " ... " ,
"friendly_demeanor" : " ... " ,
"personality_traits" : [ " Imaginative " , " Caring " ],
"empathy_level" : " High " ,
"interaction_style_with_humor" : " Playful " ,
"quirks" : [ " Uses metaphors " ]
}
},
{
"name" : " Swarm Agent " ,
"system_purpose" : " You are a collaborative AI assistant composed of multiple expert agents. You coordinate tasks among agents to provide comprehensive and accurate responses. " ,
"interaction_style" : { ... },
"personality" : {
"coordinator" : " Yes " ,
"collaborative" : " Yes " ,
"personality_traits" : [ " Organized " , " Facilitator " ],
"quirks" : [ " Ensures all perspectives are considered " ]
}
}
]
}Personnalisation :
Exemple :
Le code est structuré pour faciliter à la fois le processus de raisonnement et les interactions par chat avec les agents. Il intègre également Swarm Framework pour une meilleure coordination des agents.
Bibliothèques :
os , time , logging , json : pour les opérations système, la synchronisation, la journalisation et la gestion JSON.colorama : Pour une sortie console colorée.swarm : Pour implémenter Swarm Intelligence.tiktoken : Pour un comptage précis des jetons (dans d'autres parties du script).Initialisation :
from swarm import Agent , Swarm
client = Swarm () Les agents sont initialisés à partir du fichier de configuration agents.json .
Chaque agent est créé en tant qu'instance Agent Swarm avec des instructions et des attributs spécifiques.
Les agents sont informés les uns des autres en ajoutant des informations sur les autres agents à leurs instructions.
def initialize_swarm_agents ():
# Load agents from agents.json and create Swarm agents
agents = []
# ... Load and initialize agents with awareness of others
return agents Fonction : swarm_chat_interface(conversation_history)
Objectif : Gère les interactions de chat avec l'agent Swarm.
Processus :
def swarm_chat_interface ( conversation_history ):
# Prepare messages
messages = [{ "role" : "system" , "content" : swarm_agent . instructions }]
messages . extend ( conversation_history )
# Run Swarm client
response = client . run ( agent = swarm_agent , messages = messages )
swarm_reply = response . messages [ - 1 ][ 'content' ]. strip ()
return swarm_reply Fonction : run_swarm_reasoning(user_prompt)
Objectif : utilise les agents Swarm pour collaborer et répondre à une invite utilisateur après plusieurs étapes de raisonnement.
Processus :
blend_responses combine les réponses affinées en une réponse finale.Traitement parallèle : Swarm permet aux agents d'effectuer ces étapes simultanément, améliorant ainsi l'efficacité.
Exemple de fonction de mélange :
def blend_responses ( agent_responses , user_prompt ):
# Prepare combined prompt
combined_prompt = ...
# Initialize Blender agent
blender_agent = Agent (
name = "Swarm Agent" ,
instructions = "You are a collaborative AI assistant composed of multiple expert agents."
)
# Run blending process
response = client . run ( agent = blender_agent , messages = [{ "role" : "user" , "content" : combined_prompt }])
blended_reply = response . messages [ - 1 ][ 'content' ]
return blended_replyswarm_middle_agent_interface(user_prompt) :run_swarm_reasoning avec l'invite de l'utilisateur.swarm_chat_interface(conversation_history) :Vous trouverez ci-dessous un organigramme mis à jour reflétant la nouvelle logique, y compris le mode de discussion, la connaissance mutuelle des agents, la transparence de l'utilisation des jetons, la mise en cache des invites et l'intégration de Swarm :
Les contributions sont les bienvenues ! Pour contribuer :
Ce projet est sous licence MIT.
Pour préparer le dépôt GitHub :
Créez un nouveau référentiel sur GitHub nommé multi-agent-reasoning .
Ajoutez le fichier README.md avec ce contenu.
Incluez le script reasoning.py dans le répertoire racine.
Incluez le fichier agents.json dans le répertoire racine.
Créez un fichier .gitignore pour exclure les fichiers inutiles :
# Exclude log files
reasoning.log
swarm_middle_agent.log
# Exclude environment files
.env
# Python cache
__pycache__ /
* .py [ cod ]Validez et transférez les fichiers vers GitHub.
multi-agent-reasoning/
├── README.md
├── reasoning.py
├── swarm_middle_agent.py
├── agents.json
├── LICENSE
├── .gitignore
└── img/
├── reasoningbanner.png
├── reasoningflow.png
├── agents.png
└── promptcache.png
└── swarm.png
N'hésitez pas à explorer le code, à personnaliser les agents et à interagir avec le chatbot Multi-Agent Reasoning !
Si vous avez des questions ou avez besoin d'aide, veuillez ouvrir un ticket sur GitHub.
