multi agent reasoning
1.0.0
Uma solução baseada em Python que emprega raciocínio multiagente , onde vários agentes de IA colaboram para gerar respostas ideais às solicitações do usuário. Ao simular interações entre agentes e integrar o Swarm Framework for Intelligence , o sistema aprimora as capacidades de raciocínio para fornecer respostas precisas e refinadas. Agentes personalizados podem ser adicionados via JSON, permitindo personalizar suas personalidades, estilos de interação e muito mais. O sistema aproveita o cache de prompts para otimizar o desempenho e reduzir a latência e os custos de prompts repetidos.
O script Multi-Agent Reasoning cria uma experiência de chatbot interativa onde vários agentes de IA colaboram por meio de um processo de raciocínio estruturado para fornecer respostas ideais. Cada agente traz perspectivas e conhecimentos únicos e, através de etapas iterativas de discussão, verificação, crítica e refinamento, eles convergem para uma resposta precisa e de alta qualidade.
Além disso, o sistema integra o Swarm Framework for Intelligence para melhorar a colaboração entre os agentes. O Swarm permite que os agentes coordenem de forma eficiente, aproveitando a inteligência coletiva para resolver tarefas complexas.
Os usuários também podem conversar com agentes individuais . Os agentes conhecem uns aos outros, incluindo suas personalidades e peculiaridades, e podem responder perguntas uns sobre os outros, proporcionando uma experiência rica e interativa.
Clone o repositório :
git clone https://github.com/AdieLaine/multi-agent-reasoning.gitNavegue até o diretório do projeto :
cd multi-agent-reasoningInstale os pacotes necessários :
pip install openai colorama tiktokenInstale o Enxame:
pip install git+ssh://[email protected]/openai/swarm.git
or
pip install git+https://github.com/openai/swarm.gitConsulte o repositório GitHub do Swarm para obter instruções detalhadas de instalação.
Defina sua chave de API OpenAI :
Defina sua chave de API como uma variável de ambiente:
export OPENAI_API_KEY= ' your-api-key-here ' Alternativamente, você pode configurá-lo diretamente em seu script ou usar um arquivo .env .
Execute o script usando Python:
python reasoning.pyAo executar o script, será apresentado um menu:
═════════════════════════════════════════════════════════════════════════════════════════════
║ 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):
Opção 1: conversar com um agente
Opção 2: Use lógica de raciocínio
Opção 3: use o raciocínio baseado em Swarm
Opção 4: Sair
O sistema Multi-Agent Reasoning usa modelos OpenAI específicos:
o1-preview-2024-09-12 para tarefas de raciocínio.gpt-4o para interações de chat com agentes.gpt-4o .Esses modelos oferecem suporte a recursos avançados e relatórios de uso de token, permitindo que o sistema forneça informações detalhadas sobre o uso de token após cada resposta.
Objetivo : Permite ao usuário conversar diretamente com um agente selecionado.
Exemplo :
O núcleo da funcionalidade do chatbot está no processo de raciocínio empregado pelos agentes. Este processo foi concebido para simular um ambiente colaborativo onde os agentes pensam criticamente, verificam factos, desafiam as perspectivas uns dos outros e refinam as suas respostas com base em feedback construtivo.
Objetivo : Os agentes geram suas respostas iniciais ao prompt do usuário com base em seu raciocínio e conhecimento individual.
Exemplo :
Objetivo : Os agentes verificam a precisão e a validade de suas próprias respostas para garantir a correção factual.
Exemplo :
Objetivo : Os agentes criticam as respostas verificadas uns dos outros para identificar áreas de melhoria, omissões ou preconceitos.
Exemplo :
Objetivo : Os agentes refinam suas próprias respostas incorporando feedback das críticas e melhorando seu raciocínio inicial.
Exemplo :
Objetivo : Combinar as respostas refinadas de todos os agentes em uma resposta única, coesa e abrangente.
blend_responses .Exemplo :
Objetivo : Incorporar o feedback do usuário para refinar ainda mais a resposta, garantindo satisfação e precisão.
MAX_REFINEMENT_ATTEMPTS .Exemplo :
Objetivo : permitir que a conversa mantenha o contexto em vários prompts do usuário para um diálogo coerente.
Exemplo :
A integração Swarm aprimora o sistema de raciocínio multiagente, permitindo a coordenação dinâmica de agentes e a delegação de tarefas. O Swarm permite que os agentes colaborem de forma eficiente, aproveitando a inteligência coletiva para resolver tarefas complexas e melhorar a capacidade de resposta.
O Swarm se concentra em tornar a coordenação e execução de agentes leves, altamente controláveis e facilmente testáveis. Isso é conseguido por meio de duas abstrações primitivas: Agents e Handoffs . Um Agente engloba instruções e ferramentas e pode, a qualquer momento, optar por transferir uma conversa para outro Agente.
Inicialização do cliente Swarm : O sistema inicializa um cliente Swarm para gerenciar as interações do agente.
from swarm import Agent , Swarm
client = Swarm ()Inicialização do Agente :
agents.json .Tratamento de conversas :
Objetivo : Utilizar o Swarm Framework for Intelligence para coordenar agentes dinamicamente, permitindo colaboração eficiente e delegação de tarefas.
Inicialização :
agents.json .Discussão :
client.run() do Swarm.Verificação :
Criticando :
Refinamento :
Misturando respostas :
blend_responses .Exemplo :
Objetivo : Fornecer uma interface de chat que aproveite os recursos do Swarm para uma interação perfeita entre os agentes.
Agente Swarm para bate-papo :
Tratamento de conversas :
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_replyRespostas dinâmicas :
Exemplo :
Projeto do Agente :
Definições de funções :
Variáveis de contexto :
Tratamento de erros :
Teste :
O que é Swarm e como ele aprimora o sistema?
Preciso modificar meus agentes existentes para trabalhar com o Swarm?
Agent . Os agentes existentes podem ser adaptados incorporando a estrutura e as convenções do Swarm.Posso adicionar mais agentes ao sistema Swarm?
agents.json e inicializá-los no sistema.Como o Swarm lida com transferências de agentes?
O Swarm é compatível com os modelos utilizados no sistema?
gpt-4o . O cache de prompts aumenta a eficiência do sistema de raciocínio multiagente, reduzindo a latência e o custo ao lidar com prompts longos ou repetidos. Ele funciona armazenando em cache os prefixos comuns mais longos dos prompts, permitindo um processamento mais rápido de solicitações subsequentes que reutilizam esses prefixos.
Duração do cache :
usage que exibe detalhes de uso do token. "usage" : {
"prompt_tokens" : 2006 ,
"completion_tokens" : 300 ,
"total_tokens" : 2306 ,
"prompt_tokens_details" : {
"cached_tokens" : 1920
},
"completion_tokens_details" : {
"reasoning_tokens" : 0
}
}cached_tokens indica quantos tokens de prompt foram recuperados do cache. Os agentes são configurados por meio de um arquivo agents.json , permitindo fácil customização de seus atributos.
Localização : deve ser colocado no mesmo diretório do script reasoning.py .
Estrutura :
{
"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 " ]
}
}
]
}Personalização :
Exemplo :
O código está estruturado para facilitar tanto o processo de raciocínio quanto as interações por chat com os agentes. Ele também incorpora Swarm Framework para maior coordenação de agentes.
Bibliotecas :
os , time , logging , json : para operações do sistema, tempo, registro e manipulação de JSON.colorama : Para saída colorida do console.swarm : Para implementar Inteligência de Enxame.tiktoken : Para contagem precisa de tokens (em outras partes do script).Inicialização :
from swarm import Agent , Swarm
client = Swarm () Os agentes são inicializados a partir do arquivo de configuração agents.json .
Cada agente é criado como uma instância do Swarm Agent com instruções e atributos específicos.
Os agentes ficam cientes uns dos outros anexando informações sobre outros agentes às suas instruções.
def initialize_swarm_agents ():
# Load agents from agents.json and create Swarm agents
agents = []
# ... Load and initialize agents with awareness of others
return agents Função : swarm_chat_interface(conversation_history)
Objetivo : Lidar com interações de chat com o agente Swarm.
Processo :
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 Função : run_swarm_reasoning(user_prompt)
Objetivo : usa agentes Swarm para colaborar e responder a um prompt do usuário seguindo vários estágios de raciocínio.
Processo :
blend_responses combina as respostas refinadas em uma resposta final.Processamento paralelo : o Swarm permite que os agentes executem essas etapas simultaneamente, aumentando a eficiência.
Exemplo de função de mesclagem :
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 com o prompt do usuário.swarm_chat_interface(conversation_history) :Abaixo está um fluxograma atualizado que reflete a nova lógica, incluindo o modo de bate-papo, o conhecimento uns dos outros pelos agentes, a transparência do uso de tokens, o cache de prompts e a integração do Swarm:
Contribuições são bem-vindas! Para contribuir:
Este projeto está licenciado sob a licença MIT.
Para preparar o repositório GitHub:
Crie um novo repositório no GitHub chamado multi-agent-reasoning .
Adicione o arquivo README.md com este conteúdo.
Inclua o script reasoning.py no diretório raiz.
Inclua o arquivo agents.json no diretório raiz.
Crie um arquivo .gitignore para excluir arquivos desnecessários:
# Exclude log files
reasoning.log
swarm_middle_agent.log
# Exclude environment files
.env
# Python cache
__pycache__ /
* .py [ cod ]Confirme e envie os arquivos para o 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
Sinta-se à vontade para explorar o código, personalizar os agentes e interagir com o chatbot Multi-Agent Reasoning!
Se você tiver alguma dúvida ou precisar de ajuda, abra um problema no GitHub.
