Langroid: Einfaches Navigieren in großen Sprachmodellen mit Multi-Intelligent Body Programming

Langroid ist ein Python-Framework für Forscher und Entwickler, das die Erstellung von Anwendungen auf der Grundlage von Large Language Models (LLMs) vereinfachen soll. Es wurde von Forschern der Carnegie Mellon University und der University of Wisconsin-Madison entwickelt. Die Kernidee besteht darin, die Leistungsfähigkeit von LLMs durch multi-intelligente Körperprogrammierung nutzbar zu machen. In diesem Framework können Entwickler mehrere Agenten einrichten, sie mit großen Sprachmodellen, Vektordatenbanken und Werkzeugen ausstatten und ihnen dann Aufgaben zuweisen, damit diese Agenten bei der Lösung komplexer Probleme zusammenarbeiten können, indem sie Nachrichten austauschen.Langroid wurde entwickelt, um intuitiv, leichtgewichtig und skalierbar zu sein, und ist unabhängig von anderen LLM-Frameworks (z. B. LangChain) und kann mit praktisch jeder Art von groß angelegtem LLM arbeiten. Langroid ist unabhängig von anderen LLM-Frameworks (z.B. LangChain) und kann mit nahezu jeder Art von groß angelegtem Sprachmodell verwendet werden, wodurch Entwicklern eine flexible und leistungsstarke Entwicklungsumgebung zur Verfügung steht.

Funktionsliste

• Multi-Intelligenz-Zusammenarbeit. Unterstützt die Schaffung mehrerer Intelligenzen, die über Messaging zusammenarbeiten können, um gemeinsam an komplexen Aufgaben zu arbeiten.
• Arbeitsprogramm. passieren (eine Rechnung oder Inspektion etc.)TaskKlassen, um Intelligenzen zu bündeln, ihnen klare Anweisungen und Ziele zu geben und die Delegation von Aufgaben auf hierarchische, rekursive Weise zu ermöglichen.
• Umfassende LLM-Unterstützung. Zusätzlich zur Unterstützung der OpenAI-Modellfamilie werden Hunderte von LLMs anderer Anbieter durch Agentenbibliotheken und lokale Server (z. B. ollama, LiteLLM) unterstützt, darunter Open-Source-, lokal eingesetzte und kommerzielle Modelle.
• Werkzeuge/Funktionsaufrufe. unterstützt die Funktionsaufruf-Funktionalität von OpenAI und bietet eine eigeneToolMessageDer Mechanismus, der auf jeden LLM anwendbar ist, wird mit Hilfe von Pydantic definiert, was den Entwicklungsprozess vereinfacht und den Umgang mit fehlerhaft formatiertem JSON ermöglicht, das vom LLM generiert wird.
• Retrieval Augmentation Generation (RAG). eingebautDocChatAgentEs kann problemlos mit Dokumentensammlungen interagieren, einschließlich lokaler Dateien und URLs, und unterstützt das Chunking, die Einbettung, die Vektorspeicherung und den Abruf von Dokumenten.
• Unterstützung mehrerer Vektordatenbanken. Unterstützt Qdrant, Chroma, LanceDB, Pinecone, pgvector und viele andere Vektordatenbanken für effiziente RAG.
• Caching-Mechanismen. Unterstützt die Zwischenspeicherung von LLM-API-Antworten mit Redis oder Momento, um die Kosten und den Zeitaufwand für wiederholte Aufrufe zu reduzieren.
• Beobachtbarkeit und Protokollierung. Generieren Sie detaillierte Protokolle von Multi-Intelligence-Interaktionen und halten Sie die Quelle und den Verlauf von Nachrichten fest, damit die Entwickler sie nachverfolgen und debuggen können.

Hilfe verwenden

Langroid ist ein leistungsfähiges Python-Framework, mit dem Sie komplexe Anwendungen durch die Kombination verschiedener "Intelligenzen" erstellen können. Im Folgenden erklären wir im Detail, wie man Langroid installiert und verwendet, um einige grundlegende und fortgeschrittene Operationen durchzuführen.

Installation von Langroid

Langroid benötigt Python 3.11 oder höher. Es wird dringend empfohlen, es in einer virtuellen Umgebung zu installieren, um Abhängigkeitskonflikte mit anderen Projekten zu vermeiden.

1. Installation des Fundaments
   Die Installation des eigentlichen Kerns ist sehr einfach und erfordert nur einen Befehl:

   pip install langroid
   

   Diese Basisversion enthält die Kernfunktionen, die für die Verwendung von OpenAI-Modellen erforderlich sind.

2. Installation zusätzlicher Funktionen
   Langroid ist modular aufgebaut, und viele fortgeschrittene Funktionen erfordern zusätzliche Abhängigkeiten, die installiert werden müssen. Sie können diese nach Bedarf installieren:
   • Dokument-Chat-Funktion (RAG). Wenn Sie möchten, dass Intelligenzen PDFs, Word-Dokumente usw. lesen und verstehen können, müssen Sie dasdoc-chatZusatzpakete.

     pip install "langroid[doc-chat]"
     

   • Datenbank-Interaktionsfunktionen. Wenn Sie möchten, dass der Smart Body eine Verbindung zur Datenbank herstellt und diese abfragt, müssen Sie dasdbZusatzpakete.

     pip install "langroid[db]"
     

   • Sie können auch mehrere Add-on-Pakete gleichzeitig installieren:

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

   • Installation aller Funktionen. Wenn Sie alle optionalen Abhängigkeiten auf einmal installieren möchten, können Sie dieallTags, was jedoch die Installationszeit und -größe erheblich erhöhen kann.

     pip install "langroid[all]"
     

Umgebung Konfiguration

Sobald die Installation abgeschlossen ist, müssen Sie die erforderlichen Umgebungsvariablen konfigurieren, insbesondere Ihren Big Language Model API-Schlüssel.

1. einrichten..envPapiere
   Kopieren Sie in das Stammverzeichnis Ihres Projekts die Repository-Datei.env-templateDatei und benennen Sie sie um.env.

   cp .env-template .env
   

2. Konfigurieren des API-Schlüssels
   zeigen (eine Eintrittskarte).envDatei, geben Sie Ihren OpenAI API-Schlüssel ein. Dies ist die grundlegendste Voraussetzung, um Langroid zum Laufen zu bringen.

   OPENAI_API_KEY=your-key-here-without-quotes
   

Zentrale Konzepte und Maßnahmen

Das Herzstück von Langroid istAgent(Intelligenzen) undTask(Aufgaben). Intelligenzler sind Ausführende, und Aufgaben sind Anweisungen, wie Intelligenzler handeln sollen.

1. direkte Interaktion mit LLM

Sie können die Intelligenzen auslassen und direkt mit einem konfigurierten LLM sprechen. Dies ist nützlich, um Modellreaktionen schnell zu testen.

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. die Nutzung von Intelligenzen für den Dialog

Intelligenter Körper (ChatAgent) Die Fähigkeit, die Dialoghistorie aufrechtzuerhalten und eine kontextabhängige Kommunikation zu ermöglichen.

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

3. die Verwaltung von Intelligenzen durch Aufgaben

Task(Aufgaben) bieten einen operativen Rahmen für Intelligenzen, um ihre Rollen und Ziele zu definieren und den Zyklus der Interaktion mit den Nutzern zu verwalten.

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

4. die Zusammenarbeit von Multi-Intelligenz

Dies ist eine der leistungsfähigsten Funktionen von Langroid. Sie können mehrere Intelligenzen erstellen und sie organisieren, um ein komplexeres Problem zu lösen.

Wir erstellen zum Beispiel eine "Lehrer"- und eine "Schüler"-Intelligenz und lassen sie in einer Frage-und-Antwort-Runde zusammenarbeiten.

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

In diesem Beispiel ist dieteacher_taskspricht zuerst (stellt die Frage) und übergibt dann die Kontrolle an denstudent_taskDie Schülerin oder der Schüler antwortet, und die Kontrolle wird an die Lehrkraft zurückgegeben, usw.

5. das Chatten mit Dokumenten (RAG)

ausnutzenDocChatAgentSie können problemlos Fragen zu einer Reihe von Dokumenten stellen.

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("请总结一下这篇论文的核心思想。")

Hinter diesem Prozess steht Langroid, das den gesamten Prozess des Herunterladens von Dokumenten, der Textextraktion, der Segmentierung in Chunks, der Erzeugung von Vektoreinbettungen und der Speicherung in einer Vektordatenbank automatisiert. Wenn Sie eine Frage stellen, wird zunächst das relevanteste Dokumentfragment aus der Datenbank abgerufen und dann zusammen mit Ihrer Frage an LLM weitergegeben, um eine gut begründete Antwort zu generieren.

Anwendungsszenario

1. Aufbau automatischer Forschungsassistenten
   Es ist möglich, eine Intelligenz einzurichten, die für das Auffinden von Informationen über eine Suchmaschine zuständig ist, eine andere, die für die Extraktion von Schlüsselinformationen aus heruntergeladenen Dokumenten verantwortlich ist, und eine dritte, die für die Konsolidierung dieser Informationen in einem Bericht zuständig ist.
2. Entwicklung von interaktiven Datenanalysetools
   nutzen.TableChatAgentBenutzer können Daten in CSV-Dateien oder Datenbanken durch natürliche Sprache abfragen. Beispielsweise könnte man fragen: "Welches war das meistverkaufte Produkt im letzten Quartal?". Die Intelligenz wird automatisch den entsprechenden Abfragecode generieren und ausführen.
3. Erstellen von domänenspezifischen Q&A-Systemen
   passieren (eine Rechnung oder Inspektion etc.)DocChatAgentLaden Sie Dokumente aus Fachgebieten (z. B. Rechtstexte, medizinische Handbücher, technische Dokumente) und erstellen Sie schnell einen intelligenten Q&A-Roboter, der Fachfragen präzise beantworten kann.
4. Modellierung komplexer Systeme und Prozesse
   In der wirtschafts- oder sozialwissenschaftlichen Forschung können Intelligenzen, die verschiedene Rollen repräsentieren (z. B. Verbraucher, Lieferanten, Regulierungsbehörden), eingerichtet werden, um die Marktdynamik oder soziale Phänomene durch ihre Interaktionen zu simulieren.
5. Codegenerierung und -interpretation
   Eine Intelligenz kann so konzipiert sein, dass sie ausschließlich für die Generierung von Code auf der Grundlage von Anforderungen zuständig ist, während eine andere für die Interpretation der Logik und der Verwendung des Codes oder für die Fehlersuche im Falle von Fehlern verantwortlich ist.

QA

1. Was ist der Unterschied zwischen Langroid und LangChain?
   Langroid ist ein eigenständiges Framework, das keine LangChain verwendet. Seine Design-Philosophie konzentriert sich mehr auf die Entwicklung von Anwendungen durch Multi-Intelligenz-Zusammenarbeit, und seine Kernabstraktionen sindAgentim Gesang antwortenTaskIm Gegensatz dazu konzentriert sich LangChain auf eine "Ketten"-Struktur, die verschiedene Komponenten (Modelle, Hinweise, Werkzeuge) miteinander verbindet. Im Gegensatz dazu konzentriert sich LangChain auf eine "Ketten"-Struktur, die verschiedene Komponenten (Modelle, Hinweise, Werkzeuge) miteinander verbindet. Langroid ist der Ansicht, dass Multi-Intelligenz-Architekturen flexibler und skalierbarer sind, wenn es um komplexe Aufgaben geht.
2. Kann ich lokal bereitgestellte Open-Source-Großmodelle verwenden?
   Ja. Langroid macht es einfach, sich mit lokal laufenden Open-Source-Modellen wie Llama, Mistral usw. zu verbinden, indem es sich mit Tools wie Ollama, LiteLLM und anderen integriert. Alles, was Sie tun müssen, ist das Setzen derchat_modelZeigen Sie einfach auf Ihre lokale Modelldienstadresse, z. B."ollama/mistral".
3. Was ist ein Tool? Wie funktioniert es?
   Werkzeuge sind Funktionen, die es Intelligenzen ermöglichen, Code auszuführen, APIs aufzurufen usw., die über die Möglichkeiten des Sprachmodells selbst hinausgehen. In Langroid können Sie dies tun, indem Sie ein Objekt definieren, das von derToolMessageDer Rahmen verwendet das pydantische Modell zur Erstellung eines Werkzeugs. Wenn ein intelligentes Organ (das LLM) glaubt, ein Werkzeug verwenden zu müssen, erzeugt es eine speziell formatierte "Nachricht", die vom Rahmenwerk erfasst wird, das Ihre vordefinierte Python-Funktion aufruft, um die eigentliche Operation durchzuführen, und dann das Ergebnis an das intelligente Organ zurückgibt. Dieser Prozess ist für Entwickler sehr intuitiv.
4. Wie entscheiden die Intelligenzen untereinander, wer sprechen wird?
   bestehend ausTaskDie Planungslogik einer Aufgabe wird festgelegt. In der Hierarchie ist die übergeordnete Aufgabe für die Koordinierung der Ausführungsreihenfolge ihrer Kinder verantwortlich. Standardmäßig werden die Aufgaben der Reihe nach ausgeführt (einschließlich der Interaktionen mit dem Benutzer). Entwickler können auch diesingle_roundunddone_ifund andere Parameter, um den Ausführungsablauf und die Abbruchbedingungen der Aufgabe genau zu steuern.
5. Unterstützt Langroid Streaming-Ausgaben?
   Viele der Methoden in Langroid haben asynchrone (async) Versionen und Unterstützung für Streaming-Antworten, was bedeutet, dass Sie die Antworten des Modells Wort für Wort sehen können, wie Sie es in der ChatGPT-Schnittstelle tun würden, anstatt darauf zu warten, dass die gesamte Antwort generiert wird, was für die Verbesserung der Benutzererfahrung wichtig ist.