LangChain-Agents bauen, um Aufgaben in Python zu automatisieren

Setup

Bevor wir loslegen, richten wir die Umgebung für das Tutorial ein.

Zuerst erstellen wir eine neue Conda-Umgebung:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

Installiere die Pakete von LangChain und ein paar weitere notwendige Bibliotheken:

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Füge die neu erstellte Conda-Umgebung als Kernel zu Jupyter hinzu:

$ ipython kernel install --user --name=langchain

Erstelle eine .env-Datei, um Secrets wie API-Schlüssel zu speichern:

$ touch .env
$ vim .env  # Füge deinen OPENAI-Schlüssel ein

OPENAI_API_KEY='YOUR_KEY_HERE'

Lies deinen OpenAI-API-Schlüssel aus der .env-Datei aus:

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

Teste, ob alles funktioniert, indem du das OpenAI-Standardsprachmodell (GPT-3.5) abfragst:

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

There is no definitive answer to this question, as it is subjective and de

Jetzt können wir starten.

Was sind LangChain-Agents?

Lass uns kurz über das Agent-Framework nachdenken. Konkret betrachten wir, wie es sich vom klassischen Chain-Paradigma unterscheidet und welche Komponenten einen Agent ausmachen. Wenn wir verstehen, warum wir Anwendungen auf eine neue Art bauen sollten, sind wir bereit für den Code.

Chains vs. Agents

Das entscheidende Merkmal von Agents ist die Fähigkeit, aus einem Set an Tools die beste Reihenfolge von Aktionen zur Lösung eines Problems zu wählen.

Angenommen, wir haben Folgendes:

• Eine Wetter-API
• ML-Modell für Kleidungsempfehlungen
• Strava-API für Fahrradrouten
• Datenbank mit Nutzerpräferenzen
• Bild­erkennungsmodell
• Sprachmodell (Texterzeugung)

Klassische Problemlösung hieße, eine Kette ausgewählter Tools aus der Liste zu nutzen:

Chain 1: Wetterbasierter Kleidungsempfehler

1. Wetter-API aufrufen
2. Wetterdaten ins ML-Kleidungsmodell einspeisen
3. Kleidungsempfehlungen generieren
4. Ergebnisse anzeigen

Chain 2: Wetterbasierte Routenvorschläge fürs Radfahren

1. Wetter-API aufrufen
2. Strava-API für beliebte Routen abfragen
3. Routen anhand der Wetterlage filtern
4. Passende Routen anzeigen

Chain 3: Outfit-Foto-Analyse

1. Outfit-Foto des Nutzers empfangen
2. Bild­erkennungsmodell zur Identifikation der Kleidungsstücke nutzen
3. Mit der Präferenzdatenbank abgleichen
4. Feedback mit dem Textgenerierungsmodell erzeugen
5. Analyse anzeigen

Jede Chain löst ein spezifisches Problem über eine vordefinierte Abfolge von Schritten mit einem Teil der verfügbaren Tools. Sie kann nicht über ihren definierten Rahmen hinaus adaptieren. Zudem müsstest du drei getrennte Entwicklungsstränge pflegen — ineffizient in Zeit und Ressourcen.

Stell dir nun ein agentisches System vor, das Zugriff auf alle Tools hat. Es kann:

1. Die Anfrage oder das Problem des Nutzers verstehen (in natürlicher Sprache mit einem Sprachmodell)
2. Bewerten, welche Tools relevant sind (Reasoning)
3. Dynamisch einen Workflow mit den passendsten Tools erstellen
4. Den Workflow ausführen und bei Bedarf in Echtzeit anpassen (Acting)
5. Das Ergebnis bewerten und aus früheren Interaktionen lernen

Fragt ein Nutzer zum Beispiel: „Was soll ich heute für meine Radtour anziehen?“, könnte der Agent die Wetter-API prüfen, über Strava passende Routen analysieren, geeignete Kleidung unter Berücksichtigung früherer Präferenzen empfehlen und eine personalisierte Antwort generieren.

Der Agent kann:

• Mit demselben Tool-Set ganz unterschiedliche Probleme lösen
• Für jede Situation individuelle Workflows erstellen
• Sein Vorgehen je nach Kontext und Bedarf anpassen
• Aus Interaktionen lernen und so künftig bessere Ergebnisse liefern

Eine der wichtigsten Stärken von LangChain ist, Sprachmodelle — die für sich allein nur Text erzeugen — in Reasoning-Engines zu verwandeln, die mit verfügbaren Ressourcen sinnvolle Aktionen ausführen. Kurz: LangChain ermöglicht starke autonome Agents, die mit der Außenwelt interagieren.

Zentrale Komponenten

Ein LangChain-Agent besteht aus mehreren Bausteinen wie Chatmodellen, Prompt-Vorlagen, externen Tools und weiteren Konstrukten. Um erfolgreiche Agents zu bauen, sollten wir jeden Baustein und seinen Einsatz verstehen.

Sprach- und Chatmodelle

Beim Erstellen eines LangChain-Agents greifen viele Räder ineinander. Das erste und offensichtlichste ist ein Sprachmodell.

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])

1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make

Sprachmodelle wie OpenAI’s GPT-3.5 Turbo nehmen Strings entgegen und erzeugen Strings. Sie sind typischerweise älter und eignen sich gut, um einzelne Nutzerfragen zu beantworten.

Neuere, leistungsfähigere Modelle sind meist Chatmodelle. Sie nehmen eine Sequenz von Nachrichten als Input und geben Chatnachrichten als Output zurück (anstatt reinem Text):

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
           HumanMessage(content="What's up?")]
output = chat_model.invoke(messages)

Anders gesagt: Chatmodelle ermöglichen echte Gespräche in natürlicher Sprache. Im Beispiel initialisieren wir GPT-4o-mini mit einer Systemnachricht gefolgt von einer Nutzerfrage. Beachte die Klassen SystemMessage und HumanMessage.

Das output ist ein Message-Objekt — genau das ist bei Chatmodellen zu erwarten:

type(output)

langchain_core.messages.ai.AIMessage

print(output.content)

Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!

Zusätzlich liefern sie nützliche Metadaten, die sich per Punktnotation auslesen lassen:

output.dict()

{'content': "Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!",
'additional_kwargs': {},
'response_metadata': {'token_usage': {'completion_tokens': 38,
  'prompt_tokens': 21,
  'total_tokens': 59},
 'model_name': 'gpt-4o-mini-2024-07-18',
 'system_fingerprint': 'fp_48196bc67a',
 'finish_reason': 'stop',
 'logprobs': None},
'type': 'ai',
'name': None,
'id': 'run-fde829bf-8f5-4926-a1ed-ab53609ce03a-0',
'example': False,
'tool_calls': [],
'invalid_tool_calls': [],
'usage_metadata': {'input_tokens': 21,
 'output_tokens': 38,
 'total_tokens': 59}}

Die meisten Agents nutzen Chatmodelle wegen ihres aktuellen Wissens und ihrer Dialogfähigkeiten. Für einfache, zustandslose Agents reichen jedoch oft Sprachmodelle wie GPT-3.5.

Prompt-Vorlagen

Am effizientesten fragst du Sprach- oder Chatmodelle mit Prompt-Vorlagen ab. Damit strukturierst du Anfragen konsistent und fügst Variablen dynamisch ein — das macht Interaktionen flexibler und wiederverwendbar.

In LangChain gibt es viele Prompt-Typen. Die einfachste Klasse ist PromptTemplate. Sie funktioniert mit Sprachmodellen (Plain-Text):

from langchain_core.prompts import PromptTemplate
query_template = "Tell me about {book_name} by {author}."
prompt = PromptTemplate(input_variables=["book_name", "author"], template=query_template)
prompt.invoke({"book_name": "Song of Ice and Fire", "author": "GRRM"})

StringPromptValue(text='Tell me about Song of Ice and Fire by GRRM.')

Du erstellst dazu einen String mit Platzhaltern in geschweiften Klammern. Dann übergibst du diesen Template-String zusammen mit den Variablennamen an die Klasse PromptTemplate und konstruierst so deinen prompt.

Ein Aufruf von .invoke() mit Variablenwerten zeigt dir, wie der Prompt ans Modell übergeben wird.

Um diese Prompt-Vorlage mit einem Sprachmodell zu nutzen, verkettest du sie mit dem Pipe-Operator:

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key)
# Create a chain
chain = prompt | llm
# Invoke the chain
output = chain.invoke({"book_name": "Deathly Hallows", "author": "J.K. Rowling"})
print(output[:100])

Deathly Hallows is the seventh and final book in the popular Harry Potter series, written by J.K. R

Der Pipe-Operator (|) gehört zur LangChain Expression Language (LCEL) und dient dazu, mehrere LangChain-Komponenten und Tools zu verketten.

type(chain)

langchain_core.runnables.base.RunnableSequence

Wenn du den Pipe-Operator auf LangChain-Objekte anwendest, entsteht eine Instanz der Klasse RunnableSequence. Eine RunnableSequence steht für eine Kette von Objekten, die die Methode .invoke() unterstützen, etwa Prompt-Vorlagen und Sprach-/Chatmodelle.

Schauen wir uns nun eine weitere Prompt-Klasse für Chatmodelle an:

from langchain_core.prompts import ChatPromptTemplate

Wir haben erwähnt, dass Chatmodelle eine Sequenz aus Nachrichten benötigen. Der erste Input ist meist ein System-Prompt, der das Verhalten definiert. Mit der Klasse ChatPromptTemplate erstellen wir damit bequem Chatmodelle mit unterschiedlichen „Persönlichkeiten“:

chat_model = ChatOpenAI(api_key=api_key, model="gpt-4o-mini")
template = ChatPromptTemplate([
   ('system', 'You are a helpful AI bot. Your specialty is {specialty}.'),
   ('human', 'Explain the concept of {concept} based on your expertise.')
])

Die Klasse erwartet eine Liste rollenbasierter Nachrichten. Jedes Listenelement ist ein (Rolle, Nachricht)-Tupel mit Variablenplatzhaltern, wo erforderlich.

Danach nutzen wir wieder den Pipe-Operator, um Chatmodelle mit unterschiedlichen Verhaltensweisen zu erstellen:

specialties = ["psychology", "economics", "politics"]
concept = "time"
# Call the model with different personalities
for s in specialties:
   chain = template | chat_model
   output = chain.invoke({"specialty": s, "concept": concept})
   print(output.content[:100], end="\n" + "-" * 25 + '\n')

Time is a complex and multifaceted concept that has been explored from various perspectives, includi
-------------------------
In economics, the concept of time is multifaceted and plays a crucial role in various theories and m
-------------------------
While my primary focus is on politics, I can provide a brief overview of the concept of time as it m
-------------------------

Tools

Wir haben bereits erwähnt, dass Agents aus dem verfügbaren Toolset passende Kombinationen auswählen können — mit LLMs als Reasoning-Engine im Hintergrund.

LangChain bietet Integrationen zu Dutzenden populärer APIs und Services, damit Agents mit der Außenwelt interagieren können. Die meisten findest du im Paket langchain_community, einige in langchain_core.

Hier ein Beispiel mit dem ArXiv-Tool, um Paper-Zusammenfassungen zu verschiedenen Themen abzurufen:

!pip install -Uq arxiv  # Install arXiv Python SDK

from langchain_community.tools import ArxivQueryRun
tool = ArxivQueryRun()
print(tool.invoke('Photosynthesis')[:250])

Published: 2019-08-28
Title: Photosynthesis on Exoplanets and Exomoons from Reflected Light
Authors: Manasvi Lingam, Abraham Loeb
Summary: Photosynthesis offers a convenient means of sustaining biospheres. We
quantify the constraints for photosynthes

Es gibt auch eine Alternative, Tools zu laden, ohne sie direkt über den Klassennamen zu importieren:

from langchain_community.agent_toolkits.load_tools import load_tools
tools = load_tools(["arxiv", "dalle-image-generator"])

Hier laden wir gleichzeitig die arXiv- und die Dall-E-Bildgeneratortools mit der Funktion load_tools(). So geladene Tools lassen sich gleichartig verwenden:

# Call arXiv
print(tools[0].invoke("Kaggle")[:150])

Published: 2020-06-06
Title: StackOverflow vs Kaggle: A Study of Developer Discussions About Data Science
Authors: David Hin
Summary: Software develop

# Generate an image with DallE
output_image_url = tools[1].invoke("A magnificent chain in a cartoon.")
output_image_url

'https://oaidalleapiprodscus.blob.core.windows.net/...'

Die Funktion load_tools erwartet, dass du die String-Namen der Toolklassen kennst — etwa ArxivQueryRun gegenüber 'arxiv'. Mit get_all_tool_names findest du die verfügbaren Namen schnell heraus:

from langchain_community.agent_toolkits.load_tools import get_all_tool_names
get_all_tool_names()[:10]

['sleep',
'wolfram-alpha',
'google-search',
'google-search-results-json',
' searx-search-results-json',
'bing-search',
'metaphor-search',
'ddg-search',
'google-lens',
'google-serper']

Beachte, dass load_tools() nur eine Abkürzung ist. Beim Bauen von Agents empfiehlt es sich, Tools über ihre Klassenkonstruktoren zu laden, um sie passgenau zu konfigurieren.

Schritt-für-Schritt-Workflow zum Erstellen von LangChain-Agents

Zum Schluss schauen wir uns an, wie wir mit dem bisher Gelernten LangChain-Agents Schritt für Schritt erstellen.

In den folgenden Beispielen bauen wir einen Agent, der jedes Thema über drei Kanäle erklären kann: Text, Bild oder Video. Basierend auf der Frage entscheidet der Agent, in welchem Format er erklärt.

Los geht’s. Denk daran, dir das Setup am Anfang des Artikels anzusehen. 

1. Tools definieren

Nach der Umgebungskonfiguration definieren wir die Tools für unseren Agent. Importieren wir sie:

from langchain_community.tools import WikipediaQueryRun  # pip install wikipedia
from langchain_community.utilities import WikipediaAPIWrapper
from langchain_community.tools import YouTubeSearchTool  # pip install youtube_search
from langchain_community.tools.openai_dalle_image_generation import (
   OpenAIDALLEImageGenerationTool
)
from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper

Wir importieren fünf Klassen:

• WikipediaAPIWrapper: konfiguriert den Zugriff auf die Wikipedia-API
• WikipediaQueryRun: erzeugt Wikipedia-Zusammenfassungen
• YouTubeSearchTool: sucht YouTube-Videos zu Themen
• DallEAPIWrapper: konfiguriert den Zugriff auf OpenAI’s DallE-Endpunkt
• OpenAIDALLEImageGenerationTool: erzeugt Bilder aus Prompts

Wenn der Agent eine Anfrage erhält, entscheidet er, ob das Thema per Wikipedia-Text erklärt wird, ob er mit Dall-E ein Bild für das Verständnis erzeugt oder ob YouTube-Videos für tieferes Verständnis am besten sind.

Initialisieren wir die Tools, beginnend mit Wikipedia:

wiki_api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=250)
wikipedia = WikipediaQueryRun(description="A tool to explain things in text format. Use this tool if you think the user’s asked concept is best explained through text.", api_wrapper=wiki_api_wrapper)
print(wikipedia.invoke("Mobius strip"))

Page: Möbius strip
Summary: In mathematics, a Möbius strip, Möbius band, or Möbius loop is a surface that can be formed by attaching the ends of a strip of paper together with a half-twist. As a mathematical object, it was discovered by Johann Benedi

DallE-Bilderzeugung:

dalle_api_wrapper = DallEAPIWrapper(model="dall-e-3", size="1792x1024")
dalle = OpenAIDALLEImageGenerationTool(
   api_wrapper=dalle_api_wrapper, description="A tool to generate images. Use this tool if you think the user’s asked concept is best explained through an image."
)
output = dalle.invoke("A mountain bike illustration.")
print(output)

YouTube-Suchtool:

youtube = YouTubeSearchTool(
   description="A tool to search YouTube videos. Use this tool if you think the user’s asked concept can be best explained by watching a video."
)
youtube.run("Oiling a bike's chain")

"['https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUVT2lsaW5nIGEgYmlrZSdzIGNoYWlu', 'https://www.youtube.com/watch?v=T6xyn1FGHiU&pp=ygUVT2lsaW5nIGEgYmlrZSdzIGNoYWlu']"

Achte besonders auf die Tool-Beschreibungen. Der Agent wählt anhand dieser Beschreibung das passende Tool aus. 

Jetzt packen wir die Tools in eine Liste:

tools = [wikipedia, dalle, youtube]

Diese Toolmenge können wir bereits an ein Chatmodell binden, ohne direkt einen Agent zu bauen:

chat_model = ChatOpenAI(api_key=api_key)
model_with_tools = chat_model.bind_tools(tools)

Testen wir das Modell mit einer einfachen Nachricht:

response = model_with_tools.invoke([HumanMessage("What's up?!")])
print(f"Text response: {response.content}")
print(f"Tools used in the response: {response.tool_calls}")

Text response: Hello! How can I assist you today?
Tools used in the response: []

Der Output zeigt: Es wurden keine gebundenen Tools für die Antwort verwendet. Stellen wir nun eine konkrete Frage, die das Modell über sein Trainingswissen hinaus zwingt:

response = model_with_tools.invoke([
   HumanMessage("Can you generate an image of a mountain bike?")
])
print(f"Text response: {response.content}")
print(f"Tools used in the response: {response.tool_calls}")

Text response:
Tools used in the response: [{'name': 'openai_dalle', 'args': {'query': 'mountain bike'}, 'id': 'call_92GBfmsYtPi9TpGuIOFB1pG8', 'type': 'tool_call'}]

Wir sehen: Es gibt keinen Text, aber OpenAI’s DallE wird vorgeschlagen. Das Tool wurde noch nicht ausgeführt; das Modell empfiehlt nur den Einsatz. Um es wirklich aufzurufen — also zu handeln — brauchen wir einen Agent.

2. Einen einfachen Agent erstellen

Nach Modell und Tools erstellen wir den Agent. LangChain bietet über das Paket langgraph die High-Level-Funktion create_react_agent(), um schnell ReAct-(Reason-and-Act)-Agents zu bauen:

from langgraph.prebuilt import create_react_agent
system_prompt = SystemMessage("You are a helpful bot named Chandler.")
agent = create_react_agent(chat_model, tools, state_modifier=system_prompt)

Beim Initialisieren übergeben wir Chatmodell und Tool-Liste sowie einen System-Prompt für das Grundverhalten. Jetzt ist der Agent bereit für Anfragen:

from pprint import pprint
response = agent.invoke({"messages": HumanMessage("What's up?")})
pprint(response["messages"])

[HumanMessage(content="What's up?", id='133b9380-cfe1-495a-98f7-b835c874bd57'),
AIMessage(content='Hello! How can I assist you today?', response_metadata={'token_usage': {'completion_tokens': 10, 'prompt_tokens': 112, 'total_tokens': 122}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-0a920c15-39b4-4857-ab51-6ea905575dba-0', usage_metadata={'input_tokens': 112, 'output_tokens': 10, 'total_tokens': 122})]

Wir bekommen erwartungsgemäß eine einfache Textantwort ohne Toolaufrufe. Stellen wir eine gezieltere Frage:

response = agent.invoke({"messages": [
   HumanMessage('Explain how photosynthesis works.')
]})
print(len(response['messages']))

4

Diesmal sind es vier Nachrichten. Schauen wir uns Klassen und Inhalte an:

for message in response['messages']:
   print(
       f"{message.__class__.__name__}: {message.content}"
   )  # Print message class name and its content
   print("-" * 20, end="\n")

HumanMessage: Explain how photosynthesis works.
--------------------
AIMessage:
--------------------
ToolMessage: Page: Photosynthesis
Summary: Photosynthesis ( FOH-tə-SINTH-ə-sis) is a system of biological processes by which photosynthetic organisms, such as most plants, algae, and cyanobacteria, convert light energy, typically from sunlight, into the chemical
--------------------
AIMessage: Photosynthesis is a biological process where photosynthetic organisms like plants, algae, and cyanobacteria convert light energy, usually from sunlight, into chemical energy. This process involves capturing light energy through pigments like chlorophyll in plant cells and using it to convert carbon dioxide and water into glucose and oxygen. Glucose serves as a source of energy for the plant, while oxygen is released into the atmosphere as a byproduct. Photosynthesis is crucial for the survival of plants and the balance of oxygen and carbon dioxide in the atmosphere.
--------------------

Da haben wir es: Die dritte Nachricht stammt aus einem Toolaufruf — einer Wikipedia-Zusammenfassung. Die letzte Nachricht verwendet diese Inhalte zur Antwortgenerierung.

Zum Abschluss kapseln wir die letzten Schritte in einer Funktion:

def execute(agent, query):
   response = agent.invoke({'messages': [HumanMessage(query)]})
  
   for message in response['messages']:
       print(
           f"{message.__class__.__name__}: {message.content}"
       )  # Print message class name and its content
      
       print("-" * 20, end="\n")
  
   return response

3. Den System-Prompt verfeinern

Jetzt erweitern wir den System-Prompt mit genauen Verhaltensanweisungen:

system_prompt = SystemMessage(
   """
   You are a helpful bot named Chandler. Your task is to explain topics
   asked by the user via three mediums: text, image or video.
  
   If the asked topic is best explained in text format, use the Wikipedia tool.
   If the topic is best explained by showing a picture of it, generate an image
   of the topic using Dall-E image generator and print the image URL.
   Finally, if video is the best medium to explain the topic, conduct a YouTube search on it
   and return found video links.
   """
)

Erstellen wir den Agent mit dem neuen System-Prompt neu:

agent = create_react_agent(chat_model, tools, state_modifier=system_prompt)
response = execute(agent, query='Explain the Fourier Series visually.')

HumanMessage: Explain the Fourier Series visually.
--------------------
AIMessage:
--------------------
ToolMessage: https://oaidalleapiprodscus.blob.core.windows.net/private/org-qRwX4bsgcnaYHHwbxFBdZxUy/user-LOXQPflMtXxamV72hac9oS2O/img-iY3gXXBzWapRWKdmkd9cXEIN.png?st=2024-08-09T18%3A36%3A46Z&se=2024-08-09T20%3A36%3A46Z&sp=r&sv=2024-08-04&sr=b&rscd=inline&rsct=image/png&skoid=d505667d-d6c1-4a0a-bac7-5c84a87759f8&sktid=a48cca56-e6da-484e-a814-9c849652bcb3&skt=2024-08-09T17%3A56%3A46Z&ske=2024-08-10T17%3A56%3A46Z&sks=b&skv=2024-08-04&sig=Ly8F4jvakFeEtpZ/6jMliLq%2BG3Xs%2Bz1AmX1sL06%2BQ3U%3D
--------------------
AIMessage: Here is a visual representation of the Fourier Series:
![Fourier Series](https://oaidalleapiprodscus.blob.core.windows.net/private/org-qRwX4bsgcnaYHHwbxFBdZxUy/user-LOXQPflMtXxamV72hac9oS2O/img-iY3gXXBzWapRWKdmkd9cXEIN.png)
The Fourier Series is a way to represent a function as the sum of simple sine waves. It is used in many areas of mathematics and physics to analyze and understand periodic phenomena.
--------------------

Großartig — basierend auf unserer (sehr deutlichen) Nachricht hat der Agent das richtige Tool gewählt. Hier ist das erzeugte Bild:

4. Agents Speicher geben

Aktuell ist unser Agent zustandslos, er erinnert sich also nicht an frühere Interaktionen:

response = execute(agent, query="What did I ask you in the previous query?")

HumanMessage: What did I ask you in the previous query?
--------------------
AIMessage: I'm sorry, I cannot remember the previous query as I don't have access to the conversation history. How can I assist you today?
--------------------

Am einfachsten fügst du Chatverlauf mit der Klasse SqliteSaver aus langgraph hinzu:

from langgraph.checkpoint.sqlite import SqliteSaver
memory = SqliteSaver.from_conn_string(':agent_history:')
agent = create_react_agent(chat_model, tools, checkpointer=memory, state_modifier=system_prompt)

Wir initialisieren den Speicher über die Methode .from_conn_string() von SqliteSaver, wodurch eine Datenbankdatei entsteht. Anschließend übergeben wir memory an den Parameter checkpointer von create_react_agent().

Als Nächstes erstellen wir ein Konfigurations-Dictionary:

config = {'configurable': {'thread_id': 'a1b2c3'}}

Dieses Dictionary definiert eine Thread-ID, um Konversationen zu unterscheiden, und wird an die Methode .invoke() unseres Agents übergeben. Aktualisieren wir unsere Funktion execute() entsprechend:

def execute(agent, query, thread_id="a1b2c3"):
   config = {"configurable": {"thread_id": thread_id}}
   response = agent.invoke({'messages': [HumanMessage(query)]}, config=config)
   for message in response["messages"]:
       print(
           f"{message.__class__.__name__}: {message.content}"
       )  # Print message class name and its content
       print("-" * 20, end="\n")
   return response
Let’s test it again:
response = execute(
   agent, query="Explain how to oil a bike's chain using a YouTube video", thread_id="123"
)

HumanMessage: Explain how to oil a bike's chain using a YouTube video
--------------------
AIMessage:
--------------------
ToolMessage: ['https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D', 'https://www.youtube.com/watch?v=ubKCHtZ20-0&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D']
--------------------
AIMessage: I found a couple of YouTube videos that explain how to oil a bike chain:
1. [Video 1: How to oil a bike chain](https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D)
2. [Video 2: Step-by-step guide on oiling a bike chain](https://www.youtube.com/watch?v=ubKCHtZ20-0&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D)
You can watch these videos to learn how to oil your bike's chain effectively.
--------------------

Fragen wir den Agent nun nach früheren Anfragen:

response = execute(agent, query='What have I asked you so far?', thread_id='123')
print(response)

{'messages': [HumanMessage(content="Explain how to oil a bike's chain using a YouTube video",     id='8254142b-fb77-4958-8ad9-0a0283c6611a'), ...
]

Wie erwartet liefert der Agent die bisherigen Nachrichten zurück! Fehlt nur noch ein Chat-UI wie bei ChatGPT, und du hast deinen eigenen Chatbot.

Zukünftige Trends und Entwicklungen

Im Artikel haben wir gesehen, wohin sich LangChain bei Agents entwickelt. Bis vor Kurzem hat LangChain vor allem die Klasse AgentExecutor genutzt, die nun schrittweise durch langgraph-Agents ersetzt wird.

Reine LangChain-Agents sind für den Einstieg okay, benötigen aber mehr Codezeilen als LangGraph für denselben Agent. Und ab einem gewissen Punkt bietet das AgentExecutor-Framework nicht die Flexibilität von LangGraph, wenn es um komplexe Multi-Tool-Agents geht.

Deshalb ist jetzt ein guter Zeitpunkt, die Welle zu reiten und direkt mit LangGraph zu starten.

Wir empfehlen außerdem dringend, LangSmith zu nutzen. Es ist zu einem Kernteil des LangChain-Ökosystems für produktionsreife LLM-Anwendungen geworden. Einige zentrale Vorteile:

• Debugging: LangSmith bietet detaillierte Traces der Agent-Ausführung, sodass sich Probleme leichter finden und beheben lassen.
• Performance-Optimierung: Mit LangSmith analysierst du Tokenverbrauch, Latenz und weitere Metriken, um die Effizienz deines Agents zu steigern.
• Testing und Evaluation: LangSmith erleichtert das Erstellen und Verwalten von Testdatensätzen, um die Agent-Performance über viele Szenarien hinweg fundiert zu prüfen.
• Monitoring: In Produktion bietet LangSmith Echtzeit-Monitoring, sodass du die Leistung deines Agents verfolgen und Anomalien schnell erkennen kannst.

So startest du mit LangSmith:

1. Registriere dich kostenlos hier.
2. Setze die Umgebungsvariablen.

export LANGCHAIN_TRACING_V2="true"

export LANGCHAIN_API_KEY="..."

und schon kannst du loslegen! Sobald du Sprach-/Chatmodelle abfragst, protokolliert LangSmith diverse Metriken zu jedem Run:

Fazit

In diesem Artikel haben wir herausgearbeitet, was LangChain-Agents von Chains unterscheidet und welche Bausteine für ihren Aufbau wichtig sind. Zuerst haben wir Agents eingeführt und gezeigt, wie sie sich in Flexibilität und Entscheidungsfähigkeit von klassischen Chains abheben.

Dann haben wir die Schlüsselelemente zum Bauen von Agents betrachtet: Chatmodelle, Tools und Prompt-Vorlagen. Abschließend sind wir zwei Beispiele durchgegangen — für einfache und fortgeschrittene Agents. Die Sprachverarbeitung entwickelt sich rasant, und LangChain-Agents stehen an der Spitze dieser Entwicklung und ebnen den Weg für eine noch intelligentere und vielseitigere KI-Familie.

Hier ein paar weiterführende Ressourcen, um dein LangChain-Wissen auszubauen:

• Developing LLM Applications with LangChain Course 
• An Introduction to Prompt Engineering with LangChain 
• How to Build LLM Applications with LangChain Tutorial
• Building a GPT Model with Browsing Capabilities Using LangChain Tools
• LangChain vs LlamaIndex: A Detailed Comparison

Danke fürs Lesen!