langroid
0.24.0
Langroid é uma estrutura Python intuitiva, leve, extensível e com princípios para criar facilmente aplicativos movidos a LLM, dos pesquisadores da CMU e UW-Madison. Você configura agentes, os equipa com componentes opcionais (LLM, Vector Store e Ferramentas/Funções), atribui tarefas e resolve colaborativamente um problema trocando mensagens. Esse paradigma multi-agente é inspirado na estrutura do ator (mas você não precisa saber nada sobre isso!).
Langroid é uma nova opinião sobre o desenvolvimento de aplicativos da LLM, onde considerável pensamento foi simplificando a experiência do desenvolvedor; Ele não usa Langchain ou qualquer outra estrutura LLM.
Leia a visão geral (WIP) da arquitetura Langroid
? As empresas estão usando/adaptando o Langroid na produção . Aqui está uma cotação:
A Nullify usa agentes de IA para desenvolvimento seguro de software. Ele encontra, prioriza e corrige vulnerabilidades. Adaptamos internamente a estrutura de orquestração multi-agente do Langroid na produção, depois de avaliar o Crewai, Autogen, Langchain, Langflow, etc. Descobrimos o Langroid muito superior a essas estruturas em termos de facilidade de configuração e flexibilidade. O agente e as abstrações de tarefas do Langroid são intuitivos, bem pensados e proporcionam uma ótima experiência de desenvolvedor. Queríamos a maneira mais rápida de obter algo na produção. Com outras estruturas, levaria semanas, mas com o Langroid, obtivemos bons resultados em minutos. Altamente recomendado!
- Jacky Wong, chefe da IA da Nullify.
Veja esta introdução à postagem do blog Langroid da equipe LANCE
Acabado de publicar em ML for Healthcare (2024): um sistema de pano multi-agente baseado em Langroid para farmacovigilância, consulte a postagem do blog
Congratulamo -nos com contribuições: consulte o documento de contribuições para obter idéias sobre o que contribuir.
Você está criando aplicativos LLM ou deseja ajuda com o Langroid para sua empresa ou deseja priorizar os recursos do Langroid para os casos de uso da sua empresa? Prasad Chalasani está disponível para consultoria (consultoria/desenvolvimento): pchalasani no Gmail Dot Com.
O patrocínio também é aceito por patrocinadores do GitHub
Perguntas, feedback, idéias? Junte -se a nós na discórdia!
Este é apenas um teaser; Há muito mais, como chamado/ferramentas de função, colaboração multi-agente, extração de informações estruturadas, DocChatagent (RAG), SQLCHATAGENT, LLMS LOCAL/REMOTO NÃO OPENAI, etc. Role para baixo ou veja os documentos para mais. Consulte o Colab de partida rápida do Langroid que cria um exemplo de extração de informações de 2 agentes usando a API do OpenAi ChatCompletion. Veja também esta versão que usa a API de assistentes do OpenAI.
Acabou de lançar! Exemplo de script mostrando como você pode usar multi-agentes e ferramentas do Langroid para extrair informações estruturadas de um documento usando apenas um LLM local (Mistral-7b-Instruct-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 com formato rigoroso de saída de esquema JSON no LLMS compatível e modo rigoroso para a API do OpenAi Tools.Qwen2.5-Coder-32b-Instruct ) hospedado no GLHF.CHATOutubro de 2024:
Set 2024:
o1-mini e o1-preview .DocChatAgent usa a fusão de classificação recíproca (RRF) para classificar os pedaços recuperados por diferentes métodos.run_batch_task NOVA OPÇÃO - stop_on_first_result - Permite o término do lote assim que qualquer tarefa retornar um resultado.Agosto de 2024:
Task.run(), Task.run_async .Jul 2024:
Jun 2024:
RewindTool , que permite que um agente "retrocede e refaça" uma mensagem passada (e todas as mensagens dependentes são limpas graças ao rastreamento da linhagem). Leia as notas aqui.Maio de 2024:
doc-chat , db (para dependências relacionadas ao banco de dados). Consulte as instruções de instalação atualizadas abaixo e nos documentos.examples de classe nomeado, e um exemplo aleatório dessa lista seria usado para gerar um exemplo de 1 tiro para o LLM. Isso foi aprimorado para que você possa fornecer uma lista de exemplos em que cada exemplo seja uma instância de ferramenta ou uma tupla de (descrição, instância da ferramenta), onde a descrição é um "pensamento" que leva o LLM a usar a ferramenta (consulte o exemplo nos documentos). Em alguns cenários, isso pode melhorar a precisão da geração de ferramentas LLM. Além disso, agora, em vez de um exemplo aleatório, todos os exemplos são usados para gerar alguns exemplos de alguns tiros.TaskConfig . Somente detecta loops exatos , em vez de aproximar loops onde as entidades estão dizendo que as coisas essencialmente semelhantes (mas não exatamente as mesmas) repetidamente.RecipientTool , com a troca de que, como não é uma ferramenta, não há como aplicar/lembrar o LLM para especificar explicitamente um destinatário (em cenários em que isso é importante).DocChatAgent .gpt-4o agora é o LLM padrão por toda parte; Atualizar testes e exemplos para trabalhar com este LLM; Use tokenizer correspondente ao LLM.gemini 1.5 pro via litellmQdrantDB: Atualização para oferecer suporte a incorporações esparsas aprendidas.Abr 2024:
chat_model="groq/llama3-8b-8192" . Veja o tutorial.Task.run(), Task.run_async(), run_batch_tasks têm parâmetros max_cost e max_tokens para sair quando os tokens ou o custo excedem um limite. O resultado ChatDocument.metadata agora inclui um campo status que é um código que indica um código de motivo de conclusão da tarefa. task.run() etc pode ser invocado com um campo explícito session_id , que é usado como uma chave para procurar várias configurações no Cache Redis. Atualmente, costumava procurar "status de matar" - isso permite matar uma tarefa em execução, por task.kill() ou pela classe Task.kill_session(session_id) . Por exemplo, uso, consulte o test_task_kill em testes/main/test_task.pyMar 2024:
DocChatAgent , consulte o test_doc_chat_agent.py em particular o test_doc_chat_batch() ; Nova tarefa Run Utility: run_batch_task_gen onde um gerador de tarefas pode ser especificado, para gerar uma tarefa por entrada.DocChatAgent agora funcionará com o Image-PDFS).DocChatAgent Window FixesURLLoader : Detecte o tempo do arquivo do cabeçalho quando o URL não terminar com um sufixo reconhecível como .pdf , .docx , etc.sentence_transformer estar disponível.unstructured , haystack , chromadb , mkdocs , huggingface-hub , sentence-transformers .import langroid as lrFevereiro de 2024:
chat_model="ollama/mistral" . Veja Notas de lançamento.Jan 2024:
SQLChatAgent funciona). Consulte Exemplo de script usando este agente para responder a perguntas sobre as dependências do Python PKG..doc (além de .docx )formatter opcional no OpenAIGPTConfig para garantir uma formatação precisa de bate -papo para LLMs locais.DocChatAgentConfig possui um novo param: add_fields_to_content , para especificar campos de documentos adicionais para inserir no campo content principal, para ajudar a melhorar a recuperação.Dezembro de 2023:
DocChatAgent : ingerir quadro de dados e filtragem de pandas.LanceDocChatAgent LanceDB VECTOR-DB para busca eficiente de busca de vetores e pesquisa e filtragem de texto completo.LanceRAGTaskCreator para criar um sistema de 2 agentes que consiste em um LanceFilterAgent que decide um filtro e reformular a consulta para enviar para um agente de trava.Task com ChatAgent padrão.Nov 2023:
0.1.126: Agente OpenAiasSistant: Suporte ao cache.
0.1.117: Suporte para Ferramentas API de Assistente do OpenAI: Chamada de Função, Código-Intestro e Retriever (RAG), Uploads de Arquivos. Eles funcionam perfeitamente com a orquestração de tarefas do Langroid. Até que os documentos estejam prontos, é melhor ver estes exemplos de uso:
Testes:
Exemplo de scripts:
0.1.112: OpenAIAssistant é uma subclasse de ChatAgent que aproveita a nova API Assistente do Openai. Ele pode ser usado como um substituto para ChatAgent e conta com a API assistente para manter o estado de conversação e aproveita tópicos e assistentes persistentes para se reconectar, se necessário. Exemplos: test_openai_assistant.py , test_openai_assistant_async.py
0.1.111: Suporte mais recente modelo OpenAI: GPT4_TURBO (consulte test_llm.py, por exemplo, uso)
0.1.110: Atualizar do OpenAI v0.x para V1.1.1 (em preparação para API de assistentes e muito mais); ( litellm desativou temporariamente devido ao conflito da versão OpenAI).
Outubro de 2023:
DocChatAgent : rank_with_diversity , rank_to_periphery (perdido no meio).DocChatAgentConfig.n_neighbor_chunks > 0 Permite retornar pedaços de contexto em torno da partida.DocChatAgent usa RelevanceExtractorAgent para que o LLM extrato porções relevantes de um pedaço usando o número de frases, resultando em uma enorme velocidade e redução de custos em comparação com a abordagem ingênua de "parado de frases" (escrevendo sentenças completas relevantes) que os usos de LangChain em seu LLMChainExtractor .import langroid as lr . Veja a documentação para uso.Set 2023:
docx (preliminares).SQLChatAgent aprimorado que recupera com eficiência informações de esquema relevante ao traduzir a linguagem natural para o SQL.Agosto de 2023:
GoogleSearchTool para permitir que os agentes (seu LLM) façam pesquisas no Google por meio de chamada/ferramentas de função. Veja este exemplo de bate -papo sobre como é fácil adicionar essa ferramenta a um agente.SQLChatAgent - Graças ao nosso mais recente colaborador Rithwik Babu!Julho de 2023:
TableChatAgent para conversar com conjuntos de dados tabulares (DataFrames, Arquivos, URLs): LLM gera código PANDAS e o código é executado usando o mecanismo de chamada/função da ferramenta do Langroid.DocChatAgent agora aceita arquivos PDF ou URLs.Suponha que você queira extrair informações estruturadas sobre os principais termos de um documento de arrendamento comercial. Você pode fazer isso facilmente com o Langroid usando um sistema de dois agentes, como mostramos no Repo Langroid-Exemplos. (Veja este script para uma versão com a mesma funcionalidade usando um modelo Mistral-7b local.) A demonstração mostra apenas alguns dos muitos recursos do Langroid, como:
LeaseExtractor é responsável pela tarefa e seu LLM (GPT4) gera perguntas a serem respondidas pelo DocAgent .DocAgent LLM (GPT4) usa a recuperação de uma loja de vetores para responder às perguntas do LeaseExtractor , cita o trecho específico que apoia a resposta.LeaseExtractor LLM apresenta as informações em um formato estruturado usando uma chamada de função.Aqui está o que parece em ação (um vídeo mp4 pausível está aqui).
(Para uma lista mais atualizada, consulte a seção Atualizações/lançamentos acima)
Task.run() possui a mesma assinatura de tipo que os métodos de um responsador de um agente, e isso é fundamental para como uma tarefa de um agente pode delegar a outras submarcas: do ponto de vista de uma tarefa, as submarcas são simplesmente respondentes adicionais, para serem usados de maneira redonda de robina após os próprios respondedores.Agent e Task permitem que os usuários projetem agentes com habilidades específicas, envolvam -as em tarefas e combinem tarefas de maneira flexível.ToolMessage que funciona com qualquer LLM, não apenas do OpenAI. A chamada de funções e as ferramentas têm a mesma interface voltada para o desenvolvedor, implementada usando o Pydantic, o que facilita muito a definição de ferramentas/funções e permitir que os agentes os usem. Os benefícios do uso do pydantic são que você nunca precisa escrever especificações JSON complexas para chamadas de funções e, quando o LLM alucina o JSON malformado, a mensagem de erro pydantic é enviada de volta ao LLM para que possa corrigi -lo.langroid O Langroid requer Python 3.11+. Recomendamos usar um ambiente virtual. Use pip para instalar uma versão esbelta do langroid (da Pypi) para o seu ambiente virtual:
pip install langroid O pacote Langroid Core permite que você use os modelos OpenAI INCEDDINGS por meio de sua API. Se você deseja usar os sentence-transformers que incorporam modelos do huggingface, instale o Langroid como este:
pip install " langroid[hf-embeddings] "Para muitos cenários práticos, você pode precisar de dependências opcionais adicionais:
doc-chat Extra: pip install " langroid[doc-chat] "db extra: pip install " langroid[db] "
` `pip install " langroid[doc-chat,db] "all mais (mas observe que isso resultará em horários de carga/inicialização mais longos e em um tamanho de instalação maior): pip install " langroid[all] " Se você estiver usando SQLChatAgent (por exemplo, os examples/data-qa/sql-chat/sql_chat.py ), com um banco de dados pós-graus, precisará:
sudo apt-get install libpq-dev no ubuntu,brew install postgresql no Mac, etc.pip install langroid[postgres] ou poetry add langroid[postgres] ou poetry install -E postgres . Se isso lhe der um erro, tente pip install psycopg2-binary no seu VirtualEnv. Se você receber erros estranhos envolvendo mysqlclient , tente pip uninstall mysqlclient seguido pelo pip install mysqlclient .
Para começar, tudo o que você precisa é de uma chave da API OpenAI. Se você não tiver um, consulte esta página Openai. (Observe que, embora essa seja a maneira mais simples de começar, o Langroid trabalha com praticamente qualquer LLM, não apenas para o Openai. Veja os guias para usar LLMs abertos/locais e outros LLMs proprietários não abertos.)
Na raiz do repo, copie o arquivo .env-template para um novo arquivo .env :
cp .env-template .env Em seguida, insira sua chave da API do OpenAI. Seu arquivo .env deve ficar assim (a organização é opcional, mas pode ser necessária em alguns cenários).
OPENAI_API_KEY=your-key-here-without-quotes
OPENAI_ORGANIZATION=optionally-your-organization-idComo alternativa, você pode definir isso como uma variável de ambiente em seu shell (você precisará fazer isso toda vez que abrir um novo shell):
export OPENAI_API_KEY=your-key-here-without-quotesTodas as configurações de variáveis de ambiente a seguir são opcionais e algumas são necessárias apenas para usar recursos específicos (conforme observado abaixo).
.env , como o valor de MOMENTO_AUTH_TOKEN (veja o arquivo de exemplo abaixo),.env conjunto de arquivos CACHE_TYPE=momento (em vez de CACHE_TYPE=redis , que é o padrão).GoogleSearchTool . Para usar a pesquisa do Google como uma ferramenta/plug-in/função LLM, você precisará configurar uma tecla API do Google e configurar um mecanismo de pesquisa personalizado do Google (CSE) e obter o ID do CSE. (A documentação para estes pode ser desafiadora, sugerimos solicitar ao GPT4 um guia passo a passo.) Depois de obter essas credenciais, armazene-as como valores do GOOGLE_API_KEY e GOOGLE_CSE_ID no seu arquivo .env . A documentação completa sobre o uso disso (e outras ferramentas "sem estado") está chegando em breve, mas, enquanto isso, dê uma olhada neste exemplo de bate -papo, que mostra como você pode equipar facilmente um agente com um GoogleSearchtool . Se você adicionar todas essas variáveis opcionais, seu arquivo .env deve ficar assim:
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 Ao usar o Azure OpenAI, são necessárias variáveis de ambiente adicionais no arquivo .env . Esta página Microsoft Azure OpenAI fornece mais informações e você pode definir cada variável de ambiente como segue:
AZURE_OPENAI_API_KEY , a partir do valor da API_KEYAZURE_OPENAI_API_BASE do valor do ENDPOINT , geralmente se parece com https://your.domain.azure.com .AZURE_OPENAI_API_VERSION , você pode usar o valor padrão no .env-template , e a versão mais recente pode ser encontrada aquiAZURE_OPENAI_DEPLOYMENT_NAME é o nome do modelo implantado, que é definido pelo usuário durante a configuração do modeloAZURE_OPENAI_MODEL_NAME Azure OpenAI permite nomes de modelos específicos quando você seleciona o modelo para sua implantação. Você precisa colocar com precisão o nome exato do modelo que foi selecionado. Por exemplo, o GPT-4 (deve ser gpt-4-32k ou gpt-4 ).AZURE_OPENAI_MODEL_VERSION é necessário se AZURE_OPENAI_MODEL_NAME = gpt=4 , que ajudará o Langroid a determinar o custo do modelo Fornecemos uma versão em contêiner do repositório langroid-examples por meio desta imagem do Docker. Tudo o que você precisa fazer é configurar variáveis de ambiente no arquivo .env . Siga estas etapas para configurar o contêiner:
# 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 > São teasers rápidos para dar uma olhada no que você pode fazer com o Langroid e como seria seu código.
langroid-examples .
As várias instruções e instruções do LLM no Langroid foram testadas para funcionar bem com o GPT-4 (e até certo ponto o GPT-4O). A mudança para outros LLMs (local/aberta e proprietária) é fácil (consulte os guias mencionados acima) e pode ser suficiente para algumas aplicações, mas em geral você pode ver resultados inferiores, a menos que ajuste os avisos e/ou a configuração de vários agentes.
Veja também o Getting Started Guide para um tutorial detalhado.
Clique para expandir qualquer um dos exemplos de código abaixo. Tudo isso pode ser executado em um notebook 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. Se o modelo for suportado pela liteLLM , não há necessidade de iniciar o servidor proxy. Basta definir o parâmetro chat_model acima como litellm/[provider]/[model] , por exemplo, litellm/anthropic/claude-instant-1 e usar o objeto de configuração como acima. Observe que, para usar litellm , você precisa instalar o Langroid com o litellm Extra: poetry install -E litellm ou pip install langroid[litellm] . Para modelos remotos, você normalmente precisará definir teclas de API etc como variáveis de ambiente. Você pode definir aqueles com base nos documentos Litellm. Se houver alguma variável de ambiente necessário, o Langroid fornecerá uma mensagem de erro útil, indicando quais são necessárias. Observe que, para usar langroid com litellm , você precisa instalar o litellm extra, ou seja, pip install langroid[litellm] em seu Env virtual, ou se estiver desenvolvendo no 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 Um jogo de números de brinquedos, onde quando recebeu um número n :
repeater_task 's llm simplesmente retorna n ,even_task llm retorna n/2 se n é par, outra coisa diz "Do-não-sabe"odd_task de Llm retorna 3*n+1 se n for ímpar, senão diz "do-não-know" Cada uma dessas Task configura automaticamente um ChatAgent padrão.
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
) Em seguida, adicione o even_task e odd_task como subtares de repeater_task e execute o repeater_task , iniciando-o com um número como entrada:
repeater_task . add_sub_task ([ even_task , odd_task ])
repeater_task . run ( "3" )O Langroid aproveita o Pydantic para apoiar a API de chamada de função do OpenAI, bem como suas próprias ferramentas nativas. Os benefícios são que você não precisa escrever nenhum JSON para especificar o esquema e, também se o LLM alucina uma sintaxe de ferramenta malformada, o Langroid enviar o erro de validação pydantic (adequadamente higienizado) para o LLM para que ele possa corrigi -lo!
Exemplo simples: digamos que o agente tenha uma lista secreta de números e queremos que o LLM encontre o menor número da lista. Queremos dar ao LLM uma ferramenta/função probe que leva um único número n como argumento. O método do manipulador de ferramentas no agente retorna quantos números em sua lista são no máximo n .
Primeiro, defina a ferramenta usando a classe de ToolMessage do 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 Em seguida, defina um SpyGameAgent como uma subclasse de ChatAgent , com uma probe de método que lida com esta ferramenta:
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 ]))Em seguida, instanciamos o agente e permitimos que ele use e responda à ferramenta:
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 um exemplo de trabalho completo, consulte o script Chat-AGENT-TOOL.PY no repo langroid-examples .
Suponha que você queira que um agente extraja os termos -chave de um arrendamento, de um documento de arrendamento, como uma estrutura JSON aninhada. Primeiro defina a estrutura desejada por meio de modelos pydantic:
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 Em seguida, defina a ferramenta LeaseMessage como uma subclasse da ToolMessage do Langroid. Observe que a ferramenta possui um argumento necessário terms 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 Em seguida, defina um LeaseExtractorAgent com um método lease_info que lida com essa ferramenta, instancie o agente e permita que ele use e responda a esta ferramenta:
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 ) Consulte o script chat_multi_extract.py no repo langroid-examples para um exemplo de trabalho completo.
O Langroid fornece uma classe de agente especializada DocChatAgent para esse fim. Ele incorpora sharding, incorporação, armazenamento, armazenamento em uma geração de vetor-db e recuperação de consulta agmentada por recuperação. Usar esta classe para conversar com uma coleção de documentos é fácil. Primeiro, crie uma instância DocChatAgentConfig , com um campo doc_paths que especifica os documentos para conversar.
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 (),
) Em seguida, instancie o DocChatAgent (isso ingere os documentos na loja de vetores):
agent = DocChatAgent ( config )Então podemos fazer perguntas únicas ao agente,
agent . llm_response ( "What is a language model?" ) Ou envolva -o em uma Task e execute um loop interativo com o usuário:
task = lr . Task ( agent )
task . run () Consulte scripts de trabalho completo na pasta docqa do repo langroid-examples .
Usando o Langroid, você pode configurar um TableChatAgent com um conjunto de dados (caminho do arquivo, URL ou DataFrame) e consultar. O LLM do agente gera código Pandas para responder à consulta, via chamado de função (ou ferramenta/plug-in), e o método de manipulação de funções do agente executa o código e retorna a resposta.
Aqui está como você pode fazer isso:
import langroid as lr
from langroid . agent . special import TableChatAgent , TableChatAgentConfig Configure um TableChatAgent para um arquivo de dados, URL ou DataFrame (verifique se a tabela de dados possui uma linha de cabeçalho; o delimitador/separador é detectado automaticamente):
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 uma tarefa e faça perguntas ú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 )Ou alternativamente, configure uma tarefa e execute -a em um loop interativo com o usuário:
task = lr . Task ( agent , name = "DataAssistant" )
task . run () Para um exemplo de trabalho completo, consulte o script table_chat.py no repo langroid-examples .
Se você gosta deste projeto, dê uma estrela e? Espalhe a palavra em sua rede ou mídia social:
Seu apoio ajudará a construir o impulso e a comunidade do Langroid.
