LangGraph Tutorial: Zustandsbehaftete KI-Agenten bauen
Entdecken Sie, wie Sie mit LangGraph in Python robuste, zustandsbehaftete KI-Agenten erstellen. Dieses Tutorial führt Sie durch die Konzepte von Graphen, Knoten und Zuständen, um komplexe, autonome Agentensysteme zu entwickeln, die sich an dynamische Interaktionen anpassen können. Ideal für Entwickler, die sich mit den neuesten KI-Frameworks im Jahr 2026 beschäftigen möchten.
Einführung in LangGraph und zustandsbehaftete KI-Agenten
Die Entwicklung von KI-Agenten hat in den letzten Jahren enorme Fortschritte gemacht, insbesondere mit Frameworks wie LangChain, die die Interaktion mit großen Sprachmodellen (LLMs) vereinfachen. Doch für komplexere Anwendungsfälle, die eine fortlaufende Konversation, Entscheidungsfindung über mehrere Schritte hinweg oder die Verwaltung eines internen Gedächtnisses erfordern, reichen einfache Ketten oft nicht aus. Hier kommt LangGraph ins Spiel. LangGraph erweitert LangChain, indem es eine grafbasierte Architektur für den Aufbau von zustandsbehafteten KI-Agenten bietet. Diese Architektur ermöglicht es, Schleifen, bedingte Weiterleitungen und persistente Zustände zu definieren, was für die Erstellung wirklich autonomer und flexibler Agentensysteme unerlässlich ist. Im Jahr 2026 ist die Beherrschung von LangGraph entscheidend, um die nächste Generation intelligenter Anwendungen zu entwickeln.
Dieses detaillierte LangGraph Tutorial führt Sie Schritt für Schritt durch die Grundlagen und fortgeschrittenen Konzepte. Wir werden lernen, wie man zustandsbehaftete AI-Agenten mit Python baut, die in der Lage sind, komplexe Aufgaben zu bewältigen, indem sie sich an vergangene Interaktionen erinnern und ihre Entscheidungen entsprechend anpassen. Ob Sie virtuelle Assistenten, Forschungsagenten oder komplexe Workflow-Automatisierungen erstellen möchten, LangGraph bietet die notwendigen Werkzeuge. Wir werden uns auf praktische Beispiele konzentrieren und zeigen, wie Sie die leistungsstärksten Modelle der Plattform, wie etwa den GPT-5.3-Codex oder Gemini 3.1 Pro Preview, effektiv nutzen können. Bereiten Sie sich darauf vor, Ihre Fähigkeiten im Bereich der Agentenentwicklung auf das nächste Level zu heben!
Grundlagen von LangGraph: Zustand, Knoten und Kanten
Bevor wir uns in die Implementierung stürzen, ist es wichtig, die Kernkonzepte von LangGraph zu verstehen. Ein LangGraph-Agent ist im Wesentlichen ein gerichteter Graph, dessen Knoten (Nodes) Aktionen oder Entscheidungen darstellen und dessen Kanten (Edges) den Übergang zwischen diesen Knoten definieren. Der entscheidende Unterschied zu traditionellen LangChain-Ketten ist der 'Zustand' (State). Der Zustand ist ein persistentes Objekt, das über den gesamten Lebenszyklus des Agenten hinweg Informationen speichert und bei jedem Schritt aktualisiert wird. Dies ermöglicht es dem Agenten, sich an frühere Schritte zu erinnern und kontextbezogene Entscheidungen zu treffen. Ohne diesen Zustand wäre es unmöglich, kohärente und langanhaltende Interaktionen zu führen, was die Kernfähigkeit der zustandsbehafteten AI ausmacht.
Jeder Knoten im Graphen führt eine bestimmte Operation aus, die den globalen Zustand des Agenten modifizieren kann. Dies könnte das Aufrufen eines LLM sein, die Ausführung eines Tools oder eine bedingte Logik, die den nächsten Schritt basierend auf dem aktuellen Zustand bestimmt. Die Kanten legen fest, wie der Agent von einem Knoten zum nächsten wechselt. Dies kann eine feste Sequenz sein oder, was viel leistungsfähiger ist, eine bedingte Weiterleitung, die auf dem Ergebnis eines Knotens basiert. Dieses flexible Design ist der Schlüssel zur Erstellung komplexer und adaptiver Workflows, die über einfache lineare Ketten hinausgehen. Modelle wie Qwen3 Max Thinking eignen sich hervorragend für die Implementierung der LLM-Knoten in solchen Graphen.
Schritt 1: LangGraph installieren und initialisieren
Erste Schritte mit LangGraph
- 1
Abhängigkeiten installieren
Stellen Sie sicher, dass Sie Python 3.9+ installiert haben. Installieren Sie dann LangChain, LangGraph und das OpenAI-Paket, da wir ein OpenAI-kompatibles Modell verwenden werden. Dies ist der erste wichtige Schritt, um Ihr Entwicklungsumfeld einzurichten.
- 2
API-Schlüssel konfigurieren
Setzen Sie Ihre Multi AI API-Schlüssel als Umgebungsvariablen. Dies ermöglicht es Ihrem Code, sich bei der Multi AI-Plattform zu authentifizieren und auf die verfügbaren Modelle zuzugreifen. Ohne diese Schlüssel können Sie keine LLM-Aufrufe tätigen.
- 3
Den Agenten-Zustand definieren
Erstellen Sie eine TypedDict-Klasse, die den Zustand Ihres Agenten repräsentiert. Dieser Zustand wird über die gesamte Ausführung des Graphen hinweg persistent sein und die notwendigen Informationen speichern. Ein gut definierter Zustand ist das Herzstück jedes zustandsbehafteten Agenten.
- 4
Knotenfunktionen erstellen
Definieren Sie Python-Funktionen, die die Logik für jeden Knoten Ihres Graphen enthalten. Diese Funktionen nehmen den aktuellen Zustand entgegen, verarbeiten ihn und geben einen aktualisierten Zustand zurück. Jeder Knoten sollte eine klare, fokussierte Aufgabe haben.
- 5
Den Graphen kompilieren
Verwenden Sie `StateGraph` von LangGraph, um Ihre Knoten und Kanten zu verbinden. Definieren Sie den Startknoten und die bedingten Kanten, die den Fluss des Agenten steuern. Dieser Schritt wandelt Ihre Funktionen in einen ausführbaren Graphen um.
import os
from typing import TypedDict, Annotated, List
from langchain_core.messages import BaseMessage, HumanMessage
from langgraph.graph import StateGraph, START, END
# 1. API-Schlüssel konfigurieren (Beispiel für Multi AI)
# os.environ["MULTI_AI_API_KEY"] = "Ihre_Multi_AI_API_Schlüssel"
# os.environ["MULTI_AI_BASE_URL"] = "https://api.multi-ai.ai/v1"
# 2. Den Agenten-Zustand definieren
class AgentState(TypedDict):
messages: Annotated[List[BaseMessage], lambda x, y: x + y]
tool_output: str
# 3. Beispielknoten (LLM-Aufruf)
def call_llm(state: AgentState) -> AgentState:
messages = state['messages']
# Hier würden Sie Ihren LLM-Aufruf integrieren, z.B. mit dem GPT-5.3-Codex
# from langchain_openai import ChatOpenAI
# llm = ChatOpenAI(model="gpt-5-3-codex", temperature=0.7, base_url=os.environ["MULTI_AI_BASE_URL"], api_key=os.environ["MULTI_AI_API_KEY"])
# response = llm.invoke(messages)
# return {"messages": [response]}
print("---LLM WIRD AUFGERUFEN---")
# Simulierter LLM-Antwort für das Tutorial
if "tool" in messages[-1].content.lower():
return {"messages": [HumanMessage(content="Ich muss ein Tool aufrufen.")]}
return {"messages": [HumanMessage(content="Hallo! Wie kann ich helfen?")]}
# 4. Beispielknoten (Tool-Aufruf)
def call_tool(state: AgentState) -> AgentState:
print("---TOOL WIRD AUFGERUFEN---")
# Hier würden Sie Ihre Tool-Logik implementieren
return {"tool_output": "Ergebnis des Tools (z.B. Wetterdaten)", "messages": [HumanMessage(content="Das Tool wurde ausgeführt.")]}
# 5. Den Graphen kompilieren (noch ohne Kanten)
workflow = StateGraph(AgentState)
workflow.add_node("llm", call_llm)
workflow.add_node("tool", call_tool)
# Der Graph ist noch nicht ausführbar, da START und END fehlen
print("Graph-Knoten hinzugefügt.")
Zustandsbehaftete AI: Bedingte Logik und Schleifen in LangGraph
Die wahre Stärke von LangGraph liegt in seiner Fähigkeit, komplexe Kontrollflüsse zu implementieren, die über einfache Sequenzen hinausgehen. Dazu gehören bedingte Weiterleitungen und Schleifen. Eine bedingte Weiterleitung ermöglicht es dem Agenten, basierend auf dem aktuellen Zustand oder dem Ergebnis eines Knotens verschiedene Pfade im Graphen zu nehmen. Dies ist entscheidend für Szenarien, in denen der Agent auf unterschiedliche Benutzereingaben reagieren oder je nach Kontext verschiedene Tools aufrufen muss. Ein Agent könnte beispielsweise nach einem LLM-Aufruf entscheiden, ob ein Tool benötigt wird, oder direkt eine Antwort generieren. Lesen Sie auch: CrewAI Tutorial: KI-Teams für komplexe Aufgaben erstellen
Schleifen sind ebenfalls ein fundamentales Element, um zustandsbehaftete AI-Agenten zu bauen, die iterative Aufgaben oder Feedback-Schleifen verwalten können. Stellen Sie sich einen Agenten vor, der Code schreibt, diesen dann testet und bei Fehlern zum Schreibschritt zurückkehrt, um den Code zu korrigieren. Solche Zyklen sind mit LangGraph elegant zu modellieren. Die Möglichkeit, den Agenten in einer Schleife zu halten, bis eine bestimmte Bedingung erfüllt ist, ist ein Game-Changer für die Entwicklung autonomer Systeme im Jahr 2026. Dies ermöglicht es Agenten, Aufgaben selbstständig zu wiederholen und sich selbst zu verbessern. Für diese Art von iterativen Prozessen können Modelle wie Qwen3 Coder Plus oder DeepSeek V3.2 Speciale mit ihrer hervorragenden Code-Generierung und -Analyse eingesetzt werden.
Schritt 2: Bedingte Kanten und Schleifen hinzufügen
from langgraph.graph import StateGraph, START, END
from typing import TypedDict, Annotated, List
from langchain_core.messages import BaseMessage, HumanMessage
# AgentState und Knotenfunktionen von oben (vereinfacht für das Beispiel)
class AgentState(TypedDict):
messages: Annotated[List[BaseMessage], lambda x, y: x + y]
tool_calls: List[dict]
tool_output: str
def call_llm(state: AgentState) -> AgentState:
print("---LLM WIRD AUFGERUFEN---")
# Simulierter LLM-Antwort
last_message = state['messages'][-1].content
if "wetter" in last_message.lower():
return {"messages": [HumanMessage(content="Ich brauche ein Wetter-Tool.")]}
elif "tool" in last_message.lower():
return {"messages": [HumanMessage(content="Ich habe ein Tool aufgerufen.")]}
return {"messages": [HumanMessage(content="Hallo! Wie kann ich helfen?")]}
def call_tool(state: AgentState) -> AgentState:
print("---TOOL WIRD AUSGEFÜHRT---")
return {"tool_output": "Das Wetter ist sonnig.", "messages": [HumanMessage(content="Wetterdaten abgerufen.")]}
# Bedingte Logik für die Weiterleitung
def should_continue(state: AgentState) -> str:
last_message_content = state['messages'][-1].content
if "tool" in last_message_content.lower() or "wetter" in last_message_content.lower():
return "continue_tool"
return "end"
# Den Workflow mit bedingten Kanten aufbauen
workflow = StateGraph(AgentState)
workflow.add_node("llm", call_llm)
workflow.add_node("tool", call_tool)
workflow.add_edge(START, "llm")
# Bedingte Kante vom LLM-Knoten
workflow.add_conditional_edges(
"llm",
should_continue,
{
"continue_tool": "tool",
"end": END
}
)
# Kante vom Tool-Knoten zurück zum LLM für weitere Verarbeitung oder zum Ende
workflow.add_edge("tool", "llm") # Beispiel für eine Schleife oder Rückkehr
# Oder direkt zum END, je nach Anwendungsfall
# workflow.add_edge("tool", END)
app = workflow.compile()
# Ausführung des Graphen
print("---Graph-Ausführung 1---")
inputs = {"messages": [HumanMessage(content="Wie ist das Wetter?")]}
for s in app.stream(inputs):
print(s)
print("\n---Graph-Ausführung 2---")
inputs = {"messages": [HumanMessage(content="Erzähl mir etwas über LangGraph.")]}
for s in app.stream(inputs):
print(s)
Tipp für komplexe bedingte Logik
Verwenden Sie für die `should_continue`-Funktion ein kleines, schnelles Modell wie [Gemma 3 12B (free)](/models/gemma-3-12b-it-free) oder [Nemotron Nano 9B V2 (free)](/models/nemotron-nano-9b-v2-free) als Router. Dies kann die Latenz erheblich reduzieren, da nicht für jede Routing-Entscheidung ein großes, teures LLM aufgerufen werden muss. Ein spezialisiertes Modell kann schnell und kostengünstig bestimmen, welcher Pfad als Nächstes eingeschlagen werden soll, was die Effizienz Ihres Agenten steigert.
Tools und menschliche Interaktion in LangGraph-Agenten
Ein intelligenter KI-Agent ist selten ein isoliertes System. Oft muss er mit externen Tools interagieren, um Informationen abzurufen oder Aktionen in der realen Welt auszuführen. LangGraph integriert sich nahtlos mit LangChain-Tools, sodass Sie Ihrem Agenten die Fähigkeit verleihen können, Web-Suchen durchzuführen, Datenbanken abzufragen oder APIs zu nutzen. Diese Tools werden als spezielle Knoten im Graphen behandelt. Wenn der LLM-Knoten entscheidet, dass ein Tool aufgerufen werden muss, wird der Kontrollfluss an den Tool-Knoten übergeben, der die Aktion ausführt und das Ergebnis zurück in den Agenten-Zustand schreibt. Modelle wie Gemini 3.1 Pro Preview Custom Tools sind speziell für die verbesserte Tool-Nutzung optimiert und bieten eine tiefe Integration.
Darüber hinaus ist die Möglichkeit der menschlichen Interaktion (Human-in-the-Loop) ein entscheidender Aspekt für die Erstellung robuster und vertrauenswürdiger Agentensysteme. LangGraph ermöglicht es Ihnen, explizit Knoten zu definieren, an denen ein menschlicher Benutzer eingreifen, eine Entscheidung überprüfen oder zusätzliche Informationen bereitstellen kann. Dies ist besonders wichtig für kritische Anwendungen, bei denen Fehler hohe Kosten verursachen könnten. Indem Sie menschliche Überprüfungspunkte einbauen, können Sie die Zuverlässigkeit und Sicherheit Ihrer zustandsbehafteten AI-Agenten erheblich steigern. Dies ist eine Best Practice, die im Jahr 2026 immer relevanter wird, da Agenten komplexere und verantwortungsvollere Aufgaben übernehmen.
Fortgeschrittene LangGraph-Konzepte: Mehrere Agenten und Speicherung
LangGraph ist nicht auf einzelne Agenten beschränkt; seine Architektur glänzt auch beim Aufbau von Multi-Agenten-Systemen. Sie können mehrere spezialisierte Agenten erstellen, die jeweils für bestimmte Aufgaben zuständig sind, und diese dann innerhalb eines übergeordneten LangGraph-Workflows koordinieren. Ein Agent könnte beispielsweise für die Recherche zuständig sein, ein anderer für die Code-Generierung und ein dritter für die Überprüfung. Der Hauptgraph würde dann den Informationsfluss zwischen diesen Agenten steuern, wobei jeder Agent seinen eigenen internen Zustand beibehält. Dies ermöglicht eine modulare und skalierbare Entwicklung komplexer Anwendungen. Die Koordination zwischen Agenten kann durch gemeinsame Zustände oder explizite Nachrichtenübergabe erfolgen. Lesen Sie auch: LlamaIndex Tutorial: Wissensbasis mit lokalen LLMs
Ein weiterer entscheidender Aspekt für zustandsbehaftete AI-Agenten ist die Persistenz des Zustands über längere Zeiträume hinweg. LangGraph bietet Mechanismen zur Speicherung des Agenten-Zustands, sodass eine Interaktion unterbrochen und später genau an der Stelle fortgesetzt werden kann, an der sie aufgehört hat. Dies ist unerlässlich für langlebige Assistenten, komplexe Projekte oder Anwendungen, die eine Wiederherstellung nach Abstürzen erfordern. Durch die Integration von Speichermechanismen können Ihre Agenten ihre 'Erinnerung' über Sitzungen hinweg behalten, was die Benutzererfahrung erheblich verbessert und die Entwicklung robuster Systeme ermöglicht. Modelle wie GPT-5 Chat können in solchen persistenten Agenten als Kern-LLM dienen, um kontinuierliche Gespräche zu führen.
Schritt 3: Speicherung und Multi-Agenten-Setup
from langgraph.graph import StateGraph, START, END
from typing import TypedDict, Annotated, List
from langchain_core.messages import BaseMessage, HumanMessage
from langgraph.checkpoint.sqlite import SqliteSaver
# AgentState und Knotenfunktionen von oben
class AgentState(TypedDict):
messages: Annotated[List[BaseMessage], lambda x, y: x + y]
tool_calls: List[dict]
tool_output: str
user_input_needed: bool
def call_llm(state: AgentState) -> AgentState:
print("---LLM WIRD AUFGERUFEN---")
last_message = state['messages'][-1].content
if "menschliche hilfe" in last_message.lower():
return {"user_input_needed": True, "messages": [HumanMessage(content="Ich brauche menschliche Hilfe.")]}
if "tool" in last_message.lower():
return {"messages": [HumanMessage(content="Ich habe ein Tool aufgerufen.")]}
return {"messages": [HumanMessage(content="Hallo! Wie kann ich helfen?")]}
def call_tool(state: AgentState) -> AgentState:
print("---TOOL WIRD AUSGEFÜHRT---")
return {"tool_output": "Ergebnis des Tools", "messages": [HumanMessage(content="Tool ausgeführt.")]}
def human_oversight(state: AgentState) -> str:
if state.get('user_input_needed'):
return "human_input"
return "continue_processing"
# Speichermechanismus
memory = SqliteSaver.from_conn_string(":memory:") # Für ein echtes System Pfad zu einer Datei angeben
# Workflow mit Speicherung und menschlicher Interaktion
workflow = StateGraph(AgentState)
workflow.add_node("llm", call_llm)
workflow.add_node("tool", call_tool)
workflow.add_edge(START, "llm")
workflow.add_conditional_edges(
"llm",
lambda state: "tool" if "tool" in state['messages'][-1].content.lower() else "ask_human" if state.get('user_input_needed') else "end",
{
"tool": "tool",
"ask_human": "human_intervention", # Neuer Knoten für menschliche Interaktion
"end": END
}
)
workflow.add_node("human_intervention", lambda state: {"messages": [HumanMessage(content="Bitte geben Sie Ihre Eingabe ein:")]})
workflow.add_edge("human_intervention", "llm") # Nach menschlicher Eingabe zurück zum LLM
workflow.add_edge("tool", "llm")
app = workflow.compile(checkpointer=memory)
# Beispiel für einen Multi-Agenten-Ablauf (konzeptionell)
# def researcher_agent(state: AgentState) -> AgentState: ...
# def coder_agent(state: AgentState) -> AgentState: ...
# workflow.add_node("researcher", researcher_agent)
# workflow.add_node("coder", coder_agent)
# ... und dann bedingte Kanten zwischen ihnen definieren
print("Graph mit Speicherung und potenzieller menschlicher Interaktion kompiliert.")
# Ausführung mit Speicherung
thread_id = {"configurable": {"thread_id": "1"}}
# Erste Ausführung
print("\n---Erste Ausführung mit Speicherung---")
inputs = {"messages": [HumanMessage(content="Ich brauche menschliche Hilfe.")]}
for s in app.stream(inputs, thread_id):
print(s)
# Zweite Ausführung (simuliert menschliche Eingabe)
print("\n---Zweite Ausführung (menschliche Eingabe)---")
# Normalerweise würde hier die menschliche Eingabe erfolgen, die den Zustand aktualisiert
inputs = {"messages": [HumanMessage(content="Menschliche Eingabe: Ja, bitte fahren Sie fort.")]}
for s in app.stream(inputs, thread_id):
print(s)
Anwendungsbeispiele für zustandsbehaftete KI-Agenten mit LangGraph
Die Einsatzmöglichkeiten von zustandsbehafteten KI-Agenten, die mit LangGraph gebaut wurden, sind vielfältig und decken eine breite Palette von Branchen ab. Im Kundenservice können solche Agenten komplexe Anfragen über mehrere Interaktionen hinweg bearbeiten, indem sie den Kontext des Gesprächs beibehalten und bei Bedarf auf Wissensdatenbanken oder menschliche Agenten eskalieren. Dies führt zu einer deutlich verbesserten Kundenerfahrung und effizienteren Prozessen. Ein Agent könnte beispielsweise den Status einer Bestellung über mehrere Tage hinweg verfolgen und proaktiv Updates senden, anstatt bei jeder Anfrage von vorne zu beginnen.
Im Bereich der Softwareentwicklung können LangGraph-Agenten als Code-Assistenten fungieren, die nicht nur Code generieren, sondern auch Fehler beheben, Tests schreiben und sogar Refactorings vorschlagen. Ein solcher Agent könnte einen Entwickler durch den gesamten Zyklus der Softwareentwicklung begleiten, von der Anforderungsanalyse bis zur Bereitstellung. Durch die Nutzung von Modellen wie GLM 5 oder Qwen3 Coder Next können diese Agenten extrem leistungsfähig sein. Auch in der Finanzanalyse können Agenten komplexe Datenströme überwachen, Trends erkennen und personalisierte Anlageempfehlungen geben, wobei sie sich an die individuellen Präferenzen des Benutzers erinnern und diese im Laufe der Zeit anpassen.
- Virtuelle Assistenten: Führen Sie langanhaltende, kontextbezogene Gespräche über mehrere Sitzungen hinweg.
- Automatisierte Forschung: Agenten, die Informationen aus verschiedenen Quellen sammeln, zusammenfassen und Schlussfolgerungen ziehen, wobei sie ihren Forschungsplan dynamisch anpassen.
- Code-Generierung und -Optimierung: Agenten, die Code schreiben, testen und iterativ verbessern, bis bestimmte Kriterien erfüllt sind.
- Prozessautomatisierung: Steuern Sie komplexe Geschäftsprozesse mit bedingter Logik, menschlicher Freigabe und Integration externer Systeme.
- Interaktive Lernplattformen: Personalisierte Tutoren, die den Lernfortschritt verfolgen und den Lehrplan an die Bedürfnisse des Schülers anpassen.
Fazit: Die Zukunft der zustandsbehafteten KI-Agenten mit LangGraph
LangGraph stellt einen Wendepunkt in der Entwicklung von KI-Agenten dar. Durch seine graphbasierte Architektur und die explizite Verwaltung des Agenten-Zustands ermöglicht es Entwicklern, Systeme zu bauen, die weit über die Fähigkeiten einfacher, linearer Ketten hinausgehen. Die Möglichkeit, bedingte Logik, Schleifen und menschliche Interaktion nahtlos zu integrieren, öffnet die Tür für wirklich autonome und intelligente Anwendungen. Im Jahr 2026 ist LangGraph ein unverzichtbares Werkzeug für jeden, der komplexe und langlebige KI-Agenten mit Python bauen möchte, die in der Lage sind, sich an dynamische Umgebungen anzupassen und sinnvolle, kontextbezogene Interaktionen zu führen. Lesen Sie auch: Ollama Tutorial: LLMs lokal ausführen – Schritt für Schritt
Wir haben in diesem LangGraph Tutorial die Kernkonzepte und Best Practices für den Aufbau zustandsbehafteter AI-Agenten kennengelernt. Von der Definition des Zustands über das Hinzufügen von Knoten und Kanten bis hin zur Implementierung bedingter Logik und Speicherung – die Grundlagen sind gelegt. Die Zukunft der KI liegt in diesen intelligenten, adaptiven Systemen, und LangGraph bietet das robuste Framework, um diese Vision Wirklichkeit werden zu lassen. Beginnen Sie noch heute mit der Erkundung und nutzen Sie die Leistungsfähigkeit von Modellen wie Deep Cogito v2.1 671B oder Llama 3.1 70B Instruct auf der Multi AI-Plattform, um Ihre eigenen innovativen Agenten zu entwickeln. Weitere Informationen finden Sie in der offiziellen LangGraph Dokumentation. Ein Blick auf die PyCharm Blog-Veröffentlichung bietet zudem weitere Einblicke in die LangChain-Integration.
