agentes atômicos

Outro código-fonte

1.0.8

Baixar

Agentes Atômicos

A estrutura do Atomic Agents foi projetada para ser modular, extensível e fácil de usar. Seu principal objetivo é eliminar a complexidade redundante, abstrações desnecessárias e suposições ocultas, ao mesmo tempo que fornece uma plataforma flexível e poderosa para a construção de aplicações de IA por meio da atomicidade. A estrutura fornece um conjunto de ferramentas e agentes que podem ser combinados para criar aplicativos poderosos. Ele é construído com base no Instructor e aproveita o poder do Pydantic para validação e serialização de dados e esquemas.

Assista ao vídeo de visão geral

Por que agentes atômicos?

Embora as estruturas existentes para IA de agência se concentrem na construção de sistemas multiagentes autônomos, muitas vezes elas carecem do controle e da previsibilidade necessários para aplicações do mundo real. As empresas precisam de sistemas de IA que produzam resultados consistentes e confiáveis, alinhados com sua marca e seus objetivos.

A Atomic Agents atende a essa necessidade fornecendo:

Modularidade: crie aplicativos de IA combinando componentes pequenos e reutilizáveis.
Previsibilidade: Defina esquemas claros de entrada e saída para garantir um comportamento consistente.
Extensibilidade: Troque facilmente componentes ou integre novos sem interromper todo o sistema.
Controle: ajuste cada parte do sistema individualmente, desde prompts do sistema até integrações de ferramentas.

Anatomia de um Agente

Nos Agentes Atômicos, um agente é composto de vários componentes principais:

Prompt do sistema: Define o comportamento e a finalidade do agente.
Esquema de entrada: especifica a estrutura e as regras de validação da entrada do agente.
Esquema de Saída: Especifica a estrutura e as regras de validação da saída do agente.
Memória: Armazena histórico de conversas ou outros dados relevantes.
Provedores de contexto: injetam contexto dinâmico no prompt do sistema do agente em tempo de execução.

Aqui está um diagrama de arquitetura de alto nível:

Instalação

Para instalar Agentes Atômicos, você pode usar pip:

 pip instalar agentes atômicos

Certifique-se de instalar também o provedor que deseja usar. Por exemplo, para usar OpenAI e Groq, você pode instalar os pacotes openai e groq :

 pip instalar openai groq

Isso também instala o CLI Atomic Assembler , que pode ser usado para baixar ferramentas (e em breve também agentes e pipelines).

Para desenvolvimento local, você pode instalar a partir do repositório:

 clone git https://github.com/BrainBlend-AI/atomic-agents.gitcd atomic-agents
instalação de poesia

Estrutura do Projeto

Atomic Agents usa uma estrutura monorepo com os seguintes componentes principais:

atomic-agents/ : A biblioteca principal de Agentes Atômicos
atomic-assembler/ : A ferramenta CLI para gerenciar componentes do Atomic Agents
atomic-examples/ : Exemplos de projetos mostrando o uso de Agentes Atômicos
atomic-forge/ : Uma coleção de ferramentas que podem ser usadas com Agentes Atômicos

Início rápido e exemplos

Uma lista completa de exemplos pode ser encontrada no diretório de exemplos.

Nós nos esforçamos para documentar minuciosamente cada exemplo, mas se algo não estiver claro, não hesite em abrir um problema ou fazer uma solicitação para melhorar a documentação.

Aqui está um trecho rápido demonstrando como é fácil criar um agente poderoso com Agentes Atômicos:

 # Defina uma classe de esquema de saída customizada CustomOutputSchema(BaseIOSchema):""" docstring para o esquema de saída customizado """chat_message: str = Field(..., description="A mensagem de chat do agente.")suggested_questions: List[str ] = Field(..., description="Perguntas de acompanhamento sugeridas.")# Configure o sistema promptsystem_prompt_generator = SystemPromptGenerator(background=["Este assistente é experiente, útil e sugere perguntas de acompanhamento."],etapas =["Analise a entrada do usuário para entender o contexto e a intenção.","Formule uma resposta relevante e informativa.","Gere 3 sugestões de perguntas de acompanhamento para o usuário."],output_instructions=["Forneça informações claras e concisas em resposta às perguntas do usuário.","Conclua cada resposta com 3 sugestões de perguntas relevantes para o usuário."]
)# Inicialize o agenteagent = BaseAgent(config=BaseAgentConfig(client=your_openai_client, # Substitua pelo seu clientmodel = "gpt-4o-mini",system_prompt_generator=system_prompt_generator,memory=AgentMemory(),output_schema=CustomOutputSchema)
)# Use o agentresponse = agent.run(user_input)print(f"Agent: {response.chat_message}")print("Perguntas sugeridas:")para a pergunta em response.suggested_questions:print(f"- {question}")

Este snippet mostra como criar um agente personalizável que responde às dúvidas dos usuários e sugere perguntas de acompanhamento. Para exemplos completos e executáveis, consulte os seguintes arquivos no diretório atomic-examples/quickstart/quickstart/ :

Chatbot básico Um exemplo mínimo de chatbot para você começar.
Chatbot personalizado Um exemplo mais avançado com um prompt de sistema personalizado.
Chatbot personalizado com esquema Um exemplo avançado apresentando um esquema de saída personalizado.
Chatbot multi-provedor Demonstra como usar diferentes provedores, como Ollama ou Groq.

Além dos exemplos de início rápido, temos exemplos mais complexos que demonstram o poder dos Agentes Atômicos:

Agente de pesquisa na web: um agente inteligente que realiza pesquisas na web e responde perguntas com base nos resultados.
YouTube Summarizer: Um agente que extrai e resume conhecimento de vídeos do YouTube.

Para obter uma lista completa de exemplos, consulte o diretório de exemplos.

Esses exemplos fornecem um excelente ponto de partida para compreender e usar Agentes Atômicos.

Provedores de Contexto

Atomic Agents permite aprimorar seus agentes com contexto dinâmico usando Context Providers . Os Provedores de Contexto permitem que você injete informações adicionais no prompt do sistema do agente em tempo de execução, tornando seus agentes mais flexíveis e conscientes do contexto.

Usando provedores de contexto

Para usar um Provedor de Contexto, crie uma classe que herda de SystemPromptContextProviderBase e implemente o método get_info() , que retorna a string de contexto a ser adicionada ao prompt do sistema.

Aqui está um exemplo simples:

 de atomic_agents.lib.components.system_prompt_generator import SystemPromptContextProviderBaseclass SearchResultsProvider(SystemPromptContextProviderBase):def __init__(self, title: str, search_results: List[str]):super().__init__(title=title)self.search_results = search_resultsdef get_info(self ) -> str:return "n".join(self.search_results)

Você pode então registrar seu Provedor de Contexto com o agente:

 # Inicialize seu provedor de contexto com datasearch_results_provider dinâmico = SearchResultsProvider(title="Search Results",search_results=["Result 1", "Result 2", "Result 3"]
)# Registre o provedor de contexto com o agentagent.register_context_provider("search_results", search_results_provider)

Isso permite que seu agente inclua os resultados da pesquisa (ou qualquer outro contexto) no prompt do sistema, aprimorando suas respostas com base nas informações mais recentes.

Esquemas e Agentes de Encadeamento

O Atomic Agents facilita o encadeamento de agentes e ferramentas, alinhando seus esquemas de entrada e saída. Esse design permite trocar componentes sem esforço, promovendo modularidade e reutilização em seus aplicativos de IA.

Exemplo: Gerando Consultas para Diferentes Provedores de Pesquisa

Suponha que você tenha um agente que gera consultas de pesquisa e queira usar essas consultas com diferentes ferramentas de pesquisa. Ao alinhar o esquema de saída do agente com o esquema de entrada da ferramenta de pesquisa, você pode encadeá-los facilmente ou alternar entre diferentes provedores de pesquisa.

Veja como você pode conseguir isso:

 import trainerimport openaifrom pydantic import Fieldfrom atomic_agents.agents.base_agent import BaseIOSchema, BaseAgent, BaseAgentConfigfrom atomic_agents.lib.components.system_prompt_generator import SystemPromptGenerator# Importe a ferramenta de pesquisa que você deseja usarfrom web_search_agent.tools.searxng_search import SearxNGSearchTool# Defina o esquema de entrada para a consulta agentclass QueryAgentInputSchema(BaseIOSchema):"""Esquema de entrada para o QueryAgent."""instruction: str = Field(..., description="Instrução para gerar consultas de pesquisa para.")num_queries: int = Field(..., description="Número de consultas a serem geradas.")# Inicialize a consulta agentquery_agent = BaseAgent(BaseAgentConfig(client=instructor.from_openai(openai.OpenAI()),model="gpt-4o-mini",system_prompt_generator=SystemPromptGenerator(background= ["Você é um especialista inteligente em geração de consultas.","Sua tarefa é gerar um número específico de consultas diversas e altamente relevantes com base em uma determinada instrução."],steps=["Receba a instrução e o número de consultas a serem geradas .","Gere as consultas no formato JSON."],output_instructions=["Garanta que cada consulta seja única e relevante.","Forneça as consultas no esquema esperado."],
        ),input_schema=QueryAgentInputSchema,output_schema=SearxNGSearchTool.input_schema, # Alinhar esquema de saída)
)

Neste exemplo:

Modularidade : Ao definir o output_schema do query_agent para corresponder ao input_schema de SearxNGSearchTool , você pode usar diretamente a saída do agente como entrada para a ferramenta.
Capacidade de troca : se você decidir mudar para um provedor de pesquisa diferente, poderá importar uma ferramenta de pesquisa diferente e atualizar o output_schema de acordo.

Por exemplo, para mudar para outro serviço de pesquisa:

 # Importe uma ferramenta de pesquisa diferente de web_search_agent.tools.another_search import AnotherSearchTool# Atualize o esquema de saídaquery_agent.config.output_schema = AnotherSearchTool.input_schema

Esse padrão de design simplifica o processo de encadeamento de agentes e ferramentas, tornando seus aplicativos de IA mais adaptáveis e fáceis de manter.

Executando a CLI

Para executar a CLI, basta executar o seguinte comando:

 atômico

Ou se você instalou Atomic Agents with Poetry, por exemplo:

 poesia corre atômica

Ou se você instalou Atomic Agents com uv:

 uv corre atômico

Depois de executar este comando, será apresentado um menu que permite baixar ferramentas.

Cada ferramenta tem a sua própria:

Esquema de entrada
Esquema de saída
Exemplo de uso
Dependências
Instruções de instalação

A CLI atomic-assembler oferece controle total sobre suas ferramentas, evitando a confusão de dependências desnecessárias. Além disso, facilita a modificação de ferramentas, cada ferramenta vem com seu próprio conjunto de testes de confiabilidade.

Mas você não está limitado ao CLI! Se preferir, você pode acessar diretamente as pastas de ferramentas e gerenciá-las manualmente, simplesmente copiando e colando conforme necessário.

Compatibilidade de provedor e modelo

Atomic Agents depende do pacote Instructor. Isso significa que em todos os exemplos onde OpenAI é usado, qualquer outra API suportada pelo Instructor também pode ser usada – como Ollama, Groq, Mistral, Cohere, Anthropic, Gemini e muito mais. Para obter uma lista completa, consulte a documentação do instrutor em sua página GitHub.

Documentação da API

A documentação da API pode ser encontrada aqui.

Forja Atômica

Atomic Forge é uma coleção de ferramentas que podem ser usadas com Atomic Agents para estender sua funcionalidade. As ferramentas atuais incluem:

Calculadora
Pesquisa SearxNG
Raspador de transcrição do YouTube

Para obter mais informações sobre como usar e criar ferramentas, consulte o README do Atomic Forge.

Contribuindo

Aceitamos contribuições! Consulte o Guia do desenvolvedor para obter informações detalhadas sobre como contribuir com o Atomic Agents. Aqui estão algumas etapas rápidas: