agent builder api

API do construtor de agentes

Início rápido

Você pode iniciar o servidor de API usando recipientes do Docker ou clonando e construindo manualmente este repositório.

Configuração manual: clone este repositório em sua máquina local e inicie o servidor API Fast Python. Opcionalmente, instale e configure o Mongo DB.

Configuração do contêiner de dev: os contêineres de dev permitem automatizar a configuração do ambiente. Use essa configuração para instalar e executar serviços de contêineres em um ambiente isolado com extensões pré -instaladas. Você também pode abrir espaços de codificina do GitHub em um ambiente/navegador remoto usando segredos para passar as teclas de API do modelo.

Configuração manual

1. Configure um Python VirtualEnv e instale dependências

   python -m venv --prompt agent-builder-api venv
   source venv/bin/activate
   # venv/Scripts/activate (Windows)
   pip install -r requirements.txt

2. Defina o nome do modelo e a chave da API no arquivo .env

    OPENAI_API_KEY = " sk---- "
   MODEL_NAME = " openai "

3. Inicie o servidor no novo terminal

   python -m agentbuilder.main

[Opcional] Comece a usar poesia

Para gerenciamento de dependência de granulação fina, use a poesia para escolher os pacotes de dependência com base nos recursos do seu provedor de modelos LLM e da ferramenta.

1. Siga o Guia de Instrução Oficial para instalar a poesia.

2. Escolha os pacotes de dependência para instalar.

   poetry install --extras " openai gemini cohere anthropic mongodb vectordb langgraph "

3. Defina o nome do modelo e a chave da API no arquivo .env

    OPENAI_API_KEY = " sk---- "
   MODEL_NAME = " openai "

4. Inicie o servidor no novo terminal

   poetry run start-server

Observação

A poesia criará um ambiente virtual para nós.

[Opcional] Ativar MongoDB

Por padrão, os dados são armazenados como arquivos JSON. Habilite o armazenamento em Mongo DB definindo URL usando a variável de ambiente.

 MONGODB_URL = " mongodb://localhost:27017/llmdb "

Configuração de contêineres de dev

1. Ativar contêineres de dev no VSCode seguindo as etapas na documentação oficial.

2. Clique no crachá abaixo para executar os serviços em um ambiente de contêiner isolado em uma máquina local.

   Isso clonará o repositório e iniciará os serviços de contêineres da API e Mongo DB.

Dica

Use URL MONGODB: // MONGODB: 27017/LLMDB na extensão VSCode Mongo DB para visualizar dados de armazenamento.

4. Execute F1> Recipientes de dev: Anexe ao contêiner em execução .. e selecione o agente-Builder-container .

5. Defina o nome do modelo e a chave da API no arquivo .env

    OPENAI_API_KEY = " sk---- "
   MODEL_NAME = " openai " 

Personalização

Pacotes de dependência e configuração de ambiente

Os pacotes de dependência permitem instalações de pacote de granulação fina com base em seus requisitos. Use a variável de ambiente Extra_Deps no arquivo Docker-Compose para atualizar.

O script install-extra-deps.sh pode ser usado no modo de contêiner de dev se o Docker-Compompose não estiver disponível.

Por exemplo, a configuração do ambiente abaixo instalará dependências para o modelo Gemini, Mongo DB, Langchain Gráfico e Vectordb

 EXTRA_DEPS : " gemini,mongodb,langgraph,vectordb " 

Dica

Comece com um pacote básico de dependência para suportar seu modelo e adicione outros recursos de forma incremental

Os modelos a seguir são suportados por seu pacote de dependência

Modelo	Pacote de dependência	Nome de chave env
Abra a IA	Openai	OpenAi_API_KEY
GÊMEOS	Gêmeos	Google_api_key
Coere	coere	Cohere_api_key
Antrópico	Antrópico	Anthropic_API_KEY

Algumas ferramentas pré-configuradas requerem dependências extras ou teclas de API para ser ativado.

Ferramenta	Pacote de dependência	Nome de chave env
internet_search	-	Tavily_api_key
Vectorstore_search	vectordb	INCED_MODEL_NAME

Adicionando ferramentas

Adicione ferramentas ou kits de ferramentas personalizados usando o módulo de fábrica de ferramentas ( AgentBuilder/Factory/Tool_Factory ).

1. Crie sua ferramenta

   AgentBuilder/Tools/my_custom_tool.py

    from pathlib import Path
   from langchain_core . tools import tool
   from pydantic import BaseModel , Field
   
   @ tool
   def my_custom_tool ( a : int , b : int ):
   """Custom Tool Description"""
   return a + b
   
   my_custom_tool . name = "custom_tool_name"
   my_custom_tool . description = "Custom Tool Description"
   
   class field_inputs ( BaseModel ):
   a : int = Field ( description = "First input" )
   b : int = Field ( description = "Second input" )
   
   my_custom_tool . args_schema = sum_inputs
   my_custom_tool . metadata = { "file_path" : str ( Path ( __file__ ). absolute ())}

2. Adicione sua ferramenta no método get_all_tools no módulo Tool_Factory.

   AgentBuilder/Factory/Tool_Factory.py

   def get_all_tools()->Sequence[BaseTool]:
   
       return get_vectordb_tools()+ get_websearch_tools() + json_tools + [
               directly_answer_tool,
               weather_clothing_tool,
               temperature_tool,
               temperature_sensor_tool,
               sum_tool,greeting_tool,
               git_diff_tool,
               repl_tool,
   +           my_custom_tool
               ]

Adicionando agentes

Os agentes podem ser criados usando a interface do usuário de extensão ou declarados no código. Adicione seus agentes usando o módulo de fábrica do agente ( AgentBuilder/Factory/Agent_Factory ).

1. Crie seu agente

    def my_agent ():
     return AgentParams (
           name = "my_agent" ,
           preamble = "You are a powerful agent that uses tools to answer Human questions" ,
           tools =  [ "my_custom_tool" ],
           agent_type = 'tool_calling'
     )

2. Adicione seu agente no método get_all_agents .

   def get_all_agents():
   return [
           default_agent(),
           weather_agent(),
           python_agent(),
           git_agent(),
   +       my_agent()
   ]

Construtor de agentes personalizados e gráficos

Personalize o fluxo de trabalho do seu agente usando prompts e gráficos personalizados. Filtre o agente usando o nome do agente para aplicar personalizações.

Por exemplo, o código a seguir aplica o fluxo de trabalho do construtor de gráficos para o agente chamado "graf_agent"

 def get_agent_builder ( params : AgentBuilderParams ):
    agent_name = params . name
    match agent_name :
        case "graph_agent" :
            from agentbuilder . agents . BaseGraphAgentBuilder import BaseGraphAgentBuilder
            return BaseGraphAgentBuilder ( params )
        case _ :
            return BaseAgentBuilder ( params )

Importante

O pacote de dependência "Langgraph" precisa ser instalado no BaseGrafagentBuilder.

Configurando modelos

Atualize a configuração do modelo usando variáveis ​​de ambiente.

Suporta {provider}/{modelName} formato

• Gêmeos

  Crie chaves da API https://aistudio.google.com/app/apikey

   MODEL_NAME = " gemini/gemini-pro "
   EMBED_MODEL_NAME = " gemini/embedding-001 "
   GOOGLE_API_KEY = <GOOGLE_API_KEY>

• Coere

  Crie teclas de API https://dashboard.cohere.com/api-keys

   MODEL_NAME = " cohere/command "
   EMBED_MODEL_NAME = " cohere/embed-english-v3.0 "
   COHERE_API_KEY = <COHERE_API_KEY>

• Abra a IA

  Crie teclas de API https://platform.openai.com/docs/quickstart/account-setup

   MODEL_NAME = " openai/gpt-4o "
   EMBED_MODEL_NAME = " openai/text-embedding-3-large "
   OPENAI_API_KEY = <OPENAI_API_KEY>

• Antrópico

  Crie as chaves da API https://www.anthropic.com/ e https://www.voyageai.com/

   MODEL_NAME = " anthropic/claude-3-opus-20240229 "
   EMBED_MODEL_NAME = " voyageai/voyage-2 "
   ANTHROPIC_API_KEY = <ANTHROPIC_API_KEY>
   VOYAGE_API_KEY = <VOYAGE_API_KEY>

• Ollama

  Use modelos locais para chamadas de função.

Dica

Use o tipo de agente de bate -papo JSON para melhor compatibilidade com os modelos locais.

Instale o Ollama e puxe o modelo.

ollama pull mistral:v0.3

Defina a variável de ambiente.

 MODEL_NAME = " ollama/mistral:v0.3 "