Wie man LangChain Agents für leistungsstarke automatisierte Aufgaben verwendet
- Name
- Lynn Mikami
Published on
In der faszinierenden Welt der Sprachmodelle und der Automatisierung zeichnen sich LangChain Agents als Innovationsquelle aus, die es Entwicklern und Technikbegeisterten ermöglicht, anspruchsvolle, automatisierte Aufgaben zu erstellen, die direkt aus einem Science-Fiction-Roman zu stammen scheinen. Wenn Sie in die Welt der LangChain Agents eintauchen möchten, aber nicht wissen, wo Sie anfangen sollen, sind Sie hier genau richtig. Dieser Leitfaden wird den Prozess entmystifizieren, ihn zugänglich und unkompliziert machen. Also schnappen Sie sich eine Tasse Kaffee und begeben Sie sich mit uns auf diese aufregende Reise.
Wie man LangChain Agents verwendet: Schnellstart
Um das Agentenframework am besten zu verstehen, erstellen wir einen Agenten mit zwei Werkzeugen: einem zum Nachschlagen von Informationen online und einem zum Nachschlagen bestimmter Daten, die wir in einen Index geladen haben.
Dies setzt Kenntnisse über LLMs und Retrieval voraus. Wenn Sie diese Abschnitte noch nicht erkundet haben, wird empfohlen, dies zu tun.
Setup: LangSmith
Per Definition führen Agenten eine selbstbestimmte, eingabeabhängige Sequenz von Schritten aus, bevor sie eine ausgabeorientierte Ausgabe zurückgeben. Dies macht das Debuggen dieser Systeme besonders schwierig und die Beobachtung besonders wichtig. LangSmith ist besonders nützlich für solche Fälle.
Bei der Entwicklung mit LangChain werden alle Schritte automatisch in LangSmith verfolgt. Um LangSmith einzurichten, müssen wir lediglich die folgenden Umgebungsvariablen festlegen:
export LANGCHAIN_TRACING_V2="true"
export LANGCHAIN_API_KEY="<your-api-key>"Werkzeuge definieren
Zunächst müssen wir die Werkzeuge erstellen, die wir verwenden möchten. Wir werden zwei Werkzeuge verwenden: Tavily (um online nachzuschlagen) und dann ein Retrievaltool über einen lokalen Index, den wir erstellen werden.
- Tavily
In LangChain haben wir ein integriertes Tool, um die Tavily-Suchmaschine einfach als Werkzeug zu verwenden. Beachten Sie jedoch, dass hierfür ein API-Schlüssel erforderlich ist - es gibt eine kostenlose Stufe, aber wenn Sie keinen haben oder keinen erstellen möchten, können Sie diesen Schritt einfach ignorieren.
Sobald Sie Ihren API-Schlüssel erstellt haben, müssen Sie ihn wie folgt exportieren:
export TAVILY_API_KEY="..."from langchain_community.tools.tavily_search import TavilySearchResults
search = TavilySearchResults()
search.invoke("Wie ist das Wetter in SF?")- Retrievaltool
Wir erstellen auch ein Retrievaltool über einige eigene Daten. Für eine tiefere Erklärung jeder einzelnen Schritte hier, siehe diesen Abschnitt.
from langchain_community.document_loaders import WebBaseLoader
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
loader = WebBaseLoader("https://docs.smith.langchain.com/overview")
docs = loader.load()
documents = RecursiveCharacterTextSplitter(
chunk_size=1000, chunk_overlap=200
).split_documents(docs)
vector = FAISS.from_documents(documents, OpenAIEmbeddings())
retriever = vector.as_retriever()
retriever.get_relevant_documents("Wie lade ich einen Datensatz hoch?")[0]Nun, da wir unseren Index, über den wir das Retrieval durchführen werden, gefüllt haben, können wir ihn problemlos in ein Werkzeug umwandeln (das Format, das ein Agent benötigt, um es ordnungsgemäß zu verwenden).
from langchain.tools.retriever import create_retriever_tool
retriever_tool = create_retriever_tool(
retriever,
"langsmith_search",
"Suchen Sie nach Informationen über LangSmith. Bei Fragen zu LangSmith müssen Sie dieses Werkzeug verwenden!"
)Werkzeuge
Jetzt, da wir beide erstellt haben, können wir eine Liste der Werkzeuge erstellen, die wir downstream verwenden werden.
tools = [search, retriever_tool]Wie man einen LangChain Agenten erstellt
Nachdem wir die Werkzeuge definiert haben, können wir den Agenten erstellen. Wir verwenden einen OpenAI Functions-Agenten - weitere Informationen zu diesem Agententyp sowie zu anderen Optionen finden Sie in diesem Leitfaden.
Zuerst wählen wir das LLM aus, das den Agenten steuern soll.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)Als nächstes wählen wir den Prompt aus, den wir verwenden möchten, um den Agenten zu steuern.
from langchain import hub
# Holen Sie sich den zu verwendenden Prompt - Sie können dies anpassen!
prompt = hub.pull("hwchase17/openai-functions-agent")
prompt.messagesNun können wir den Agenten mit dem LLM, dem Prompt und den Werkzeugen initialisieren. Der Agent ist dafür verantwortlich, die Eingabe entgegenzunehmen und zu entscheiden, welche Aktionen durchgeführt werden sollen. Wesentlich ist, dass der Agent diese Aktionen nicht ausführt - das erledigt der AgentExecutor (nächster Schritt). Weitere Informationen dazu, wie man über diese Komponenten nachdenkt, finden Sie in unserer konzeptionellen Anleitung.
from langchain.agents import create_openai_functions_agent
agent = create_openai_functions_agent(llm, tools, prompt)Zu guter Letzt kombinieren wir den Agenten (die Intelligenz) mit den Werkzeugen im AgentExecutor (der den Agenten wiederholt aufrufen und Werkzeuge ausführen wird). Weitere Informationen dazu, wie man über diese Komponenten nachdenkt, finden Sie in unserer konzeptionellen Anleitung.
from langchain.agents import AgentExecutor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)Führen Sie den Agenten aus
Nun können wir den Agenten auf ein paar Abfragen ausführen! Beachten Sie jedoch, dass es sich vorerst um speicherlose Abfragen handelt (er erinnert sich nicht an vorherige Interaktionen).
agent_executor.invoke({"input": "Hallo!"})agent_executor.invoke({"input": "Wie kann LangSmith Ihnen beim Testen helfen?"})agent_executor.invoke({"input": "Wie ist das Wetter in SF?"})Hinzufügen von Memory
Wie zuvor erwähnt, ist dieser Agent zustandslos. Das bedeutet, er erinnert sich nicht an vorherige Interaktionen. Um ihm Gedächtnis zu geben, müssen wir zuvor chat_history übergeben. Hinweis: Es muss chat_history genannt werden, aufgrund des verwendeten Prompts. Wenn wir ein anderes Prompt verwenden würden, könnten wir den Variablennamen ändern.
# Hier übergeben wir eine leere Liste von Nachrichten für `chat_history`, da dies die erste Nachricht im Chat ist
agent_executor.invoke({"input": "Hallo! Mein Name ist Bob", "chat_history": []})from langchain_core.messages import AIMessage, HumanMessage
agent_executor.invoke(
{
"chat_history": [
HumanMessage(content="Hallo! Mein Name ist Bob"),
AIMessage(content="Hallo Bob! Wie kann ich Ihnen heute helfen?"),
],
"input": "Wie lautet mein Name?",
}
)Wenn wir diese Nachrichten automatisch verfolgen möchten, können wir sie in ein RunnableWithMessageHistory einbinden. Weitere Informationen zur Verwendung finden Sie in diesem Leitfaden.
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
message_history = ChatMessageHistory()
agent_with_chat_history = RunnableWithMessageHistory(
agent_executor,
# Dies wird benötigt, weil in den meisten Szenarien eine Sitzungs-ID erforderlich ist
# Sie wird hier nicht wirklich verwendet, da wir eine einfache in-Memory-ChatMessageHistory verwenden
lambda session_id: message_history,
input_messages_key="input",
history_messages_key="chat_history",
)
agent_with_chat_history.invoke(
{"input": "Hallo! Ich bin Bob"},
# Dies wird benötigt, weil in den meisten Szenarien eine Sitzungs-ID erforderlich ist
# Sie wird hier nicht wirklich verwendet, da wir eine einfache in-Memory-ChatMessageHistory verwenden
config={"configurable": {"session_id": "<foo>"}},
)Arten von LangChain Agents
Agent-Typen
Im Bereich der LangChain Agents steht Vielfalt im Vordergrund. Diese Agents gibt es in verschiedenen Varianten, die jeweils für unterschiedliche Aufgaben und Fähigkeiten geeignet sind. Lassen Sie uns die nuancierte Welt der Agent-Typen erkunden, indem wir ihre Modelltypen, Unterstützung für Chat-History, Multi-Input-Tools, parallele Funktionen und erforderliche Modellparameter betrachten. Das Verständnis dieser Kategorien wird Ihnen helfen, den perfekten Agenten für Ihre Bedürfnisse auszuwählen.
-
OpenAI Tools: Ein hochmoderner Agent, der für aktuelle OpenAI-Modelle optimiert ist (1106 und höher). Er ist darauf ausgelegt, Chat-Interaktionen zu handhaben, Multi-Input-Tools zu unterstützen und parallele Funktionsaufrufe auszuführen. Hierfür sind die Modellparameter "tools" erforderlich. Ideal für diejenigen, die die neuesten Angebote von OpenAI nutzen.
-
OpenAI Functions: Speziell für OpenAI- oder feinabgestimmte Open-Source-Modelle entwickelt, die OpenAIs Funktionen nachahmen können. Er zeichnet sich durch seine Fähigkeit in Chat-Umgebungen aus, unterstützt Multi-Input-Tools und erfordert die Modellparameter "functions". Eine solide Wahl für Modelle, die gut darin sind, Funktionen aufzurufen.
-
XML: Dieser Agent ist für Modelle geeignet, die sich mit XML auskennen, z.B. von Anthropic. Er ist für LLMs (nicht Chat-Modelle) geeignet, unterstützt Chat-History und wird am besten mit unstrukturierten Tools verwendet, die eine einzelne Zeichenfolge als Eingabe benötigen. Wählen Sie diese Option, wenn Sie mit Modellen arbeiten, die XML beherrschen.
-
Structured Chat: Ein vielseitiger Agent, der in chatbasierten Anwendungen glänzt und Tools mit mehreren Eingaben unterstützt. Er benötigt keine zusätzlichen Modellparameter und ist eine gute Option für Projekte, die komplexe Tool-Interaktionen erfordern.
-
JSON Chat: Ausgerichtet auf Modelle, die in JSON hervorragend sind, ist dieser Agent für Chat-Anwendungen geeignet. Er vereinfacht die Arbeit mit JSON-freundlichen Modellen und erleichtert die Entwicklung von Chat-basierten Anwendungen.
-
ReAct: Einfach, aber effektiv - dieser Agent ist für grundlegende LLM-Anwendungen konzipiert. Er ist ein ausgezeichneter Ausgangspunkt für einfache Modelle, die eine unkomplizierte Implementierung benötigen.
-
Self Ask With Search: Ideal für einfache Modelle mit einem einzelnen Suchwerkzeug - dieser Agent ist perfekt für Projekte, bei denen ein prägnantes, fokussiertes Werkzeugset erforderlich ist.
Jede Agentenart bringt ihre eigenen Stärken mit sich, daher ist es wichtig, den Agenten entsprechend den spezifischen Anforderungen Ihres Projekts auszuwählen. Ob Sie Unterstützung für Chat-History, Multi-Input-Tools oder parallele Funktionen benötigen, es gibt einen Agenten, der genau auf diese Anforderungen zugeschnitten ist. Berücksichtigen Sie die Komplexität Ihrer Aufgaben, die Fähigkeiten des gewählten Sprachmodells und die Art der Interaktionen, die Ihre Anwendung verarbeiten wird. Durch die Abstimmung dieser Faktoren mit dem richtigen Agententyp können Sie das volle Potenzial der LangChain Agents in Ihren Projekten ausschöpfen und den Weg für innovative Lösungen und reibungslose Arbeitsabläufe ebnen.
In der Ausweitung der Feinheiten von LangChain Agents soll dieser Leitfaden ein tieferes Verständnis und praktische Anwendungen verschiedener Agententypen vermitteln. Durch die Untersuchung detaillierter Beispiele und Szenarien erhalten Sie Einblicke in die Auswahl und Implementierung des am besten geeigneten Agenten für die Bedürfnisse Ihres Projekts. Tauchen wir ein in das Herzstück der LangChain Agents und heben ihre einzigartigen Funktionen und Fähigkeiten anhand von Beispielen hervor.
LangChain Agents #1: OpenAI Tools Agent
Der OpenAI Tools Agent ist darauf ausgelegt, nahtlos mit den neuesten OpenAI-Modellen zusammenzuarbeiten und die gleichzeitige Ausführung mehrerer Funktionen oder "Tools" zu erleichtern. Dieser Agent ist besonders nützlich, wenn Ihre Anwendung die Interaktion mit mehreren externen APIs erfordert oder mehrere Aufgaben parallel ausführen soll, um die gesamte Verarbeitungszeit zu reduzieren.
Beispielcode:
# Importieren der erforderlichen Bibliotheken und Tools
from langchain import hub
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
# Initialisieren des Tavily Search Tools
tools = [TavilySearchResults(max_results=1)]
# Abrufen des Prompts und Einrichten des LLM
prompt = hub.pull("hwchase17/openai-tools-agent")
llm = ChatOpenAI(model="gpt-3.5-turbo-1106", temperature=0)
# Erstellen des OpenAI Tools Agenten
agent = create_openai_tools_agent(llm, tools, prompt)
# Führen Sie den Agenten mit einer Beispieleingabe aus
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
response = agent_executor.invoke({"input": "was ist LangChain?"})
print(response)In diesem Beispiel erzeugt die Funktion create_openai_tools_agent einen Agenten, der das OpenAI-Modell nutzen kann, um intelligent zu entscheiden, wann und welche Tools basierend auf der Eingabe aufgerufen werden sollen. Das Tavily Search Tool wird hier verwendet, um die Web-Suchfunktionen zu demonstrieren.
LangChain Agents #2: OpenAI Functions Agent
Der OpenAI Functions Agent ist am besten geeignet für Aufgaben, bei denen das Modell basierend auf der Eingabe entscheiden muss, ob und welche Funktion aufgerufen werden soll. Obwohl er dem Tools Agenten ähnelt, ist er speziell für Szenarien ausgelegt, in denen das Aufrufen von Funktionen zentral für die Aufgabe ist. OpenAI hat diesen Ansatz zugunsten von Tools für neuere Modelle veraltet.
Beispielcode:
# Einrichtung für OpenAI Functions Agent
from langchain import hub
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
# Initialisierung der Tools und Auswahl des LLM
tools = [TavilySearchResults(max_results=1)]
prompt = hub.pull("hwchase17/openai-functions-agent")
llm = ChatOpenAI(model="gpt-3.5-turbo-1106")
# Erzeugen und Ausführen des OpenAI Functions Agenten
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
response = agent_executor.invoke({"input": "was ist LangChain?"})
print(response)Dieses Beispiel zeigt, wie der OpenAI Functions Agent eingerichtet und verwendet wird. Es wird das Tavily Search Tool genutzt, um zu demonstrieren, dass der Agent in der Lage ist, bestimmte Funktionen basierend auf Benutzerabfragen aufzurufen.
LangChain Agents #3: XML Agent
Der XML Agent ist optimiert für Modelle, die gut darin sind, XML-Strukturen zu generieren und zu interpretieren. Dieser Agententyp bietet Vorteile, wenn mit strukturierten Daten gearbeitet wird oder die Interaktion mit dem Modell von dem strukturierten Format von XML profitiert.
Beispielcode:
# Initialisierung des XML Agenten
from langchain import hub
from langchain.agents import AgentExecutor, create_xml_agent
from langchain_community.chat_models import ChatAnthropic
from langchain_community.tools.tavily_search import TavilySearchResults
tools = [TavilySearchResults(max_results=1)]
prompt = hub.pull("hwchase17/xml-agent-convo")
llm = ChatAnthropic(model="claude-2")
# Erzeugen und Ausführen des XML Agenten
agent = create_xml_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
response = agent_executor.invoke({"input": "was ist LangChain?"})
print(response)Dieses Beispiel zeigt die Verwendung eines XML Agenten mit Claude-2, einem Anthropic Modell, das sich durch seine Fähigkeit zur Arbeit mit XML auszeichnet. Das XML-Format ermöglicht eine strukturierte Kommunikation zwischen dem Agenten und dem Modell und erleichtert die Verarbeitung komplexer Daten.
LangChain Agents #4: JSON Chat Agent
Der JSON Chat Agent verwendet JSON-Formatierungen für seine Ausgaben, was ihn für Anwendungen geeignet macht, die strukturierte Antwortdaten erfordern. Dieser Agent eignet sich besonders für Chat-Modelle, die gut in der Verarbeitung und Generierung von JSON-Strukturen sind.
Beispielcode:
# Einrichtung des JSON Chat Agenten
from langchain import hub
from langchain.agents import AgentExecutor, create_json_chat_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
tools = [TavilySearchResults(max_results=1)]
prompt = hub.pull("hwchase17/react-chat-json")
llm = ChatOpenAI()
# Erzeugen und Ausführen des JSON Chat Agenten
agent = create_json_chat_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)
response = agent_executor.invoke({"input": "was ist LangChain?"})
print(response)Hier wird der JSON Chat Agent verwendet, um eine Eingabe zu verarbeiten und eine JSON-formatierte Antwort zu generieren. Dabei wird das Tavily Search Tool für die Web-Suchfunktionen genutzt. Dieser Agent ist besonders nützlich, wenn eine strukturierte Antwort für weitere Verarbeitungsschritte oder für eine strukturiertere Interaktion mit dem Benutzer erforderlich ist.
LangChain Agents #5: Structured Chat Agent
Der Structured Chat Agent eignet sich besonders für Szenarien, die Multi-Input-Tools involvieren und komplexe Interaktionen erfordern, bei denen mehr als nur eine einfache Zeichenketten-Eingabe benötigt wird. Dieser Agent ist darauf ausgelegt, komplexe Workflows zu unterstützen, bei denen für jeden Tool-Aufruf mehrere Parameter berücksichtigt werden müssen.
Beispielcode:
# Initialisierung des Structured Chat Agenten
from langchain import hub
from langchain.agents import AgentExecutor, create_structured_chat_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
tools = [TavilySearchResults(max_results=1)]
prompt = hub.pull("hwchase17/structured-chat-agent")
llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-1106")
# Erzeugen und Ausführen des Structured Chat Agenten
agent = create_structured_chat_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)
response = agent_executor.invoke({"input": "was ist LangChain?"})
print(response)Dieses Beispiel veranschaulicht die Verwendung eines Structured Chat Agenten, um effektiv mit Multi-Input-Tools zu interagieren. Durch detaillierte Angabe des Prompts und Auswahl eines geeigneten Sprachmodells kann dieser Agent komplexe Abfragen und Tool-Interaktionen nahtlos bewältigen. Durch das Verständnis der Unterschiede und Fähigkeiten dieser LangChain Agents können Entwickler ihre Anwendungen besser anpassen, um das volle Potenzial von Sprachmodellen und automatisierten Aufgaben zu nutzen. Ob Ihre Anwendung einfache Funktionsaufrufe, strukturierte Datenverarbeitung oder komplexe Multi-Tool-Interaktionen erfordert, es gibt einen passenden LangChain Agenten. Mit diesen Beispielen als Grundlage sind Sie bestens gerüstet, um Ihre Reise zur Entwicklung intelligenterer, effizienterer und reaktionsfähigerer Anwendungen anzutreten.
Fazit
Zusammenfassend bieten LangChain Agents ein vielseitiges und leistungsstarkes Toolkit für Entwickler, die fortgeschrittene Sprachmodellfunktionen in ihre Anwendungen integrieren möchten. Durch das Verständnis der Feinheiten jeder Agentenart - von OpenAI Tools und Functions Agents bis hin zu XML, JSON Chat und Structured Chat Agents - können Sie das richtige Werkzeug für die spezifischen Anforderungen Ihres Projekts auswählen. Diese Agenten können eine Vielzahl von Aufgaben bewältigen, von einfachen Funktionsaufrufen bis hin zu komplexen Interaktionen mit mehreren Eingaben und strukturierten Datenformaten.