Die Einführung von KI-Agenten (opens new window) hat verschiedene Branchen umgestaltet und bietet beispiellose Effizienz- und Produktivitätssteigerungen. Studien zeigen, dass über 60% (opens new window) der Unternehmensinhaber eine gesteigerte Produktivität durch die Implementierung von KI erwarten. Insbesondere glauben 64% (opens new window), dass KI die allgemeine Geschäftsproduktivität verbessern wird, während 42% eine optimierte Arbeitsabläufe erwarten. Diese Statistiken verdeutlichen die transformative Wirkung von KI-Agenten bei der Optimierung von Arbeitsabläufen und der Förderung des Wachstums in verschiedenen Branchen.
Im täglichen Leben begegnen wir KI-Agenten öfter, als wir realisieren - von virtuellen Assistenten (opens new window) wie Siri und Alexa bis hin zu personalisierten Empfehlungssystemen (opens new window) auf Streaming-Plattformen. Diese Agenten spielen eine entscheidende Rolle bei der Verbesserung der Benutzererfahrung, der Bereitstellung maßgeschneiderter Lösungen und der nahtlosen Automatisierung von Routineaufgaben.
Im Bereich der KI-Entwicklung zeichnet sich LangChain (opens new window) als revolutionäres modulares Framework aus, das die Erstellung von sprachgesteuerten KI-Anwendungen vereinfacht. Dieses innovative Tool bietet eine standardisierte Schnittstelle (opens new window) für die Interaktion mit Sprachmodellen und eine nahtlose Integration mit externen Datenquellen. LangChain abstrahiert die Komplexität, die normalerweise mit der Arbeit an Large Language Models (LLMs) (opens new window) verbunden ist, und ist daher auch für Personen ohne umfangreiche Kenntnisse in maschinellem Lernen oder KI zugänglich.
# Was ist eine Kette in LangChain?
LangChain wurde ursprünglich entwickelt, um eine nahtlose Schnittstelle für die Integration von LLMs mit externen Datenquellen bereitzustellen. Es zielt darauf ab, die Lücke zwischen den Fähigkeiten leistungsstarker KI-Modelle und den großen Datenmengen, die sie nutzen können, zu überbrücken. Dieses Framework ermöglicht es Entwicklern, fortschrittliche Anwendungen zu erstellen, die die Leistung von LLMs nutzen, um Daten aus verschiedenen Quellen abzurufen und zu verarbeiten.
Die Struktur von LangChain basiert hauptsächlich auf dem Konzept von "Ketten". Diese Ketten repräsentieren Sequenzen von Operationen, die Eingaben in gewünschte Ausgaben umwandeln. Die Eleganz von LangChain liegt in seiner Modularität und Flexibilität, die es Entwicklern ermöglicht, maßgeschneiderte Workflows an ihre spezifischen Anforderungen anzupassen.
In LangChain ist eine Kette eine Sequenz von Schritten oder Operationen, die Eingabedaten verarbeiten, um eine Ausgabe zu erzeugen. Jeder Schritt in der Kette erfüllt eine bestimmte Funktion, wie z.B. Datenabruf, Transformation oder Interaktion mit einem LLM. Ketten können einfach sein und nur wenige Schritte umfassen, oder komplex sein und mehrere Stufen der Datenverarbeitung und Modellinteraktionen umfassen.
Beispielsweise könnte eine Kette damit beginnen, Daten aus einer API abzurufen, diese Daten durch eine Reihe von Transformationen zu leiten und sie schließlich in ein LLM einzuspeisen, um eine Antwort zu generieren. Dieser modulare Ansatz erleichtert das Design, die Testung und die Wiederverwendung einzelner Komponenten eines Workflows.
Ketten haben jedoch ihre Grenzen. Sie sind linear und können manchmal Schwierigkeiten mit dynamischeren oder anpassungsfähigen Aufgaben haben. Hier kommen LangChain-Agenten ins Spiel, die die Grenzen von Ketten durch mehr Flexibilität und Intelligenz überwinden.
# Was sind LangChain-Agenten?
LangChain-Agenten sind leistungsstarke Komponenten, die die Fähigkeiten von LLMs verbessern, indem sie ihnen ermöglichen, Entscheidungen zu treffen und Aktionen basierend auf diesen Entscheidungen durchzuführen. Im Gegensatz zu Ketten, die einer vordefinierten Sequenz von Aktionen folgen, verwenden Agenten LLMs als Schlussfolgerungsmaschinen, um die Sequenz von Aktionen dynamisch zu bestimmen.
Die Kernfunktionalität von LangChain-Agenten besteht darin, Aktionen basierend auf Eingabedaten und den Ergebnissen vorheriger Aktionen auszuwählen und auszuführen. Dadurch sind sie äußerst anpassungsfähig und in der Lage, komplexe Aufgaben mit minimalem menschlichen Eingriff zu bewältigen. Zum Beispiel kann ein Agent mit verschiedenen Tools und Datenquellen interagieren, Informationen verarbeiten und seine Aktionen iterativ verfeinern, um ein bestimmtes Ziel zu erreichen.
In Ketten ist eine Sequenz von Aktionen fest codiert, während in Agenten die Sequenz von Aktionen nicht vorherbestimmt ist und ein Sprachmodell als Schlussfolgerungsmaschine verwendet wird, um zu bestimmen, welche Aktionen in welcher Reihenfolge durchgeführt werden sollen.
Agenten haben mehrere wichtige Eigenschaften:
- Anpassungsfähigkeit: Agenten können ihre Aktionen basierend auf den Daten und dem Kontext anpassen, mit denen sie konfrontiert werden. Dies bedeutet, dass sie nicht an eine vordefinierte Sequenz von Schritten wie Ketten gebunden sind.
- Autonomie: Agenten können eigenständig arbeiten und Entscheidungen treffen, ohne ständige Überwachung zu benötigen.
- Interaktivität: Agenten können mit mehreren Datenquellen, Tools und LLMs interagieren und sind daher vielseitig einsetzbar.
Durch die Integration von Agenten kann Ihr System anspruchsvollere Workflows verwalten, die dynamische Antworten und anpassungsfähiges Verhalten erfordern und die Starrheit einfacher Ketten überwinden.
# Welche Hauptkomponenten hat ein Agent?
Um einen effektiven Agenten in LangChain zu erstellen, sind mehrere wichtige Komponenten erforderlich:
# Tools
Tools sind die Bausteine, die ein Agent verwendet, um Aufgaben auszuführen, einschließlich der Interaktion mit APIs, Datenbanken und Datenverarbeitungsfunktionen. Jedes Tool bietet spezifische Funktionen, die der Agent nutzen kann, um verschiedene Aufgaben zu erledigen.
LangChain bietet verschiedene Möglichkeiten, verschiedene Tools zu nutzen, einschließlich vordefinierter Tools, Retriever (opens new window) als Tools und benutzerdefinierte Tools (opens new window). Schauen wir uns diese im Detail an:
# Vordefinierte Tools
LangChain bietet eine Sammlung von vordefinierten Tools (opens new window), die Sie durch Importieren und Integration in Ihre Agenten sofort verwenden können. Zum Beispiel:
from langchain_community.tools import DuckDuckGoSearchRun
search = DuckDuckGoSearchRun()
In diesem Beispiel importieren wir das Tool DuckDuckGoSearchRun aus dem Modul langchain_community.tools und initialisieren es. Nach der Initialisierung kann dieses Tool innerhalb eines Agenten über ein Toolkit (opens new window) verwendet werden, wie wir später sehen werden.
# Verwendung von Retrievers als Tools
In Szenarien, in denen Sie Daten aus einer Vektordatenbank (opens new window) basierend auf Benutzerabfragen abrufen müssen, ermöglicht es Ihnen LangChain, Datenretriever in Tools umzuwandeln und sie in Ihren Agenten zu verwenden. So können Sie es tun:
from langchain.tools.retriever import create_retriever_tool
retriever_tool = create_retriever_tool(
retriever,
"name_des_tools",
"Beschreibung des Tools",
)
Mit der Methode create_retriever_tool von LangChain können Sie jeden Retriever in ein LangChain-Tool umwandeln. Diese Methode nimmt drei Argumente entgegen: den Retriever, den Sie zuvor erstellt haben, den Namen des Tools und eine Beschreibung des Tools. Die Beschreibung hilft dem LLM zu entscheiden, wann dieses Tool verwendet werden soll und welche Art von Daten es enthält.
# Benutzerdefinierte Tools
LangChain ermöglicht es Entwicklern auch, benutzerdefinierte Tools zu definieren, die auf ihre Anwendungen oder Anwendungsfälle zugeschnitten sind. Der einfachste Weg, ein benutzerdefiniertes Tool zu definieren, besteht darin, den @tool-Dekorator mit einer beliebigen Python-Methode zu verwenden. Hier ist ein Beispiel:
from langchain.agents import tool
@tool
def get_word_length(word: str) -> int:
"""Gibt die Länge eines Wortes zurück."""
return len(word)
get_word_length.invoke("abc")
In diesem Beispiel wird der Methodenname als Toolname verwendet und der Docstring dient als Beschreibung des Tools. Diese Konfiguration ermöglicht es dem Agenten, das Tool effektiv zu verstehen und zu nutzen.
Für komplexere Tools können Sie die von LangChain bereitgestellte BaseTool-Klasse erweitern, um anspruchsvolle benutzerdefinierte Tools zu erstellen, die spezifische Anforderungen erfüllen.
# Toolkit
Ein Toolkit ist eine Sammlung von Tools, auf die ein Agent zugreifen kann. Es definiert den Umfang der Aktionen, die der Agent ausführen kann, und die Ressourcen, die er nutzen kann. Es handelt sich um eine Liste von Tools, die Sie definiert haben und die im Agenten verwendet werden sollen, wie zum Beispiel:
tool_kit=[retriever_tool,get_word_length]
Alle Tools im Toolkit funktionieren auf die gleiche Weise, unabhängig davon, wie sie definiert sind.
# LLM (Large Language Model)
Das LLM ist der Kern der Intelligenz des Agenten. Es verarbeitet natürliche Spracheingaben, generiert Antworten und treibt den Entscheidungsprozess voran. LangChain integriert sich nahtlos mit verschiedenen modernen LLMs wie GPT-4 (opens new window), BERT (opens new window) und T5 (opens new window), um sicherzustellen, dass Agenten Zugriff auf modernste KI-Fähigkeiten haben.
Diese Integration verbessert das Verständnis natürlicher Sprache, ermöglicht anspruchsvolle Entscheidungsfindung und unterstützt die Anpassung an spezifische Domänen. Dadurch werden LangChain-Agenten vielseitig und leistungsstark bei der Durchführung komplexer Aufgaben.
# Prompt
Der Prompt ist die anfängliche Anweisung oder Abfrage, die das Verhalten des LLMs steuert. Eine klare und effektive Formulierung des Prompts ist entscheidend, um sicherzustellen, dass der Agent Aufgaben genau und effizient erledigt.
LangChain Hub
LangChain Hub ist ein zentrales Repository zum Finden, Teilen und Verwalten von Prompts, Ketten, Agenten und mehr. Es hilft Entwicklern und Teams dabei, hochwertige Prompts zu nutzen und ihre Entwicklungsprozesse zu beschleunigen.
Verwendung von LangChain Hub
Mit LangChain Hub (opens new window) können Sie problemlos einen öffentlichen Prompt in Ihren Codebase einbinden und so gut ausgearbeitete Prompts nutzen, die auf Ihren spezifischen Anwendungsfall und das von Ihnen verwendete Sprachmodell zugeschnitten sind. So können Sie beispielsweise einen vorgeschriebenen Prompt importieren:
from langchain import hub
prompt = hub.pull("hwchase17/openai-functions-agent")
Der Code hub.pull("hwchase17/openai-functions-agent") wird verwendet, um einen vordefinierten Prompt aus dem LangChain Hub abzurufen, der speziell für die Verwendung mit OpenAI-Funktionen (opens new window) entwickelt wurde. Dieser spezielle Prompt ist Teil einer Sammlung, die darauf abzielt, die Funktionalität von Agenten mit den leistungsstarken Sprachmodellen von OpenAI zu verbessern.
# Agent Executor
Der Agent Executor (opens new window) ist ein entscheidendes Element im LangChain-Ökosystem. Er orchestriert die Aktivitäten des Agenten, verwaltet den Ablauf der Operationen und stellt sicher, dass jede Komponente harmonisch funktioniert.
Aus der Dokumentation von LangChain sieht der Workflow des Agent Executors ungefähr so aus:
next_action = agent.get_action(...)
while next_action != AgentFinish:
observation = run(next_action)
next_action = agent.get_action(..., next_action, observation)
return next_action
Es handelt sich also im Wesentlichen um eine while-Schleife, die die nächsten Aktionen des Agenten aufruft, bis der Agent seine endgültige Antwort zurückgegeben hat. Der Executor ist für folgende Aufgaben verantwortlich:
- Initiierung von Aufgaben: Er startet die Aktivitäten des Agenten basierend auf dem gegebenen Prompt und Kontext.
- Verwaltung des Workflows: Er koordiniert die Interaktion zwischen Tools, dem Toolkit und dem LLM und stellt so einen reibungslosen Ablauf des Workflows sicher.
- Behandlung von Fehlern: Er verwaltet etwaige Fehler oder Ausnahmen (opens new window), die während der Operationen des Agenten auftreten, und sorgt so für eine robuste und zuverlässige Leistung.
Jede dieser Komponenten spielt eine wichtige Rolle für die Funktionalität eines Agenten. LangChain behandelt diese Komponenten mit großer Flexibilität, sodass Entwickler jeden Teil an ihre Bedürfnisse anpassen und optimieren können.
# Erstellen eines Agenten mit MyScaleDB und LangChain
Bis jetzt haben wir die wichtigen Komponenten kennengelernt, die zum Erstellen eines Agenten benötigt werden. Jetzt erstellen wir einen Agenten mit MyScaleDB (opens new window) und DuckDuckGo (opens new window). Dieser Agent wird zwei Tools haben:
- Retriever: Dieses Tool ruft Informationen zur MyScaleDB-Telemetrie (opens new window) ab.
- DuckDuckGo-Tool: Dieses Tool ruft Daten aus dem Internet ab.
# Einrichten der Umgebung
Bevor wir mit dem Erstellen des Agenten beginnen, installieren wir die erforderlichen Tools und Technologien. Öffnen Sie Ihr Terminal und geben Sie den folgenden Befehl ein:
pip install langchain langchain_openai duckduckgo-search
Dies installiert alle erforderlichen Pakete für den Aufbau dieses Agenten.
# Laden der Daten für das Retriever-Tool
Lassen Sie uns zunächst die Daten für das Retriever-Tool mit dem WebBaseLoader von LangChain laden:
from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
# Laden der Daten aus dem Internet
loader = WebBaseLoader("https://myscale.com/blog/myscale-telemetry-llm-app-observability/")
docs = loader.load()
# Aufteilen des Textes in kleinere Abschnitte
documents = RecursiveCharacterTextSplitter(
chunk_size=1000, chunk_overlap=200
).split_documents(docs)
# Einrichten der MyScaleDB-Anmeldeinformationen
Bevor wir den Retriever initialisieren, müssen wir die Anmeldeinformationen für die Vektordatenbank festlegen. Wir verwenden MyScale, und Sie können mehr darüber im Schnellstartleitfaden (opens new window) lesen. Legen Sie die Anmeldeinformationen wie folgt fest:
import os
# Anmeldeinformationen für MyScaleDB
os.environ["MYSCALE_HOST"] = "Ihr-Hostname-hier"
os.environ["MYSCALE_PORT"] = "443"
os.environ["MYSCALE_USERNAME"] = "Ihr-Benutzername-hier"
os.environ["MYSCALE_PASSWORD"] = "Ihr-Passwort-hier"
# Setzen Sie den OpenAI-API-Schlüssel für das OpenAI-LLM
os.environ["OPENAI_API_KEY"] = "API-Schlüssel-hier"
Für dieses Projekt verwenden wir OpenAI-Embeddings (opens new window) und ChatGPT, für die die Einrichtung des OpenAI-API-Schlüssels (opens new window) erforderlich ist.
# Initialisieren des Retrievers
Lassen Sie uns den Retriever initialisieren und die Daten in den MyScaleDB-Retriever (opens new window) einfügen.
from langchain_community.vectorstores import MyScale
from langchain_openai import OpenAIEmbeddings
vector = MyScale.from_documents(documents, OpenAIEmbeddings())
retriever = vector.as_retriever()
Sobald der Retriever bereit ist, ist der nächste Schritt, den Retriever in ein LangChain-Tool umzuwandeln. Hierfür verwenden wir die Methode create_retriever_tool:
from langchain.tools.retriever import create_retriever_tool
retriever_tool = create_retriever_tool(
retriever,
"MyScale_Telemetrie",
"Suchen Sie nach Informationen zur MyScale-Telemetrie. Für Fragen zur Telemetrie müssen Sie dieses Tool verwenden!",
)
Das definierte Tool wird immer dann verwendet, wenn eine Benutzerabfrage Informationen zur MyScale-Telemetrie anfordert. Wie bereits erwähnt, ist die Beschreibung des Tools sehr wichtig, da sie dem LLM dabei hilft, das geeignete Tool basierend auf der Abfrage auszuwählen.
# Definieren des Suchtools
Lassen Sie uns das zweite Tool für unseren Agenten definieren. Dies ist ein vordefiniertes Tool, das entwickelt wurde, um nach aktuellen Ereignissen zu suchen oder die neuesten Informationen aus dem Internet abzurufen.
from langchain_community.tools import DuckDuckGoSearchRun
search = DuckDuckGoSearchRun()
# Erstellen des Toolkits
Unser Agent wird zwei Tools verwenden: den Retriever und die Websuche. Erstellen wir das Toolkit:
tools = [search, retriever_tool]
# Initialisieren des LLM
Wir verwenden das GPT-3.5-Turbo-Modell von OpenAI für den Agenten:
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
# Abrufen des Prompts
Wir verwenden denselben vordefinierten Prompt aus dem LangChain Hub, da wir das OpenAI-Modell für unseren Agenten verwenden.
from langchain import hub
# Abrufen der Prompt-Vorlage
prompt = hub.pull("hwchase17/openai-functions-agent")
prompt.messages
# Erstellen des Agenten und des Agent Executors
LangChain bietet verschiedene Arten von Agenten (opens new window), von denen jeder einzigartige Schlussfolgerungsfähigkeiten und Funktionalitäten bietet. Für dieses Projekt verwenden wir den fortschrittlichsten und robustesten verfügbaren Agenten: den OpenAI-Tools-Agenten (opens new window). Wie in der offiziellen Dokumentation hervorgehoben, verwendet dieser Agent die neuesten Modelle von OpenAI und bietet eine verbesserte Leistung und eine breite Palette von Funktionen.
from langchain.agents import create_tool_calling_agent
agent = create_tool_calling_agent(llm, tools, prompt)
Nun übergeben wir den Agenten an den AgentExecutor, der alle Funktionen des definierten Agenten verwaltet.
from langchain.agents import AgentExecutor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
Das Setzen von verbose=True in der AgentExecutor ermöglicht eine detaillierte Protokollierung der Operationen des Agenten. Dies bietet eine größere Transparenz und Einblicke in den Entscheidungsprozess des Agenten, was für die Fehlersuche und das Verständnis der Interaktion des Agenten mit verschiedenen Tools nützlich ist.
# Hinzufügen von Memory zum Agenten
Wir fügen dem Agenten Memory hinzu, um den Kontext aus vorherigen Interaktionen beizubehalten, was seine Fähigkeit verbessert, relevante und kohärente Antworten in laufenden Gesprächen zu liefern. Memory ermöglicht es dem Agenten auch, im Laufe der Zeit zu lernen und sich anzupassen, was seine Leistung verbessert und Interaktionen persönlicher und intelligenter macht.
from langchain.memory import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
memory = ChatMessageHistory(session_id="test-session")
agent_with_chat_history = RunnableWithMessageHistory(
agent_executor,
lambda session_id: memory,
input_messages_key="input",
history_messages_key="chat_history",
)
Die Verwendung einer Session-ID hilft dabei, einzelne Benutzersitzungen zu verwalten und zu organisieren, um sicherzustellen, dass der Agent Interaktionen spezifisch für jede Sitzung genau verfolgen und abrufen kann.
# Aufrufen des Agenten
Schließlich können wir den Agenten aufrufen, um Informationen abzurufen. Wenn wir diese Abfrage stellen:
# Abrufen von Informationen zur MyScale-Telemetrie
agent_executor.invoke({"input": "Was ist MyScale-Telemetrie?"}, config={"configurable": {"session_id": "<foo>"}})
werden die Ergebnisse ähnlich aussehen wie folgt:
Wie Sie sehen können, bezog sich die Abfrage auf die MyScale-Telemetrie und der Agent ruft den MyScale_Telemetrie-Agenten dafür auf.
Stellen wir eine weitere Abfrage und rufen die neuesten Daten aus dem Internet ab.
# Abrufen von Informationen aus dem Web
agent_executor.invoke({"input": "Wie ist das Wetter in Kalifornien?"}, config={"configurable": {"session_id": "<foo>"}})
Die Ergebnisse werden ähnlich aussehen wie folgt:
Dieses praktische Beispiel zeigt, wie Sie mit MyScaleDB und DuckDuckGo-Tools einen LangChain-Agenten erstellen können. Jede Komponente ist für die Funktionalität des Agenten wesentlich, und eine korrekte Einrichtung der Umgebung gewährleistet einen reibungslosen Betrieb.
# Fazit
LangChain-Agenten sind fortschrittliche Komponenten, die die Fähigkeiten von LLMs verbessern. Sie ermöglichen dies, indem sie LLMs Entscheidungen treffen und Aktionen basierend auf diesen Entscheidungen durchführen lassen. Im Gegensatz zu herkömmlichen Ketten, die einer festgelegten Sequenz folgen, verwenden Agenten LLMs, um die Sequenz von Aktionen dynamisch zu bestimmen. Diese Flexibilität ermöglicht es Agenten, komplexe und sich ändernde Aufgaben effizienter zu bewältigen. LangChain-Agenten sind äußerst modular, was es einfach macht, verschiedene Tools und benutzerdefinierte Funktionen zu integrieren und so Workflows zu erstellen, die auf spezifische Anforderungen zugeschnitten sind.
MyScaleDB (opens new window) ist eine erstklassige Wahl unter den Vektordatenbanken und bekannt für seine hervorragende Leistung und Skalierbarkeit. Sein MSTG (Multi-Stage Tree Graph) Algorithmus (opens new window) übertrifft andere durch schnellere und genauere Datenabfrage, was für KI-gesteuerte Aufgaben entscheidend ist. MyScaleDB ist darauf ausgelegt, große Datenmengen effizient zu verarbeiten und stellt so zuverlässige und schnelle Operationen sicher. Dies macht es zu einem unverzichtbaren Werkzeug für Entwickler, die robuste KI-Anwendungen erstellen möchten, die eine effiziente Datenverwaltung und -abfrage im großen Maßstab erfordern.
