Langroid: Navegando facilmente em grandes modelos de linguagem com programação corporal multiinteligente

O Langroid é uma estrutura Python para pesquisadores e desenvolvedores projetada para simplificar o processo de criação de aplicativos orientados por LLMs (Large Language Models). Desenvolvida por pesquisadores da Carnegie Mellon University e da University of Wisconsin-Madison, sua ideia central é aproveitar o poder dos LLMs por meio da programação de corpos multiinteligentes. Nessa estrutura, os desenvolvedores podem configurar vários agentes, equipá-los com grandes modelos de linguagem, bancos de dados vetoriais e ferramentas e, em seguida, atribuir tarefas para permitir que esses agentes colaborem na solução de problemas complexos por meio da troca de mensagens. Projetado para ser intuitivo, leve e dimensionável, o Langroid é independente de outras estruturas de LLM (por exemplo, LangChain) e pode funcionar com praticamente qualquer tipo de LLM em grande escala. Ele não depende de outras estruturas LLM (por exemplo, LangChain) e pode ser usado com praticamente qualquer tipo de modelo de linguagem em larga escala, oferecendo aos desenvolvedores um ambiente de desenvolvimento flexível e avançado.

Lista de funções

• Colaboração de inteligência múltipla. Oferece suporte à criação de várias inteligências que podem colaborar por meio de mensagens para trabalhar em conjunto em tarefas complexas.
• Programa de trabalho. aprovar (um projeto de lei ou inspeção etc.)Taskaulas para empacotar as inteligências, definir instruções e metas claras para elas e permitir a delegação de tarefas de forma hierárquica e recursiva.
• Amplo suporte ao LLM. Além de oferecer suporte à família de modelos da OpenAI, centenas de LLMs de outros provedores são suportados por meio de bibliotecas de agentes e servidores locais (por exemplo, ollama, LiteLLM), incluindo modelos de código aberto, implantados localmente e comerciais.
• Ferramentas/chamadas de função. suporta a funcionalidade de chamada de função da OpenAI e fornece seu próprioToolMessageO mecanismo, que é aplicável a qualquer LLM, é definido usando Pydantic, o que simplifica o processo de desenvolvimento e permite o tratamento de JSON formatado incorretamente gerado pelo LLM.
• Geração de aumento de recuperação (RAG). embutidoDocChatAgentEle pode interagir facilmente com coleções de documentos, incluindo arquivos locais e URLs, e oferece suporte a fragmentação, incorporação, armazenamento vetorial e recuperação de documentos.
• Suporte a banco de dados de vetores múltiplos. Oferece suporte a Qdrant, Chroma, LanceDB, Pinecone, pgvector e muitos outros bancos de dados vetoriais para RAG eficiente.
• Mecanismos de cache. Oferece suporte ao armazenamento em cache das respostas da API do LLM usando Redis ou Momento para reduzir o custo e o tempo de chamadas repetidas.
• Observabilidade e registro. Gere registros detalhados de interações de várias inteligências e mantenha a origem e o conteúdo das mensagens para que os desenvolvedores possam rastrear e depurar.

Usando a Ajuda

O Langroid é uma poderosa estrutura Python que permite criar aplicativos complexos combinando diferentes "inteligências". A seguir, explicaremos em detalhes como instalar e usar o Langroid para realizar algumas operações básicas e avançadas.

Instalação do Langroid

O Langroid requer o Python 3.11 ou superior. É altamente recomendável instalá-lo em um ambiente virtual para evitar conflitos de dependência com outros projetos.

1. Instalação da fundação
   A instalação do próprio núcleo é muito simples e requer apenas um comando:

   pip install langroid
   

   Essa versão básica contém a funcionalidade principal necessária para usar os modelos OpenAI.

2. Instalação de recursos adicionais
   O Langroid tem um design modular e muitos recursos avançados exigem a instalação de dependências adicionais. Você pode optar por instalá-las conforme necessário:
   • Recurso de bate-papo de documentos (RAG). Se você precisar permitir que as inteligências leiam e entendam PDFs, documentos do Word etc., precisará instalar odoc-chatPacotes complementares.

     pip install "langroid[doc-chat]"
     

   • Funções de interação do banco de dados. Se você quiser que o corpo inteligente se conecte e consulte o banco de dados, será necessário instalar o pacotedbPacotes complementares.

     pip install "langroid[db]"
     

   • Você também pode instalar vários pacotes de complementos ao mesmo tempo:

     pip install "langroid[doc-chat,db]"
     

   • Instalação de todos os recursos. Se quiser instalar todas as dependências opcionais de uma só vez, você pode usar o comandoallmas isso pode aumentar significativamente o tempo e o tamanho da instalação.

     pip install "langroid[all]"
     

Configuração do ambiente

Quando a instalação estiver concluída, você precisará configurar as variáveis de ambiente necessárias, principalmente a chave da API do Big Language Model.

1. estabelecer.envpapéis
   No diretório raiz do seu projeto, copie o arquivo.env-templatee renomeá-lo.env.

   cp .env-template .env
   

2. Configuração da chave de API
   show (um ingresso).envpreencha sua chave de API da OpenAI. Esse é o requisito mais básico para colocar o Langroid em funcionamento.

   OPENAI_API_KEY=your-key-here-without-quotes
   

Conceitos e operações essenciais

No centro do Langroid estáAgent(Intelligentsia) eTask(Tarefas). A Intelligentsia é um executor, e as tarefas são instruções que orientam como a intelligentsia deve agir.

1. interação direta com o LLM

Você pode ignorar as inteligências e falar diretamente com um LLM configurado. Isso é útil para testar rapidamente as respostas do modelo.

import langroid.language_models as lm
# 配置要使用的模型，例如GPT-4o
# 或者使用本地模型 "ollama/mistral"
llm_config = lm.OpenAIGPTConfig(
chat_model=lm.OpenAIChatModel.GPT4o,
)
model = lm.OpenAIGPT(llm_config)
# 直接发送问题并获取回答
response = model.chat("中国的首都是哪里？", max_tokens=20)
print(response.message)

2. uso de inteligências para o diálogo

Corpo Inteligente (ChatAgent) A capacidade de manter o histórico do diálogo e permitir a comunicação contextualizada.

import langroid as lr
# 创建一个默认配置的聊天智能体
agent = lr.ChatAgent()
# 智能体能够记住之前的对话
agent.llm_response("中国的首都是哪里？")
response = agent.llm_response("那印度的呢？") # 智能体会理解“那”指代的是首都
print(response.content)

3. gerenciamento de inteligências por meio de tarefas

Task(Tarefas) fornecem uma estrutura operacional para que as inteligências definam suas funções e metas e gerenciem o ciclo de interação com os usuários.

import langroid as lr
# 1. 创建一个智能体
agent = lr.ChatAgent()
# 2. 为智能体创建一个任务，并赋予系统消息（角色设定）
task = lr.Task(
agent,
name="Bot",
system_message="你是一个乐于助人的助手。"
)
# 3. 运行任务，这将启动一个与用户的交互循环
task.run("你好") # 以用户的 "你好" 开始对话

4. inteligência múltipla trabalhando em conjunto

Esse é um dos recursos mais poderosos do Langroid. Você pode criar várias inteligências e organizá-las para resolver um problema mais complexo.

Por exemplo, criamos uma inteligência de "professor" e uma de "aluno" e permitimos que eles participem de uma sessão de perguntas e respostas.

import langroid as lr
# 通用的大模型配置
llm_config = lr.ChatAgentConfig(
llm=lr.language_models.OpenAIGPTConfig(
chat_model=lr.language_models.OpenAIChatModel.GPT4o,
),
)
# 创建老师智能体和任务
teacher_agent = lr.ChatAgent(llm_config)
teacher_task = lr.Task(
teacher_agent,
name="Teacher",
system_message="""
向你的学生提出简明的数学问题，并给予反馈。
请从一个问题开始。
"""
)
# 创建学生智能体和任务
student_agent = lr.ChatAgent(llm_config)
student_task = lr.Task(
student_agent,
name="Student",
system_message="简明地回答老师的问题。",
single_round=True, # 学生回答一轮后就等待
)
# 将学生任务设置为老师任务的子任务
teacher_task.add_sub_task(student_task)
# 运行主任务，整个对话将自动进行
teacher_task.run()

Neste exemplo, oteacher_taskfalará primeiro (fará a pergunta) e depois passará o controle para ostudent_taskO aluno responde e o controle é devolvido ao professor, e assim por diante.

5. conversando com documentos (RAG)

fazer uso deDocChatAgentVocê pode facilmente fazer perguntas a vários documentos.

import langroid as lr
from langroid.agent.special import DocChatAgent, DocChatAgentConfig
# 配置文档路径，可以是网址或本地文件
config = DocChatAgentConfig(
doc_paths=[
"https://arxiv.org/pdf/2308.08155.pdf", # 一篇关于语言模型的论文
"/path/to/your/notes.txt",
],
)
# 创建DocChatAgent，它会自动处理文档的加载、切分和索引
agent = DocChatAgent(config)
# 将智能体包装在任务中，并开始交互式聊天
task = lr.Task(agent, name="DocAssistant")
task.run("请总结一下这篇论文的核心思想。")

Por trás desse processo, o Langroid automatiza todo o processo de download de documentos, extração de texto, segmentação em partes, geração de embeddings vetoriais e armazenamento em um banco de dados vetorial. Quando você faz uma pergunta, ele primeiro recupera o fragmento de documento mais relevante do banco de dados e, em seguida, o entrega ao LLM junto com a sua pergunta para gerar uma resposta bem fundamentada.

cenário do aplicativo

1. Criação de assistentes de pesquisa automatizados
   É possível criar uma inteligência responsável por encontrar informações usando um mecanismo de busca, outra responsável por extrair as principais informações dos documentos baixados e uma terceira responsável por consolidar essas informações em um relatório.
2. Desenvolvimento de ferramentas interativas de análise de dados
   UtilizarTableChatAgentOs usuários podem consultar dados em arquivos CSV ou bancos de dados por meio de linguagem natural. Por exemplo, pode-se perguntar "Qual foi o produto mais vendido no último trimestre?". A inteligência gerará e executará automaticamente o código de consulta apropriado.
3. Criar sistemas de Q&A específicos do domínio
   aprovar (um projeto de lei ou inspeção etc.)DocChatAgentCarregue documentos em campos especializados (por exemplo, textos jurídicos, manuais médicos, documentos técnicos) e crie rapidamente um robô inteligente de perguntas e respostas que possa responder com precisão a perguntas profissionais.
4. Modelagem de sistemas e processos complexos
   Em pesquisas comerciais ou de ciências sociais, as inteligências que representam diferentes funções (por exemplo, consumidores, fornecedores, reguladores) podem ser configuradas para simular a dinâmica do mercado ou fenômenos sociais por meio de suas interações.
5. Geração e interpretação de códigos
   Uma inteligência pode ser projetada para ser exclusivamente responsável pela geração de código com base nos requisitos, enquanto outra é responsável por interpretar a lógica e o uso do código ou depurar o código se ele der errado.

QA

1. Qual é a diferença entre Langroid e LangChain?
   O Langroid é uma estrutura autônoma que não usa o LangChain. Sua filosofia de design se concentra mais na criação de aplicativos por meio da colaboração de várias inteligências, e suas principais abstrações sãoAgentresponder cantandoTaskEm contrapartida, a LangChain se concentra em uma estrutura de "cadeia" que conecta diferentes componentes (modelos, dicas, ferramentas). Em contrapartida, o LangChain se concentra em uma estrutura de "cadeia" que conecta diferentes componentes (modelos, dicas, ferramentas), e o Langroid acredita que as arquiteturas de inteligência múltipla são mais flexíveis e dimensionáveis ao lidar com tarefas complexas.
2. Posso usar big models de código aberto implantados localmente?
   Sim. O Langroid facilita a conexão com modelos de código aberto executados localmente, como Llama, Mistral etc., integrando-se a ferramentas como Ollama, LiteLLM e outras. Tudo o que você precisa fazer é definir o parâmetrochat_modelBasta apontar para o endereço de serviço de seu modelo local, por exemplo"ollama/mistral".
3. O que é uma ferramenta? Como ela funciona?
   Ferramentas são recursos que permitem que as inteligências executem códigos, chamem APIs etc. além dos recursos do próprio modelo de linguagem. No Langroid, você pode fazer isso definindo um objeto que herda do modeloToolMessageA estrutura usa o modelo Pydantic para criar uma ferramenta. Quando um corpo inteligente (o LLM) acha que precisa usar uma ferramenta, ele gera uma "mensagem" especialmente formatada, que é capturada pela estrutura, que chama sua função Python predefinida para executar a operação real e, em seguida, retorna o resultado para o corpo inteligente. Esse processo é muito intuitivo para os desenvolvedores.
4. Como as inteligências decidem entre si quem vai falar?
   compreendendoTaskA lógica de agendamento de uma tarefa é determinada. Na hierarquia, a tarefa principal é responsável por coordenar a ordem de execução de seus filhos. Por padrão, as tarefas são executadas sequencialmente (incluindo interações com o usuário). Os desenvolvedores também podem definir osingle_roundedone_ife outros parâmetros para controlar com precisão o fluxo de execução e as condições de encerramento da tarefa.
5. O Langroid oferece suporte à saída de streaming?
   Suporte Muitos dos métodos do Langroid têm versões assíncronas (async) e suporte para respostas de streaming, o que significa que você pode ver as respostas do modelo exibidas palavra por palavra, como faria na interface do ChatGPT, em vez de esperar que ele gere a resposta completa, o que é importante para melhorar a experiência do usuário.