langroid
0.24.0
Langroid es un marco de Python intuitivo, liviano, extensible y de principios para construir fácilmente aplicaciones con alimentación de LLM, a partir de investigadores de CMU y UW-Madison. Configura agentes, los equipa con componentes opcionales (LLM, vector-tienda y herramientas/funciones), les asigna tareas y que resuelva colaborativamente un problema intercambiando mensajes. Este paradigma de múltiples agentes está inspirado en el marco del actor (¡pero no necesita saber nada sobre esto!).
Langroid es una nueva versión del desarrollo de aplicaciones LLM, donde se ha hecho un pensamiento considerable para simplificar la experiencia del desarrollador; No usa Langchain , ni ningún otro marco LLM.
Lea la descripción (WIP) de la arquitectura Langroid
? Las empresas están utilizando/adaptando a Langroid en producción . Aquí hay una cita:
Nullify utiliza agentes de IA para el desarrollo de software seguro. Encuentra, prioriza y arregla vulnerabilidades. Hemos adaptado internamente el marco de orquestación de múltiples agentes de Langroid en la producción, después de evaluar Crewai, Autogen, Langchain, Langflow, etc. Encontramos que Langroid es muy superior a esos marcos en términos de facilidad de configuración y flexibilidad. Las abstracciones de agente y tareas de Langroid son intuitivas, bien pensadas y proporcionan una gran experiencia de desarrollador. Queríamos la forma más rápida de obtener algo en producción. Con otros marcos nos habría llevado semanas, pero con Langroid obtuvimos buenos resultados en minutos. ¡Muy recomendable!
- Jacky Wong, cabeza de AI en Nullify.
Vea esta publicación de blog de introducción a Langroid del equipo LancedB
Acabo de publicar en ML para HealthCare (2024): un sistema de trapo múltiple basado en langroid para farmacovigilancia, vea la publicación del blog
Agradecemos las contribuciones: vea el documento de contribuciones para obtener ideas sobre qué contribuir.
¿Está construyendo aplicaciones LLM o desea ayuda con Langroid para su empresa, o desea priorizar las funciones de Langroid para los casos de uso de su empresa? Prasad Chalasani está disponible para consultoría (asesor/desarrollo): Pchalasani en Gmail Dot Com.
El patrocinio también se acepta a través de Github Patrocinadores
Preguntas, comentarios, ideas? ¡Únete a nosotros en Discord!
Esto es solo un teaser; Hay mucho más, como la llamada/herramientas de funciones, la colaboración de múltiples agentes, la extracción de información estructurada, Docchatagent (RAG), SQLCHATAGENT, LLMS LOCALES/REMOTOS NO OPENAI, etc. Desplácese hacia abajo o vea los documentos para obtener más información. Consulte el Colab de arranque rápido de Langroid que se desarrolla con un ejemplo de extracción de información de 2 agentes utilizando la API de Completion de OpenAI CHATCOMET. Consulte también esta versión que utiliza la API de asistentes de OpenAI.
¡Acabo de lanzar! Ejemplo de script que muestra cómo puede usar múltiples agentes y herramientas Langroid para extraer información estructurada de un documento utilizando solo un LLM local (Mistral-7B-InNSTRUCT-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 con formato de salida de esquema JSON estricto en LLMS compatibles y modo estricto para la API de OpenAI Tools.Qwen2.5-Coder-32b-Instruct ) alojado en GLHF.CHATOct 2024:
SEP 2024:
o1-mini y o1-preview .DocChatAgent usa fusión de rango recíproco (RRF) para clasificar los trozos recuperados por diferentes métodos.run_batch_task nueva opción - stop_on_first_result - Permite la terminación de lotes tan pronto como cualquier tarea devuelva un resultado.Agosto de 2024:
Task.run(), Task.run_async .Jul 2024:
Jun 2024:
RewindTool , que permite a un agente "rebobinar y rehacer" un mensaje pasado (y todos los mensajes dependientes se borran gracias al seguimiento de linaje). Lea las notas aquí.Mayo de 2024:
doc-chat , db (para dependencias relacionadas con la base de datos). Consulte las instrucciones de instalación actualizadas a continuación y en los documentos.examples de ClassMethod con nombre, y un ejemplo aleatorio de esta lista se utilizaría para generar un ejemplo de 1 disparo para el LLM. Esto se ha mejorado para que ahora pueda proporcionar una lista de ejemplos en los que cada ejemplo es una instancia de herramienta o una tupla de (descripción, instancia de herramienta), donde la descripción es un "pensamiento" que lleva a la LLM a usar la herramienta (ver ejemplo en los documentos). En algunos escenarios, esto puede mejorar la precisión de la generación de herramientas LLM. Además, ahora, en lugar de un ejemplo aleatorio, todos los ejemplos se utilizan para generar pocos ejemplos de disparos.TaskConfig . Solo detecta los bucles exactos , en lugar de los bucles aproximados donde las entidades dicen esencialmente similares (pero no exactamente las mismas) cosas repetidamente.RecipientTool , con la compensación de que, dado que no es una herramienta, no hay forma de aplicar/recordarle al LLM que especifique explícitamente un destinatario (en escenarios donde esto es importante).DocChatAgent .gpt-4o es ahora el LLM predeterminado en todo momento; Actualizar pruebas y ejemplos para trabajar con este LLM; Use tokenizador correspondiente al LLM.gemini 1.5 pro Soporte a través de litellmQdrantDB: Actualización para admitir incrustaciones escasas aprendidas.Abr 2024:
chat_model="groq/llama3-8b-8192" . Ver tutorial.Task.run(), Task.run_async(), run_batch_tasks tiene parámetros max_cost y max_tokens para salir cuando las tokens o el costo exceden un límite. El resultado ChatDocument.metadata ahora incluye un campo status que es un código que indica un código de razón de finalización de tarea. También task.run() etc se puede invocar con un campo explícito session_id que se utiliza como clave para buscar varias configuraciones en Redis Cache. Actualmente solo se usa para buscar el "estado de matar": esto permite matar una tarea de ejecución, ya sea por task.kill() o por el classmethod Task.kill_session(session_id) . Por ejemplo, el uso, consulte test_task_kill en tests/main/test_task.pyMarzo de 2024:
DocChatAgent , consulte test_doc_chat_agent.py en particular el test_doc_chat_batch() ; Nueva tarea Ejecutar utilidad: run_batch_task_gen donde se puede especificar un generador de tareas, para generar una tarea por entrada.DocChatAgent ahora funcionará con Image-PDFS).DocChatAgent Contexting-Window FixesURLLoader : detectar el tiempo de archivo del encabezado cuando la URL no termina con un sufijo reconocible como .pdf , .docx , etc.sentence_transformer está disponible.unstructured , haystack , chromadb , mkdocs , huggingface-hub , sentence-transformers .import langroid as lrFebrero de 2024:
chat_model="ollama/mistral" . Ver Notas de la versión.Enero de 2024:
SQLChatAgent ). Consulte el script de ejemplo usando este agente para responder preguntas sobre las dependencias de Python PKG..doc (además de .docx )formatter opcional en OpenAIGPTConfig para garantizar un formato de chat preciso para LLM locales.DocChatAgentConfig tiene un nuevo parámetro: add_fields_to_content , para especificar campos de documentos adicionales para insertar en el campo content principal, para ayudar a mejorar la recuperación.Diciembre de 2023:
DocChatAgent : ingerir pandas dataframes y filtrado.LanceDocChatAgent aprovecha LanceDB Vector-DB para una búsqueda vectorial eficiente y búsqueda y filtrado de texto completo.LanceRAGTaskCreator para crear un sistema de 2 agentes que consiste en un LanceFilterAgent que decide un filtro y una consulta de reformas para enviar a un agente de RAG.Task más simple con ChatAgent predeterminado.Nov 2023:
0.1.126: Agente OpenAiassistante: soporte de almacenamiento en caché.
0.1.117: Soporte para herramientas API de asistente de OpenAI: llamas de funciones, entrisador de código y retriever (RAG), cargas de archivos. Estos funcionan sin problemas con la orquestación de tareas de Langroid. Hasta que los documentos estén listos, es mejor ver estos ejemplos de uso:
Pruebas:
Ejemplo de scripts:
0.1.112: OpenAIAssistant es una subclase de ChatAgent que aprovecha la nueva API asistente de OpenAI. Se puede utilizar como reemplazo de ChatAgent , y se basa en la API asistente para mantener el estado de conversación y aprovecha los hilos y asistentes persistentes para que se vuelvan a conectarlos si es necesario. Ejemplos: test_openai_assistant.py , test_openai_assistant_async.py
0.1.111: Apoyo al último modelo Operai: GPT4_TURBO (ver test_llm.py, por ejemplo, el uso)
0.1.110: Actualización de OpenAI V0.X a V1.1.1 (en preparación para asistentes API y más); ( litellm deshabilitado temporalmente debido al conflicto de la versión OpenAI).
Oct 2023:
DocChatAgent re-rankers: rank_with_diversity , rank_to_periphery (perdido en el medio).DocChatAgentConfig.n_neighbor_chunks > 0 permite que devuelvan fragmentos de contexto alrededor del partido.DocChatAgent utiliza RelevanceExtractorAgent para que el LLM extraiga porciones relevantes de un fragmento utilizando el número de oraciones, lo que resulta en una gran aceleración y una reducción de costos en comparación con el enfoque ingenuo de "párvelo de oraciones" (escribiendo oraciones completas de oraciones completas) que usa LangChain en su LLMChainExtractor .import langroid as lr . Vea la documentación para el uso.SEP 2023:
docx (preliminar).SQLChatAgent mejorado que recupera eficientemente la información de esquema relevante al traducir el lenguaje natural a SQL.Agosto de 2023:
GoogleSearchTool para habilitar a los agentes (su LLM) para realizar búsquedas en Google a través de funciones/herramientas. Vea este ejemplo de chat de lo fácil que es agregar esta herramienta a un agente.SQLChatAgent - ¡Gracias a nuestro último colaborador Rithwik Babu!Julio de 2023:
TableChatAgent para chatear con conjuntos de datos tabulares (Dataframes, archivos, URL): LLM genera código PANDAS, y el código se ejecuta utilizando el mecanismo de herramienta/función de función de Langroid.DocChatAgent ahora acepta archivos o URL PDF.Supongamos que desea extraer información estructurada sobre los términos clave de un documento de arrendamiento comercial. Puede hacerlo fácilmente con Langroid usando un sistema de dos agentes, como mostramos en el repositorio de Examples Langroid. (Consulte este script para una versión con la misma funcionalidad utilizando un modelo local Mistral-7B). La demostración muestra solo algunas de las muchas características de Langroid, como:
LeaseExtractor está a cargo de la tarea, y su LLM (GPT4) genera preguntas que debe ser respondida por el DocAgent .DocAgent LLM (GPT4) utiliza la recuperación de una tienda de vectores para responder a las preguntas del LeaseExtractor , cita el extracto específico que respalda la respuesta.LeaseExtractor LLM presenta la información en un formato estructurado utilizando una función de función.Así es como se ve en acción (un video MP4 pausable está aquí).
(Para una lista más actualizada, consulte la sección de actualizaciones/versiones anteriores)
Task.run() tiene la misma firma de tipo que los métodos de un respondedor de un agente, y esto es clave para cómo una tarea de un agente puede delegar a otras subasinas: desde el punto de vista de una tarea, las sub-tareas son simplemente respondedoras adicionales, que se utilizarán de manera redonda después de los respondedores del agente.Agent y Task permiten a los usuarios diseñar agentes con habilidades específicas, envolverlos en tareas y combinar las tareas de manera flexible.ToolMessage equivalente que funciona con cualquier LLM, no solo de OpenAI. Las llamadas de funciones y las herramientas tienen la misma interfaz orientada al desarrollador, implementada con Pydantic, lo que hace que sea muy fácil definir herramientas/funciones y permitir que los agentes las usen. Los beneficios del uso de Pydantic son que nunca tiene que escribir especificaciones de JSON complejas para las llamadas de funciones, y cuando el LLM alucina JSON malformado, el mensaje de error Pydantic se envía de vuelta al LLM para que pueda solucionarlo.langroid Langroid requiere Python 3.11+. Recomendamos usar un entorno virtual. Use pip para instalar una versión delgada de langroid (de PYPI) a su entorno virtual:
pip install langroid El paquete Core Langroid le permite utilizar modelos de incrustaciones Operai a través de su API. Si en su lugar desea usar los modelos de incrustación de sentence-transformers de Huggingface, instale Langroid así:
pip install " langroid[hf-embeddings] "Para muchos escenarios prácticos, es posible que necesite dependencias opcionales adicionales:
doc-chat Extra: pip install " langroid[doc-chat] "db Extra: pip install " langroid[db] "
` `pip install " langroid[doc-chat,db] "all los extra (pero tenga en cuenta que esto dará como resultado tiempos de carga/inicio más largos y un tamaño de instalación más grande): pip install " langroid[all] " Si está utilizando SQLChatAgent (por ejemplo, los examples/data-qa/sql-chat/sql_chat.py ), con un DB Postgres, deberá:
sudo apt-get install libpq-dev en Ubuntu,brew install postgresql en Mac, etc.pip install langroid[postgres] o poetry add langroid[postgres] o poetry install -E postgres . Si esto le da un error, intente pip install psycopg2-binary en su VirtualEnv. Si recibe errores extraños que involucran mysqlclient , intente hacer pip uninstall mysqlclient seguido de pip install mysqlclient .
Para comenzar, todo lo que necesitas es una tecla API de OpenAI. Si no tiene uno, vea esta página de OpenAI. (Tenga en cuenta que si bien esta es la forma más sencilla de comenzar, Langroid funciona con prácticamente cualquier LLM, no solo de OpenAI. Consulte las guías para usar LLM de Open/Local y otros LLM no opuestos.
En la raíz del repositorio, copie el archivo .env-template a un nuevo archivo .env :
cp .env-template .env Luego inserte su tecla API OpenAI. Su archivo .env debe verse así (la organización es opcional pero puede ser necesaria en algunos escenarios).
OPENAI_API_KEY=your-key-here-without-quotes
OPENAI_ORGANIZATION=optionally-your-organization-idAlternativamente, puede establecer esto como una variable de entorno en su shell (necesitará hacer esto cada vez que abra un nuevo shell):
export OPENAI_API_KEY=your-key-here-without-quotesTodas las siguientes configuraciones de variables de entorno son opcionales, y algunas solo se necesitan para usar características específicas (como se indica a continuación).
.env , como el valor de MOMENTO_AUTH_TOKEN (consulte el archivo de ejemplo a continuación),.env set CACHE_TYPE=momento (en lugar de CACHE_TYPE=redis que es el valor predeterminado).GoogleSearchTool . Para usar Google Search como una herramienta/complemento/función de funciones LLM, deberá configurar una tecla API de Google, luego configurar un motor de búsqueda de Google Custom (CSE) y obtener la ID de CSE. (La documentación para estos puede ser un desafío, sugerimos pedirle a GPT4 una guía paso a paso). Después de obtener estas credenciales, guárdelas como valores de GOOGLE_API_KEY y GOOGLE_CSE_ID en su archivo .env . La documentación completa sobre el uso de esto (y otras herramientas "sin estado") llegará pronto, pero mientras tanto, eche un vistazo a este ejemplo de chat, que muestra cómo puede equipar fácilmente a un agente con un GoogleSearchtool . Si agrega todas estas variables opcionales, su archivo .env debería verse así:
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 Al usar Azure OpenAI, se requieren variables de entorno adicionales en el archivo .env . Esta página Microsoft Azure OpenAI proporciona más información, y puede establecer cada variable de entorno de la siguiente manera:
AZURE_OPENAI_API_KEY , desde el valor de API_KEYAZURE_OPENAI_API_BASE Desde el valor del ENDPOINT , generalmente se parece a https://your.domain.azure.com .AZURE_OPENAI_API_VERSION , puede usar el valor predeterminado en .env-template , y la última versión se puede encontrar aquíAZURE_OPENAI_DEPLOYMENT_NAME es el nombre del modelo implementado, que es definido por el usuario durante la configuración del modeloAZURE_OPENAI_MODEL_NAME Azure OpenAI permite nombres de modelos específicos cuando selecciona el modelo para su implementación. Debe poner precisamente el nombre exacto del modelo que se seleccionó. Por ejemplo, GPT-4 (debería ser gpt-4-32k o gpt-4 ).AZURE_OPENAI_MODEL_VERSION se requiere si AZURE_OPENAI_MODEL_NAME = gpt=4 , que ayudará a Langroid para determinar el costo del modelo Proporcionamos una versión contenedor del repositorio de langroid-examples a través de esta imagen de Docker. Todo lo que necesita hacer es configurar las variables de entorno en el archivo .env . Siga estos pasos para configurar el contenedor:
# 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 > Estos son teasers rápidos para ver lo que puede hacer con Langroid y cómo se vería su código.
langroid-examples .
Las diversas indicaciones e instrucciones de LLM en Langroid se han probado para funcionar bien con GPT-4 (y, en cierta medida, GPT-4O). Cambiar a otros LLM (local/abierto y patentado) es fácil (ver las guías mencionadas anteriormente), y puede ser suficiente para algunas aplicaciones, pero en general puede ver resultados inferiores a menos que ajuste las indicaciones y/o la configuración de agente múltiple.
También vea la Getting Started Guide para obtener un tutorial detallado.
Haga clic para expandir cualquiera de los ejemplos de código a continuación. Todo esto se puede ejecutar en un cuaderno de 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 el modelo es compatible con liteLLM , entonces no es necesario iniciar el servidor proxy. Simplemente establezca el chat_model param arriba en litellm/[provider]/[model] , por ejemplo litellm/anthropic/claude-instant-1 y use el objeto de configuración como se indicó anteriormente. Tenga en cuenta que para usar litellm debe instalar Langroid con el litellm extra: poetry install -E litellm o pip install langroid[litellm] . Para modelos remotos, generalmente necesitará establecer las teclas API, etc. como variables de entorno. Puede establecerlos basados en los documentos de litellm. Si faltan variables de entorno requeridas, Langroid ofrece un mensaje de error útil que indica cuáles son necesarios. Tenga en cuenta que para usar langroid con litellm debe instalar el litellm adicional, es decir, pip install langroid[litellm] en su env virtual, o si se está desarrollando dentro del repositorio 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 juego de números de juguete, donde cuando se le da un número n :
repeater_task 's LLM simplemente devuelve n ,even_task 's LLM devuelve n/2 Si n es uniforme, de lo contrario, dice "no saber"odd_task 's LLM Devuelve 3*n+1 Si n es impar, de lo contrario, dice "no saber" Cada una de estas Task configura automáticamente un ChatAgent predeterminado.
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
) Luego agregue el even_task y odd_task como sub-tartas de repeater_task , y ejecute repeater_task , lo iniciando con un número como entrada:
repeater_task . add_sub_task ([ even_task , odd_task ])
repeater_task . run ( "3" )Langroid aprovecha a Pydantic para admitir la API de transferencia de funciones de OpenAI, así como sus propias herramientas nativas. Los beneficios son que no tiene que escribir ningún JSON para especificar el esquema, y también si el LLM alucina una sintaxis de herramienta malformada, Langroid envía el error de validación de pydántico (adecuadamente desinfectado) al LLM para que pueda solucionarlo!
Ejemplo simple: digamos que el agente tiene una lista secreta de números, y queremos que el LLM encuentre el número más pequeño de la lista. Queremos darle al LLM una herramienta/función probe que toma un solo número n como argumento. El método del controlador de herramientas en el agente devuelve cuántos números en su lista son como máximo n .
Primero defina la herramienta utilizando la clase 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 Luego defina un SpyGameAgent como una subclase de ChatAgent , con una probe de método que maneja esta herramienta:
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 ]))Luego instanciamos el agente y le permitimos usar y responder a la herramienta:
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 ) Para un ejemplo de trabajo completo, consulte el script chat-agent-tool.py en el repositorio langroid-examples .
Supongamos que desea que un agente extraiga los términos clave de un arrendamiento, de un documento de arrendamiento, como una estructura JSON anidada. Primero defina la estructura deseada a través de modelos pydánticos:
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 Luego, defina la herramienta LeaseMessage como una subclase de ToolMessage de Langroid. Nota La herramienta tiene un argumento requerido terms de Lease de tipo:
import langroid as lr
class LeaseMessage ( lr . agent . ToolMessage ):
request : str = "lease_info"
purpose : str = """
Collect information about a Commercial Lease.
"""
terms : Lease Luego, defina un LeaseExtractorAgent con un método lease_info que maneja esta herramienta, instanciar al agente y habilitarle que use y responda a esta herramienta:
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 ) Vea el script chat_multi_extract.py en el repositorio langroid-examples para un ejemplo de trabajo completo.
Langroid proporciona una clase de agente especializado DocChatAgent para este propósito. Incorpora fragmentación de documentos, incrustación, almacenamiento en un vector-DB y generación de consulta de consulta acuática de recuperación. Usar esta clase para chatear con una colección de documentos es fácil. Primero cree una instancia DocChatAgentConfig , con un campo doc_paths que especifica los documentos con los que chatear.
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 (),
) Luego instanciar el DocChatAgent (esto ingiere los documentos en la tienda vectorial):
agent = DocChatAgent ( config )Entonces podemos hacerle preguntas únicas al agente,
agent . llm_response ( "What is a language model?" ) o envuélvalo en una Task y ejecute un bucle interactivo con el usuario:
task = lr . Task ( agent )
task . run () Vea los scripts de trabajo completos en la carpeta docqa del repositorio de langroid-examples .
Usando Langroid, puede configurar un TableChatAgent con un conjunto de datos (ruta de archivo, URL o DataFrame), y consultarlo. El LLM del agente genera el código PANDAS para responder a la consulta, a través de la reducción de funciones (o herramienta/complemento), y el método de manejo de funciones del agente ejecuta el código y devuelve la respuesta.
Así es como puedes hacer esto:
import langroid as lr
from langroid . agent . special import TableChatAgent , TableChatAgentConfig Configure un TableChatAgent para un archivo de datos, URL o DataFrame (asegúrese de que la tabla de datos tenga una fila de encabezado; el delimitador/separador se detecta automáticamente):
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 ,
)
)Configure una tarea y haga preguntas únicas como esta:
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 )O alternativamente, configure una tarea y ejecútala en un bucle interactivo con el usuario:
task = lr . Task ( agent , name = "DataAssistant" )
task . run () Para obtener un ejemplo de trabajo completo, consulte el script table_chat.py en el repositorio langroid-examples .
Si te gusta este proyecto, dale una estrella y? Difundir la palabra en su red o redes sociales:
Su apoyo ayudará a construir el impulso y la comunidad de Langroid.
