langroid
0.24.0
Langroid est un cadre Python intuitif, léger, extensible et fondé sur des principes pour créer facilement des applications LLM, des chercheurs de CMU et UW-Madison. Vous configurez des agents, équipez-les de composants facultatifs (LLM, Vector-Store et outils / fonctions), affectez-leur des tâches et faites-les résoudre en collaboration un problème en échangeant des messages. Ce paradigme multi-agents est inspiré par le cadre de l'acteur (mais vous n'avez pas besoin de savoir quoi que ce soit!).
Langroid est une nouvelle interprétation du développement d'applications LLM, où une réflexion considérable a été consacrée à la simplification de l'expérience du développeur; Il n'utilise pas Langchain , ni aucun autre cadre LLM.
Lisez le (WIP) Aperçu de l'architecture Langroid
? Les entreprises utilisent / adaptent la production de Langroid. Voici un devis:
Nullify utilise des agents d'IA pour le développement de logiciels sécurisés. Il trouve, priorise et corrige les vulnérabilités. Nous avons adapté en interne le cadre d'orchestration multi-agents de Langroid en production, après avoir évalué Crewai, Autogen, Langchain, Langflow, etc. Nous avons trouvé que Langroid était bien supérieur à ces cadres en termes de facilité d'installation et de flexibilité. Les abstractions de l'agent et des tâches de Langroid sont intuitives, bien pensées et offrent une excellente expérience de développeur. Nous voulions le moyen le plus rapide d'obtenir quelque chose en production. Avec d'autres cadres, cela nous aurait pris des semaines, mais avec Langroid, nous avons obtenu de bons résultats en minutes. Hautement recommandé!
- Jacky Wong, chef de l'IA à l'annulation.
Voir cette introduction à un article de blog Langroid de l'équipe LancedB
Je viens de publier dans ML pour Healthcare (2024): un système de chiffon multi-agent basé sur Langroid pour la pharmacovigilance, voir un article de blog
Nous accueillons les contributions: voir le document des contributions pour les idées sur ce qu'il faut contribuer.
Construisez-vous des applications LLM ou voulez-vous de l'aide avec Langroid pour votre entreprise ou souhaitez hiérarchiser les fonctionnalités Langroid pour les cas d'utilisation de votre entreprise? Prasad Chalasani est disponible pour la consultation (conseil / développement): pchalasani chez gmail dot com.
Le parrainage est également accepté via des sponsors GitHub
Questions, commentaires, idées? Rejoignez-nous sur Discord!
Ce n'est qu'un teaser; Il y a beaucoup plus, comme l'appel / outils de fonctions, la collaboration multi-agents, l'extraction d'informations structurées, le docchatagent (RAG), le SQLChatagent, les LLM locaux / distants non openai, etc. Faites défiler vers le bas ou voir les documents pour en savoir plus. Consultez le colab de démarrage rapide Langroid qui s'accumule à un exemple d'extraction d'informations à 2 agents à l'aide de l'API Openai ChatCompletion. Voir aussi cette version qui utilise à la place l'API Openai Assistants.
Je viens de sortir! Exemple de script montrant comment vous pouvez utiliser des multi-agents Langroid et des outils pour extraire des informations structurées à partir d'un document en utilisant uniquement un LLM local (Mistral-7B-Istruct-V0.2).
import langroid as lr
import langroid . language_models as lm
# set up LLM
llm_cfg = lm . OpenAIGPTConfig ( # or OpenAIAssistant to use Assistant API
# any model served via an OpenAI-compatible API
chat_model = lm . OpenAIChatModel . GPT4o , # or, e.g., "ollama/mistral"
)
# use LLM directly
mdl = lm . OpenAIGPT ( llm_cfg )
response = mdl . chat ( "What is the capital of Ontario?" , max_tokens = 10 )
# use LLM in an Agent
agent_cfg = lr . ChatAgentConfig ( llm = llm_cfg )
agent = lr . ChatAgent ( agent_cfg )
agent . llm_response ( "What is the capital of China?" )
response = agent . llm_response ( "And India?" ) # maintains conversation state
# wrap Agent in a Task to run interactive loop with user (or other agents)
task = lr . Task ( agent , name = "Bot" , system_message = "You are a helpful assistant" )
task . run ( "Hello" ) # kick off with user saying "Hello"
# 2-Agent chat loop: Teacher Agent asks questions to Student Agent
teacher_agent = lr . ChatAgent ( agent_cfg )
teacher_task = lr . Task (
teacher_agent , name = "Teacher" ,
system_message = """
Ask your student concise numbers questions, and give feedback.
Start with a question.
"""
)
student_agent = lr . ChatAgent ( agent_cfg )
student_task = lr . Task (
student_agent , name = "Student" ,
system_message = "Concisely answer the teacher's questions." ,
single_round = True ,
)
teacher_task . add_sub_task ( student_task )
teacher_task . run ()Nov 2024:
Agent S avec un format de sortie de schéma JSON strict sur les LLM compatibles et le mode strict pour l'API OpenAI Tools.Qwen2.5-Coder-32b-Instruct ) hébergées sur GLHF.ChatOctobre 2024:
Sept. 2024:
o1-mini et o1-preview .DocChatAgent utilise la fusion de rang réciproque (RRF) pour classer les morceaux récupérés par différentes méthodes.run_batch_task Nouvelle option - stop_on_first_result - permet la terminaison de lot dès que toute tâche renvoie un résultat.Août 2024:
Task.run(), Task.run_async .Juillet 2024:
Juin 2024:
RewindTool , qui permet à un agent de "rembobiner et refaire" un message passé (et tous les messages dépendants sont effacés grâce au suivi de la lignée). Lisez les notes ici.Mai 2024:
doc-chat , db (pour les dépendances liées à la base de données). Voir les instructions d'installation mises à jour ci-dessous et dans les documents.examples de ClassMethod, et un exemple aléatoire de cette liste serait utilisé pour générer un exemple à 1 coup pour le LLM. Cela a été amélioré, vous pouvez donc désormais fournir une liste d'exemples où chaque exemple est soit une instance d'outil, soit un tuple de (description, instance d'outil), où la description est une "pensée" qui conduit le LLM à utiliser l'outil (voir l'exemple dans les documents). Dans certains scénarios, cela peut améliorer la précision de la génération d'outils LLM. De plus, maintenant, au lieu d'un exemple aléatoire, tous les exemples sont utilisés pour générer quelques exemples de coups.TaskConfig . Ne détecte que des boucles exactes , plutôt que des boucles approximatives où les entités disent des choses essentiellement similaires (mais pas exactement les mêmes).RecipientTool , avec le compromis que comme il n'est pas un outil, il n'y a aucun moyen d'appliquer / rappeler au LLM de spécifier explicitement un destinataire (dans des scénarios où cela est important).DocChatAgent .gpt-4o est maintenant le LLM par défaut partout; Mettre à jour les tests et les exemples pour travailler avec ce LLM; Utilisez le tokenzer correspondant au LLM.gemini 1.5 pro Support via litellmQdrantDB: Mise à jour pour soutenir les intégres insuffisants apprises.Avril 2024:
chat_model="groq/llama3-8b-8192" . Voir le tutoriel.Task.run(), Task.run_async(), run_batch_tasks ont les paramètres max_cost et max_tokens pour quitter lorsque les jetons ou le coût dépassent une limite. Le résultat ChatDocument.metadata comprend désormais un champ status qui est un code indiquant un code de raison de l'achèvement de la tâche. Aussi task.run() etc peut être invoqué avec un champ session_id explicite qui est utilisé comme clé pour rechercher divers paramètres dans le cache redis. Actuellement, utilisé uniquement pour rechercher "Kill Status" - cela permet de tuer une tâche en cours d'exécution, soit par task.kill() , soit par la classe Task.kill_session(session_id) . Par exemple d'utilisation, consultez le test_task_kill dans les tests / main / test_task.pyMars 2024:
DocChatAgent , voir le test_doc_chat_agent.py en particulier le test_doc_chat_batch() ; NOUVELLE TAGD RUN UTILITY: run_batch_task_gen où un générateur de tâches peut être spécifié, pour générer une tâche par entrée.DocChatAgent fonctionnera désormais avec Image-PDFS).DocChatAgent Context Window FixesURLLoader : détecter le temps de fichier à partir de l'en-tête lorsque l'URL ne se termine pas par un suffixe reconnaissable comme .pdf , .docx , etc.sentence_transformer est disponible.unstructured , haystack , chromadb , mkdocs , sentence-transformers huggingface-hub .import langroid as lrFévrier 2024:
chat_model="ollama/mistral" . Voir les notes de libération.Janvier 2024:
SQLChatAgent ). Voir l'exemple de script utilisant cet agent pour répondre aux questions sur les dépendances PKG Python..doc (en plus de .docx )formatter facultatif dans OpenAIGPTConfig pour assurer une mise en forme précise de chat pour les LLM locaux.DocChatAgentConfig a un nouveau param: add_fields_to_content , pour spécifier des champs de documents supplémentaires à insérer dans le champ content principal, pour aider à améliorer la récupération.Dec 2023:
DocChatAgent : Ingérez des dataframes de Pandas et le filtrage.LanceDocChatAgent exploite LanceDB Vector-DB pour une recherche de vecteurs efficace et une recherche et un filtrage en texte complet.LanceRAGTaskCreator pour créer un système à 2 agents composé d'un LanceFilterAgent qui décide d'une requête de filtre et de reformularité à envoyer à un agent de chiffon.Task plus simple avec ChatAgent par défaut.Nov 2023:
0.1.126: Agent OpenaiasSistant: support de mise en cache.
0.1.117: Prise en charge des outils API Assistant OpenAI: Calling Fonction, Code-Interepreter et Retriever (RAG), Fichiers Téléchargements. Ceux-ci fonctionnent parfaitement avec l'orchestration des tâches de Langroid. Jusqu'à ce que les documents soient prêts, il est préférable de voir ces exemples d'utilisation:
Tests:
Exemple de scripts:
0.1.112: OpenAIAssistant est une sous-classe de ChatAgent qui exploite la nouvelle API Assistant OpenAI. Il peut être utilisé comme remplacement de rendez-vous pour ChatAgent , et s'appuie sur l'API assistant pour maintenir l'état de conversation, et exploite des fils et des assistants persistants pour les reconnecter si nécessaire. Exemples: test_openai_assistant.py , test_openai_assistant_async.py
0.1.111: Prise en charge du dernier modèle OpenAI: GPT4_TURBO (voir test_llm.py par exemple usage)
0.1.110: mise à niveau de OpenAI v0.x à v1.1.1 (en préparation de l'API des assistants et plus encore); ( litellm temporairement handicapé en raison du conflit de version Openai).
Octobre 2023:
DocChatAgent : rank_with_diversity , rank_to_periphery (Lost in Middle).DocChatAgentConfig.n_neighbor_chunks > 0 permet de retourner des morceaux de contexte autour de la correspondance.DocChatAgent utilise RelevanceExtractorAgent pour que le LLM extrait des parties pertinentes d'un morceau utilisant le nombre de phrases, ce qui entraîne une réduction d'énorme vitesse et des coûts par rapport à l'approche naïve "de luminance" (rédigeant des phrases complètes entières concernées) que LangChain utilise dans leur LLMChainExtractor .import langroid as lr . Voir la documentation pour l'utilisation.Sept. 2023:
docx de chargement (préliminaire).SQLChatAgent qui récupère efficacement les informations de schéma pertinentes lors de la traduction du langage naturel en SQL.Août 2023:
GoogleSearchTool pour activer les agents (leur LLM) pour effectuer des recherches Google via l'appel des fonctions / outils. Voir cet exemple de chat pour la facilité avec laquelle il est d'ajouter cet outil à un agent.SQLChatAgent - Merci à notre dernier contributeur Rithwik Babu!Juillet 2023:
TableChatAgent pour discuter avec des ensembles de données tabulaires (DataFrames, fichiers, URL): LLM génère du code PANDAS, et le code est exécuté à l'aide du mécanisme de l'outil / fonction de Langroid.DocChatAgent accepte désormais les fichiers PDF ou les URL.Supposons que vous souhaitiez extraire des informations structurées sur les termes clés d'un document de location commercial. Vous pouvez facilement le faire avec Langroid en utilisant un système à deux agents, comme nous le montrent dans le répo Langroid-Examples. (Voir ce script pour une version avec les mêmes fonctionnalités en utilisant un modèle local Mistral-7B.) La démo ne présente que quelques-unes des nombreuses fonctionnalités de Langroid, telles que:
LeaseExtractor est en charge de la tâche, et son LLM (GPT4) génère des questions auxquelles le DocAgent .DocAgent LLM (GPT4) utilise la récupération à partir d'un magasin vectoriel pour répondre aux questions LeaseExtractorLeaseExtractor LLM présente les informations dans un format structuré à l'aide d'un appel de fonction.Voici à quoi il ressemble en action (une vidéo MP4 pausable est ici).
(Pour une liste plus à jour, voir la section des mises à jour / versions ci-dessus)
Task.run() a le même signature de type que les méthodes d'un répondeur d'un agent, et c'est la clé de la façon dont une tâche d'un agent peut déléguer à d'autres sous-tâches: du point de vue d'une tâche, les sous-tâches sont simplement des répondeurs supplémentaires, à utiliser de manière à la ronde après les répondants de l'agent.Agent et Task permettent aux utilisateurs de concevoir des agents avec des compétences spécifiques, de les envelopper dans des tâches et de combiner des tâches de manière flexible.ToolMessage équivalent qui fonctionne avec n'importe quel LLM, pas seulement OpenAI. L'appel de fonction et les outils ont la même interface orientée vers les développeurs, implémentée à l'aide de Pyndantic, ce qui facilite la définition d'outils / fonctions et de permettre aux agents de les utiliser. Les avantages de l'utilisation de Pyndantique sont que vous n'avez jamais à écrire des spécifications JSON complexes pour l'appel de fonction, et lorsque le LLM hallucine JSON mal formé, le message d'erreur pydantique est renvoyé au LLM afin qu'il puisse le réparer.langroid Langroid nécessite Python 3.11+. Nous vous recommandons d'utiliser un environnement virtuel. Utilisez pip pour installer une version Slim à nu de langroid (de PYPI) à votre environnement virtuel:
pip install langroid Le package Langroid Core vous permet d'utiliser des modèles OpenAI Embeddings via leur API. Si vous souhaitez plutôt utiliser les modèles d'intégration sentence-transformers à partir de HuggingFace, installez Langroid comme ceci:
pip install " langroid[hf-embeddings] "Pour de nombreux scénarios pratiques, vous aurez peut-être besoin de dépendances facultatives supplémentaires:
doc-chat supplémentaire: pip install " langroid[doc-chat] "db Extra: pip install " langroid[db] "
` `pip install " langroid[doc-chat,db] "all supplémentaire (mais notez que cela entraînera des temps de charge / démarrage plus longs et une taille d'installation plus grande): pip install " langroid[all] " Si vous utilisez SQLChatAgent (par exemple, les examples/data-qa/sql-chat/sql_chat.py ), avec un Postgres DB, vous devrez:
sudo apt-get install libpq-dev sur ubuntu,brew install postgresql sur Mac, etc.pip install langroid[postgres] ou poetry add langroid[postgres] ou poetry install -E postgres . Si cela vous donne une erreur, essayez pip install psycopg2-binary dans votre virtualenv. Si vous obtenez des erreurs étranges impliquant mysqlclient , essayez de faire pip uninstall mysqlclient suivi de pip install mysqlclient .
Pour commencer, tout ce dont vous avez besoin est une clé API OpenAI. Si vous n'en avez pas, consultez cette page Openai. (Notez que bien que ce soit le moyen le plus simple de commencer, Langroid fonctionne avec pratiquement n'importe quel LLM, pas seulement ceux d'OpenAI. Voir les guides à l'utilisation de LLMS Open / Local et d'autres LLMS propriétaires non openai.)
Dans la racine du dépôt, copiez le fichier .env-template dans un nouveau fichier .env :
cp .env-template .env Insérez ensuite votre clé API OpenAI. Votre fichier .env devrait ressembler à ceci (l'organisation est facultative mais peut être nécessaire dans certains scénarios).
OPENAI_API_KEY=your-key-here-without-quotes
OPENAI_ORGANIZATION=optionally-your-organization-idAlternativement, vous pouvez le définir comme une variable d'environnement dans votre coquille (vous devrez le faire chaque fois que vous ouvrez un nouveau shell):
export OPENAI_API_KEY=your-key-here-without-quotesTous les paramètres de variables d'environnement suivants sont facultatifs et certains ne sont nécessaires que pour utiliser des fonctionnalités spécifiques (comme indiqué ci-dessous).
.env , comme la valeur de MOMENTO_AUTH_TOKEN (voir l'exemple de fichier ci-dessous),.env set CACHE_TYPE=momento (au lieu de CACHE_TYPE=redis qui est la valeur par défaut).GoogleSearchTool . Pour utiliser Google Search comme un outil LLM / plugin / fonction Call, vous devrez configurer une touche API Google, puis configurer un moteur de recherche sur Google personnalisé (CSE) et obtenir l'ID CSE. (La documentation pour celles-ci peut être difficile, nous suggérons de demander à GPT4 un guide étape par étape.) Après avoir obtenu ces informations d'identification, stockez-les sous forme de valeurs de GOOGLE_API_KEY et GOOGLE_CSE_ID dans votre fichier .env . Une documentation complète sur l'utilisation de cette question (et d'autres outils "sans état") arrive bientôt, mais en attendant, jetez un coup d'œil à cet exemple de chat, qui montre comment vous pouvez facilement équiper un agent d'un GoogleSearchtool . Si vous ajoutez toutes ces variables facultatives, votre fichier .env devrait ressembler à ceci:
OPENAI_API_KEY=your-key-here-without-quotes
GITHUB_ACCESS_TOKEN=your-personal-access-token-no-quotes
CACHE_TYPE=redis # or momento
REDIS_PASSWORD=your-redis-password-no-quotes
REDIS_HOST=your-redis-hostname-no-quotes
REDIS_PORT=your-redis-port-no-quotes
MOMENTO_AUTH_TOKEN=your-momento-token-no-quotes # instead of REDIS* variables
QDRANT_API_KEY=your-key
QDRANT_API_URL=https://your.url.here:6333 # note port number must be included
GOOGLE_API_KEY=your-key
GOOGLE_CSE_ID=your-cse-id Lorsque vous utilisez Azure OpenAI, des variables d'environnement supplémentaires sont nécessaires dans le fichier .env . Cette page Microsoft Azure OpenAI fournit plus d'informations, et vous pouvez définir chaque variable d'environnement comme suit:
AZURE_OPENAI_API_KEY , de la valeur d' API_KEYAZURE_OPENAI_API_BASE à partir de la valeur du ENDPOINT , ressemble généralement à https://your.domain.azure.com .AZURE_OPENAI_API_VERSION , vous pouvez utiliser la valeur par défaut dans .env-template , et la dernière version peut être trouvée iciAZURE_OPENAI_DEPLOYMENT_NAME est le nom du modèle déployé, qui est défini par l'utilisateur lors de la configuration du modèleAZURE_OPENAI_MODEL_NAME Azure Openai permet des noms de modèle spécifiques lorsque vous sélectionnez le modèle pour votre déploiement. Vous devez mettre précisément le nom du modèle exact sélectionné. Par exemple, GPT-4 (devrait être gpt-4-32k ou gpt-4 ).AZURE_OPENAI_MODEL_VERSION est requis si AZURE_OPENAI_MODEL_NAME = gpt=4 , ce qui aidera Langroid à déterminer le coût du modèle Nous fournissons une version conteneurisée du référentiel langroid-examples via cette image Docker. Tout ce que vous avez à faire est de configurer des variables d'environnement dans le fichier .env . Veuillez suivre ces étapes pour configurer le conteneur:
# get the .env file template from `langroid` repo
wget -O .env https://raw.githubusercontent.com/langroid/langroid/main/.env-template
# Edit the .env file with your favorite editor (here nano), and remove any un-used settings. E.g. there are "dummy" values like "your-redis-port" etc -- if you are not using them, you MUST remove them.
nano .env
# launch the container
docker run -it --rm -v ./.env:/langroid/.env langroid/langroid
# Use this command to run any of the scripts in the `examples` directory
python examples/ < Path/To/Example.py > Ce sont des teasers rapides pour donner un aperçu de ce que vous pouvez faire avec Langroid et à quoi ressemblerait votre code.
langroid-examples .
Les différentes invites LLM et instructions dans Langroid ont été testées pour bien fonctionner avec GPT-4 (et dans une certaine mesure GPT-4O). Le passage à d'autres LLM (local / ouvert et propriétaire) est facile (voir guides mentionné ci-dessus), et peut suffire à certaines applications, mais en général, vous pouvez voir des résultats inférieurs à moins que vous ajustez les invites et / ou la configuration multi-agents.
Voir également le Getting Started Guide pour un tutoriel détaillé.
Cliquez pour développer l'un des exemples de code ci-dessous. Tous ces éléments peuvent être exécutés dans un cahier Colab:
import langroid . language_models as lm
mdl = lm . OpenAIGPT ()
messages = [
lm . LLMMessage ( content = "You are a helpful assistant" , role = lm . Role . SYSTEM ),
lm . LLMMessage ( content = "What is the capital of Ontario?" , role = lm . Role . USER ),
]
response = mdl . chat ( messages , max_tokens = 200 )
print ( response . message ) cfg = lm . OpenAIGPTConfig (
chat_model = "local/localhost:8000" ,
chat_context_length = 4096
)
mdl = lm . OpenAIGPT ( cfg )
# now interact with it as above, or create an Agent + Task as shown below. Si le modèle est pris en charge par liteLLM , alors pas besoin de lancer le serveur proxy. Définissez simplement le param chat_model ci-dessus sur litellm/[provider]/[model] , par exemple litellm/anthropic/claude-instant-1 et utilisez l'objet config comme ci-dessus. Notez que pour utiliser litellm , vous devez installer Langroid avec le litellm extra: poetry install -E litellm ou pip install langroid[litellm] . Pour les modèles distants, vous devrez généralement définir les clés d'API, etc. comme variables d'environnement. Vous pouvez définir ceux basés sur les documents Litellm. Si des variables d'environnement requises sont manquantes, Langroid donne un message d'erreur utile indiquant lesquels sont nécessaires. Notez que pour utiliser langroid avec litellm , vous devez installer le litellm supplémentaire, c'est-à-dire que pip install langroid[litellm] dans votre Env virtual, ou si vous vous développez dans le repo langroid , poetry install -E litellm .
pip install langroid[litellm] import langroid as lr
agent = lr . ChatAgent ()
# get response from agent's LLM, and put this in an interactive loop...
# answer = agent.llm_response("What is the capital of Ontario?")
# ... OR instead, set up a task (which has a built-in loop) and run it
task = lr . Task ( agent , name = "Bot" )
task . run () # ... a loop seeking response from LLM or User at each turn Un jeu de chiffres de jouets, où lorsqu'on lui a donné un nombre n :
repeater_task renvoie simplement n ,even_task renvoie n/2 si n est uniforme, sinon "ne savez pas"odd_task renvoie 3*n+1 si n est étrange, sinon "ne savez pas" Chacune de ces Task configure automatiquement un ChatAgent par défaut.
import langroid as lr
from langroid . utils . constants import NO_ANSWER
repeater_task = lr . Task (
name = "Repeater" ,
system_message = """
Your job is to repeat whatever number you receive.
""" ,
llm_delegate = True , # LLM takes charge of task
single_round = False ,
)
even_task = lr . Task (
name = "EvenHandler" ,
system_message = f"""
You will be given a number.
If it is even, divide by 2 and say the result, nothing else.
If it is odd, say { NO_ANSWER }
""" ,
single_round = True , # task done after 1 step() with valid response
)
odd_task = lr . Task (
name = "OddHandler" ,
system_message = f"""
You will be given a number n.
If it is odd, return (n*3+1), say nothing else.
If it is even, say { NO_ANSWER }
""" ,
single_round = True , # task done after 1 step() with valid response
) Ensuite, ajoutez le even_task et odd_task en tant que sous-tâches de repeater_task , et exécutez le repeater_task , en le lançant avec un nombre en entrée:
repeater_task . add_sub_task ([ even_task , odd_task ])
repeater_task . run ( "3" )Langroid exploite Pydontic pour prendre en charge l'API d'appelant d'Openai ainsi que ses propres outils natifs. Les avantages sont que vous n'avez pas à écrire de JSON pour spécifier le schéma, et si le LLM hallucine une syntaxe d'outils mal formulés, Langroid envoie l'erreur de validation pyndante (convenablement désinfectée) au LLM afin qu'il puisse le corriger!
Exemple simple: disons que l'agent a une liste secrète de nombres, et nous voulons que le LLM trouve le plus petit nombre dans la liste. Nous voulons donner au LLM un outil / fonction probe qui prend un seul numéro n comme argument. La méthode du gestionnaire d'outils dans l'agent renvoie le nombre de nombres dans sa liste au plus n .
Définissez d'abord l'outil à l'aide de la classe ToolMessage de Langroid:
import langroid as lr
class ProbeTool ( lr . agent . ToolMessage ):
request : str = "probe" # specifies which agent method handles this tool
purpose : str = """
To find how many numbers in my list are less than or equal to
the <number> you specify.
""" # description used to instruct the LLM on when/how to use the tool
number : int # required argument to the tool Définissez ensuite un SpyGameAgent comme sous-classe de ChatAgent , avec une probe de méthode qui gère cet outil:
class SpyGameAgent ( lr . ChatAgent ):
def __init__ ( self , config : lr . ChatAgentConfig ):
super (). __init__ ( config )
self . numbers = [ 3 , 4 , 8 , 11 , 15 , 25 , 40 , 80 , 90 ]
def probe ( self , msg : ProbeTool ) -> str :
# return how many numbers in self.numbers are less or equal to msg.number
return str ( len ([ n for n in self . numbers if n <= msg . number ]))Nous instancions ensuite l'agent et nous permettons de l'utiliser et de répondre à l'outil:
spy_game_agent = SpyGameAgent (
lr . ChatAgentConfig (
name = "Spy" ,
vecdb = None ,
use_tools = False , # don't use Langroid native tool
use_functions_api = True , # use OpenAI function-call API
)
)
spy_game_agent . enable_message ( ProbeTool ) Pour un exemple de travail complet, consultez le script Chat-agent-tool.py dans le repo langroid-examples .
Supposons que vous souhaitiez qu'un agent extrait les termes clés d'un bail, à partir d'un document de location, en tant que structure JSON imbriquée. Définissez d'abord la structure souhaitée via des modèles pydantes:
from pydantic import BaseModel
class LeasePeriod ( BaseModel ):
start_date : str
end_date : str
class LeaseFinancials ( BaseModel ):
monthly_rent : str
deposit : str
class Lease ( BaseModel ):
period : LeasePeriod
financials : LeaseFinancials
address : str Définissez ensuite l'outil LeaseMessage comme une sous-classe de ToolMessage de Langroid. Remarque L'outil a un argument requis terms de type Lease :
import langroid as lr
class LeaseMessage ( lr . agent . ToolMessage ):
request : str = "lease_info"
purpose : str = """
Collect information about a Commercial Lease.
"""
terms : Lease Définissez ensuite un LeaseExtractorAgent avec une méthode lease_info qui gère cet outil, instancier l'agent et lui permettre d'utiliser et de répondre à cet outil:
class LeaseExtractorAgent ( lr . ChatAgent ):
def lease_info ( self , message : LeaseMessage ) -> str :
print (
f"""
DONE! Successfully extracted Lease Info:
{ message . terms }
"""
)
return json . dumps ( message . terms . dict ())
lease_extractor_agent = LeaseExtractorAgent ()
lease_extractor_agent . enable_message ( LeaseMessage ) Voir le script chat_multi_extract.py dans le dépôt langroid-examples pour un exemple de travail complet.
Langroid fournit un DocChatAgent de classe d'agent spécialisée à cet effet. Il intègre le fragment de document, l'intégration, le stockage dans un Vector-DB et la génération de requête-répondage de requête auprès de la récupération. Il est facile d'utiliser cette classe pour discuter avec une collection de documents. Créez d'abord une instance DocChatAgentConfig , avec un champ doc_paths qui spécifie les documents avec lesquels discuter.
import langroid as lr
from langroid . agent . special import DocChatAgentConfig , DocChatAgent
config = DocChatAgentConfig (
doc_paths = [
"https://en.wikipedia.org/wiki/Language_model" ,
"https://en.wikipedia.org/wiki/N-gram_language_model" ,
"/path/to/my/notes-on-language-models.txt" ,
],
vecdb = lr . vector_store . QdrantDBConfig (),
) Puis instancier le DocChatAgent (cela ingère les documents dans le magasin vectoriel):
agent = DocChatAgent ( config )Ensuite, nous pouvons soit poser des questions uniques à l'agent,
agent . llm_response ( "What is a language model?" ) Ou enveloppez-le dans une Task et exécutez une boucle interactive avec l'utilisateur:
task = lr . Task ( agent )
task . run () Voir les scripts fonctionnels complets dans le dossier docqa du repo langroid-examples .
À l'aide de Langroid, vous pouvez configurer un TableChatAgent avec un ensemble de données (chemin de fichier, URL ou DataFrame) et les interroger. Le LLM de l'agent génère du code PANDAS pour répondre à la requête, via l'appel des fonctions (ou l'outil / plugin), et la méthode de gestion de fonction de l'agent exécute le code et renvoie la réponse.
Voici comment vous pouvez faire ceci:
import langroid as lr
from langroid . agent . special import TableChatAgent , TableChatAgentConfig Configurez un TableChatAgent pour un fichier de données, URL ou DataFrame (Assurez-vous que le tableau de données a une ligne d'en-tête; le délimiteur / séparateur est automatiquement détecté):
dataset = "https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv"
# or dataset = "/path/to/my/data.csv"
# or dataset = pd.read_csv("/path/to/my/data.csv")
agent = TableChatAgent (
config = TableChatAgentConfig (
data = dataset ,
)
)Configurez une tâche et posez des questions ponctuelles comme celle-ci:
task = lr . Task (
agent ,
name = "DataAssistant" ,
default_human_response = "" , # to avoid waiting for user input
)
result = task . run (
"What is the average alcohol content of wines with a quality rating above 7?" ,
turns = 2 # return after user question, LLM fun-call/tool response, Agent code-exec result
)
print ( result . content )Ou alternativement, configurez une tâche et exécutez-la dans une boucle interactive avec l'utilisateur:
task = lr . Task ( agent , name = "DataAssistant" )
task . run () Pour un exemple de travail complet, consultez le script table_chat.py dans le répo langroid-examples .
Si vous aimez ce projet, veuillez lui donner une étoile et? Passez le mot dans votre réseau ou sur les réseaux sociaux:
Votre soutien aidera à créer l'élan et la communauté de Langroid.
