Téléchargement agent builder api - agent builder api Code Source Téléchargement

agent builder api

Autre code source

1.0.0

Télécharger

API Agent Builder

Démarrage rapide

Vous pouvez démarrer le serveur API à l'aide de conteneurs Docker ou de cloner et de construire ce référentiel manuellement.

Configuration manuelle: clonez ce référentiel dans votre machine locale et démarrez le serveur API Fast Python. Facultativement, installez et configurez Mongo DB.

Configuration des conteneurs Dev: les conteneurs Dev vous permettent d'automatiser la configuration de l'environnement. Utilisez cette configuration pour installer et exécuter les services de conteneurs dans un environnement isolé avec des extensions préinstallées. Vous pouvez également ouvrir des codes GitHub dans un environnement / navigateur distant à l'aide de secrets pour passer les touches API du modèle.

Configuration manuelle

Configurer un Python VirtualEnv et Installer des dépendances

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

Définissez le nom du modèle et la clé API dans le fichier .env
```
 OPENAI_API_KEY = " sk---- "
MODEL_NAME = " openai "
```
Démarrez le serveur dans le nouveau terminal
```
python -m agentbuilder.main
```

[Facultatif] Commencez à utiliser la poésie

Pour la gestion des dépendances à grain fin, utilisez la poésie pour choisir et choisir des packs de dépendance en fonction de votre fournisseur de modèle LLM et de vos fonctionnalités d'outils.

Suivez le guide d'instructions officielles pour installer la poésie.

Choisissez et choisissez des packs de dépendance à installer.

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

Définissez le nom du modèle et la clé API dans le fichier .env
```
 OPENAI_API_KEY = " sk---- "
MODEL_NAME = " openai "
```
Démarrez le serveur dans le nouveau terminal
```
poetry run start-server
```

Note

La poésie créera un environnement virtuel pour nous.

[Facultatif] Activer MongoDB

Par défaut, les données sont stockées sous forme de fichiers JSON. Activez le stockage dans Mongo DB en définissant l'URL à l'aide de la variable d'environnement.

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

Configuration des conteneurs de développement

Activez les conteneurs Dev dans VScode en suivant les étapes de la documentation officielle.
Cliquez sur l'insigne ci-dessous pour exécuter les services dans un environnement de conteneur isolé dans une machine locale.
Cela clonera le repo et démarrera les services de conteneurs API et Mongo DB.

Conseil

Utilisez URL MongoDB: // MongoDB: 27017 / LLMDB dans l'extension VScode Mongo DB pour afficher les données de stockage.

Exécuter F1> Conteneurs Dev: attachez au conteneur en cours d'exécution .. et sélectionnez Agent-Builder-Container .

Définissez le nom du modèle et la clé API dans le fichier .env

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

Personnalisation

Packs de dépendance et configuration de l'environnement

Les packs de dépendance permettent des installations de packages à grain fin en fonction de vos besoins. Utilisez la variable d'environnement extra_deps dans le fichier docker-compose à mettre à jour.

Le script d'installation-extra-deps.sh peut être utilisé en mode Container Dev si Docker-Compose n'est pas disponible.

Par exemple, la configuration de l'environnement ci-dessous installera des dépendances pour le modèle Gemini, Mongo DB, Langchain Graph et VectedB

 EXTRA_DEPS : " gemini,mongodb,langgraph,vectordb "

Conseil

Commencez par un pack de dépendances de base pour prendre en charge votre modèle et ajoutez d'autres fonctionnalités progressivement

Les modèles suivants sont pris en charge par son pack de dépendances

Modèle	Pack de dépendances	Nom de clé env
AI ouvert	Openai	Openai_api_key
GÉMEAUX	Gémeaux	Google_api_key
ADHÉRER	adhérer	Cohere_api_key
Anthropique	anthropique	Anthropic_api_key

Certains outils préconfigurés nécessitent des dépendances supplémentaires ou des clés API pour être activée.

Outil	Pack de dépendances	Nom de clé env
Internet_search	-	Tavily_api_key
vectorstore_search	vectordb	Embed_model_name

Ajout d'outils

Ajoutez des outils ou des kits d'outils personnalisés à l'aide du module d'usine d'outils ( AgentBuilder / Factory / Tool_factory ).

Créez votre outil

agentbuilder / outils / 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 ())}

Ajoutez votre outil dans la méthode get_all_tools dans le module TOLL_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
            ]

Ajout d'agents

Les agents peuvent être créés à l'aide de l'interface utilisateur d'extension ou déclarée dans le code. Ajoutez vos agents à l'aide du module d'usine d'agent ( agentBuilder / Factory / Agent_Factory ).

Créez votre agent

 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'
  )

Ajoutez votre agent dans la méthode get_all_agents .

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

Builder et graphiques d'agent personnalisés

Personnalisez votre flux de travail d'agent à l'aide d'invites et de graphiques personnalisés. Filtrez l'agent à l'aide du nom de l'agent pour appliquer les personnalisations.

Par exemple, le code suivant applique Graph Builder Workflow pour l'agent nommé "Graph_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 )

Important

Le pack de dépendances "Langgraph" doit être installé pour BaseGraphAgentBuilder.

Configuration des modèles

Mettre à jour la configuration du modèle à l'aide des variables d'environnement.

Prend en charge le format {fournisseur} / {ModelName}

Gémeaux

Créer des touches API https://aistudio.google.com/app/apikey

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

Adhérer

Créer des touches 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>

AI ouvert

Créer des touches 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>

Anthropique

Créez des touches API https://www.anthropic.com/ et 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>