LangChain Agents erstellen

LangChain ist ein Framework zum Erstellen von LLM-Anwendungen, das Modellaufrufe zu zusammensetzbaren, kontrollierbaren und skalierbaren Anwendungssystemen erweitert.

Was LangChain löst, ist nicht, wie Modelle aufgerufen werden, sondern:

Wie mehrstufiges Schlussfolgern organisiert wird
Wie externe Daten integriert werden
Wie Tools von Modellen sicher aufgerufen werden können
Wie Kontext langfristig verwaltet wird

Open-Source-Repository:https://github.com/langchain-ai/langchain。

LangChain-Tutorial:https://www.example.com/langchain/langchain-tutorial.html

Stellen Sie sich vor, Sie bauen einen intelligenten Roboterassistenten. Dieser Assistent muss Ihre Fragen verstehen, Informationen aus verschiedenen Quellen suchen, logische Schlussfolgerungen anstellen und Ihnen schließlich in natürlicher Sprache antworten. Allein ein Sprachmodell wie GPT zu verwenden, ist, als würde man dem Roboter nur ein kluges Gehirn geben, aber es fehlen ihm noch Hände und Augen – es weiß nicht, wie es externe Daten erhalten oder bestimmte Aufgaben ausführen soll.

LangChainEs ist genau ein solches Framework und spielt die Rolle eines Verbinders und Koordinators.

LangChainEs verbindet auf clevere Weise leistungsstarke Sprachmodelle (wie GPT-4, DeepSeek) mit externen Datenquellen, Berechnungswerkzeugen und Gedächtnissystemen, um leistungsstarke, praktische KI-Anwendungen zu erstellen.

Einfach gesagt liegt der Kernwert von LangChain darin:Sprachmodelle nützlich zu machen, was mehrere zentrale Einschränkungen großer Sprachmodelle (LLMs) adressiert:

Echtzeitwissen: Trainingsdaten von LLMs haben einen Stichtag und können die neuesten Informationen nicht abrufen.
Domänenspezialisierung: Allgemeine LLMs verfügen nicht über privates Wissen, das für eine Branche oder ein Unternehmen spezifisch ist.
Aktionsfähigkeit: LLMs selbst können keine Aktionen wie Berechnungen, Datenbankabfragen, API-Aufrufe usw. ausführen.
Gesprächskohärenz: In mehrstufigen Gesprächen müssen sich LLMs an den vorherigen Chatverlauf erinnern.

LangChain organisiert diese Fähigkeiten durch eine Reihe standardisierter Chains und Komponenten, sodass Entwickler komplexe KI-Anwendungen wie mit Bausteinen schnell erstellen können.

Überblick über die LangChain-Module:

LLMs / ChatModels: Modellschnittstellen
Prompt-Vorlagen: Prompt-Strukturierung
Chains: Workflow-Orchestrierung
Memory: Kontextverwaltung
Retrievers / VectorStores: Wissensabruf
Agents & Tools: Automatische Entscheidungsfindung und Ausführung

Umgebungsvorbereitung

Installation über einen inländischen Mirror:

pip install langchain langchain-openai langchain-community python-dotenv -i https://mirrors.aliyun.com/pypi/simple/

Wenn Sie OpenAI verwenden, können Sie Umgebungsvariablen konfigurieren:

export OPENAI_API_KEY=你的key

Testen Sie anschließend mit dem folgenden Code:

Beispiel

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

resp = llm.invoke("Erkläre in einem Satz, was LangChain ist")
print(resp.content)

In China können wir das große DeepSeek-Modell zum Testen verwenden. Wenn du noch keines hast, musst du zuerst zuhttps://platform.deepseek.com/api_keysgehen und einen API-Schlüssel erstellen.

Referenz zur DeepSeek-API-Dokumentation:https://api-docs.deepseek.com/zh-cn/。

Wenn Sie mehrere Modelle von Drittanbietern zentral verwalten müssen, können Sie LiteLLM als Modell-Gateway installieren:

pip install -U litellm

Die Beispiele in diesem Artikel verwenden jedoch direktChatOpenAIzusammen mitopenai_api_baseParameter, um eine Verbindung zu DeepSeek herzustellen, ohne LiteLLM separat installieren zu müssen.

Beispiel

import os
from langchain_openai import ChatOpenAI

# Es wird empfohlen, den API Key in einer Umgebungsvariable abzulegen oder ihn hier direkt zuzuweisen (im Produktivbetrieb nicht hartcodieren).
# os.environ["DEEPSEEK_API_KEY"] = "sk-your-DeepSeek-secret-key"

# Modell initialisieren
llm = ChatOpenAI(
model="deepseek-v4-pro", # DeepSeek V4 Modellname
openai_api_key="sk-your-Key", # Tragen Sie Ihren DeepSeek API Key ein
openai_api_base="https://api.deepseek.com", # DeepSeek API-Endpunkt
temperature=0.7,
max_tokens=1024
)

# Ausprobieren
response = llm.invoke("Hallo, DeepSeek! Bitte gib eine kurze Selbstvorstellung.")
print(response.content)

Die Ausführung des obigen Codes gibt Folgendes aus:

你好！很高兴认识你！

我是DeepSeek，由深度求索公司创造的AI助手。我的特点包括：
。。。

LCEL-Ketten erstellen (LangChain Expression Language)

Das bloße Aufrufen des Modells ist nicht leistungsfähig genug; wir müssen eine standardmäßige Verarbeitungspipeline aufbauen:

Prompt -> LLM -> OutputParser

Der vollständige Code sieht wie folgt aus:

Beispiel

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

# 1. Das Modell definieren (Model)
llm = ChatOpenAI(
model="deepseek-v4-pro",
openai_api_key="your_DEEPSEEK_API_KEY",
openai_api_base="https://api.deepseek.com"
)

# 2. Die Prompt-Vorlage definieren (Prompt)
# system: Die Rolle der KI festlegen
# user: Die spezifische Eingabe des Benutzers
prompt = ChatPromptTemplate.from_messages([
("system", "Du bist ein erfahrener technischer Experte, der darin brilliert, komplexe Technologiekonzepte in einfacher, leicht verständlicher Sprache zu erklären. Deine Erklärung sollte eine anschauliche Analogie enthalten."),
("user", "{concept}")
])

# 3. Den Ausgabe-Parser definieren (Output Parser)
# Das Message-Objekt des Modells direkt in einen einfachen String umwandeln
parser = StrOutputParser()

# 4. Die Kette aufbauen (Chain) – den Pipe-Operator | zum Verbinden verwenden
# Ablauf: Eingabe-Dictionary -> Prompt füllen -> an LLM senden -> Ausgabe parsen
chain = prompt | llm | parser

# 5. Chain aufrufen
concept_to_explain = Quantenverschränkung
print(fKonzept wird erklärt: {concept_to_explain}...\n")

result = chain.invoke({"concept": concept_to_explain})

print(--- DeepSeek-Antwort ---)
print(result)

Streaming-Ausgabe

In realen Anwendungen (wie Chatbots) müssen wir Text Zeichen für Zeichen wie bei ChatGPT ausgeben, anstatt ihn erst nach Abschluss der Generierung vollständig anzuzeigen.

LangChain unterstützt dies ganz einfach, indem man.stream()statt.invoke() verwendet：

Beispiel

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

# 1. Das Modell definieren
llm = ChatOpenAI(
model="deepseek-v4-pro",
openai_api_key=your_DEEPSEEK_API_KEY,
openai_api_base="https://api.deepseek.com"
)

# 2. Die Prompt-Vorlage definieren
# system: Die Rolle der KI festlegen
# user: Die spezifische Eingabe des Benutzers
prompt = ChatPromptTemplate.from_messages([
("system", "Du bist ein erfahrener technischer Experte, der komplexe technische Konzepte in einfacher, leicht verständlicher 'Alltagssprache' erklärt. Deine Erklärung sollte eine anschauliche Metapher enthalten."),
("user", "{concept}")
])

# 3. Den Ausgabe-Parser definieren
# Das Message-Objekt des Modells direkt in einen einfachen String umwandeln
parser = StrOutputParser()

# 4. Die Chain aufbauen – mit dem Pipe | verbinden
# Ablauf: Eingabe-Dictionary -> Prompt füllen -> an LLM senden -> Ausgabe parsen
chain = prompt | llm | parser

# 5. Chain aufrufen
concept_to_explain = Quantenverschränkung
print(fKonzept wird erklärt: {concept_to_explain} (Streaming-Ausgabe)...\n")

# Hierbei ist chunk das jeweils generierte Fragment
for chunk in chain.stream({"concept": Rekursives neuronales Netz}):
print(chunk, end="", flush=True)

Codestruktur

Prompt

ChatPromptTemplateKlar unterscheidensystem / user
Prompt isteine strukturierte Eingabefunktion, kein String

LLM

ChatOpenAInur eine einheitliche Schnittstelle
LangChain erweitert nicht die Modellfähigkeiten, sondern erhöht nur dieKontrollierbarkeit

OutputParser

Die Modellausgabe ist immerMessage
StrOutputParserJaexplizite Typkonvertierung
Ohne einen Parser ist das Projekt unkontrollierbar.

Kernkomponenten erklärt

1. Modelle

LangChain bietet eine einheitliche Abstraktionsschnittstelle. Derzeit wird hauptsächlich empfohlen,Chat Modelszu verwenden, da aktuelle Modelle (wie DeepSeek, GPT-4) größtenteils für Konversation optimiert sind.

Chat-Modelle: Ein- und Ausgabe sind strukturierte Nachrichten.
SystemMessage: Legen Sie die Rolle der KI fest.
HumanMessage: Vom Benutzer gesendete Nachrichten.
AIMessage: Die von der KI zurückgegebene Nachricht.

2. Prompts

In der neuen Version wird empfohlen,ChatPromptTemplatezum Erstellen von Konversations-Prompts zu verwenden, was besser mit den Aufrufkonventionen aktueller Mainstream-LLMs übereinstimmt.

from langchain_core.prompts import ChatPromptTemplate

# 使用 from_messages 构建结构化模板
prompt_template = ChatPromptTemplate.from_messages([
    ("system", "你是一位专业的{role}。"),
    ("user", "{content}")
])

# 动态填充变量
prompt = prompt_template.invoke({"role": "美食评论家", "content": "评价一下这碗炸酱面"})
# 输出：包含 SystemMessage 和 HumanMessage 的列表

3. Chains & LCEL

Wichtige Updates: LLMChainist veraltet. Verwenden Sie jetztLCEL (Pipe-Operator|)Syntax. Dieser Ansatz ist flexibler und unterstützt asynchrone und Streaming-Ausgabe.

# 现代写法：Prompt | Model | OutputParser
from langchain_core.output_parsers import StrOutputParser

# 这里的 llm 是 ChatOpenAI(model="deepseek-v4-pro") 的实例
chain = prompt_template | llm | StrOutputParser()

# 调用链
result = chain.invoke({"role": "导游", "content": "介绍一下故宫"})
print(result) # 直接输出字符串

4. Indizes & Retrieval

Dies istRAG (Retrieval-Augmented Generation)im Kern. Die neue Version betont den Prozess der Umwandlung von Dokumenten in "Retriever".

Process: DocumentLoaders(Laden) ->TextSplitter(Chunking) ->Embeddings(Vektorisierung) ->VectorStore(Speicherung).
Retriever: Es ist nicht mehr nur eine Datenbanksuche; es ist eine Komponente, die in eine Chain integriert werden kann.

# 将向量库转为检索器
retriever = vectorstore.as_retriever()
# 在新版链中引用
# chain = {"context": retriever, "question": RunnablePassthrough()} | prompt | llm

Vollständiges praktisches RAG-Beispiel

Im Folgenden implementieren wir eine vollständige RAG-Anwendung. Zuerst müssen wir zusätzliche Abhängigkeiten installieren:

pip install langchain-community faiss-cpu sentence-transformers -i https://mirrors.aliyun.com/pypi/simple/

Beispiel

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_community.vectorstores import FAISS
from langchain.text_splitter import RecursiveCharacterTextSplitter

# Umgebungsvariablen laden
load_dotenv()

# Modell und Embedding initialisieren
llm = ChatOpenAI(
model=os.getenv('DEEPSEEK_MODEL', 'deepseek-v4-pro'),
openai_api_key=os.getenv('DEEPSEEK_API_KEY'),
openai_api_base=os.getenv('DEEPSEEK_BASE_URL', 'https://api.deepseek.com'),
)

# Ein kostenloses lokales Embedding-Modell verwenden (wird beim ersten Ausführen automatisch heruntergeladen)
embeddings = HuggingFaceEmbeddings(
model_name="sentence-transformers/all-MiniLM-L6-v2"
)

# --- 1. Wissensdokumente vorbereiten ---
# In realen Projekten können diese Dokumente aus Dateien, Webseiten, Datenbanken usw. geladen werden.
documents = [
"LangChain ist ein Open-Source-Framework zum Erstellen von Anwendungen für große Sprachmodelle, das 2022 von Harrison Chase erstellt wurde.",
"Zu den Kernkomponenten von LangChain gehören: Modellschnittstellen, Prompt-Vorlagen, Chains, Memory, Retrieval und Agents.",
"LCEL (LangChain Expression Language) ist die neue Generation der Chain-Building-Syntax von LangChain, die den Pipe-Operator | verwendet, um Komponenten zu verbinden.",
"RAG (Retrieval-Augmented Generation) ruft relevante Dokumente vor der Generierung ab, sodass LLMs Fragen über die Trainingsdaten hinaus beantworten können.",
"LangGraph ist ein neues Framework, das vom LangChain-Team veröffentlicht wurde und speziell für die Erstellung komplexer mehrstufiger KI-Agenten-Workflows gedacht ist.",
"LangSmith ist die Observability-Plattform von LangChain zum Debuggen, Testen und Überwachen von LLM-Anwendungen.",
]

# --- 2. Text-Chunking ---
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=100,
chunk_overlap=20
)
# Die Dokumente hier sind bereits kurz; in realen Szenarien werden lange Dokumente in mehrere Segmente aufgeteilt
texts = text_splitter.create_documents(documents)

# --- 3. Vektorisieren und in FAISS speichern ---
vectorstore = FAISS.from_documents(texts, embeddings)

# --- 4. Einen Retriever erstellen ---
retriever = vectorstore.as_retriever(search_kwargs={"k": 2})

# --- 5. RAG-Chain erstellen ---
rag_prompt = ChatPromptTemplate.from_messages([
("system", Du bist ein Wissensassistent. Beantworte die Frage basierend auf dem unten abgerufenen Kontext. Wenn die Antwort nicht im Kontext steht, sage, dass du es nicht weißt.\n\nKontext: {context}),
("human", "{question}")
])

# Hilfsfunktion: abgerufene Dokumente zu einem String verketten
def format_docs(docs):
return "\n".join(doc.page_content for doc in docs)

rag_chain = (
{"context": retriever | format_docs, "question": RunnablePassthrough()}
| rag_prompt
| llm
| StrOutputParser()
)

# --- 6. RAG testen ---
question = Was sind die Kernkomponenten von LangChain?
print(fFrage: {question})
print(fAntwort: {rag_chain.invoke(question)})

Erläuterung der technischen Kernpunkte von RAG:

FAISSEs ist Facebooks Open-Source-Bibliothek für Vektorähnlichkeitssuche, geeignet für lokale Entwicklung und Tests, wobei die Daten im Speicher gehalten werden.
ProduktionsumgebungEs wird empfohlen, professionelle Vektordatenbanken wie Pinecone, Milvus, Chroma und Weaviate zu verwenden, die Persistenz und verteilte Bereitstellung unterstützen.
Embedding-Modell: : Dieses Beispiel verwendet das HuggingFaceall-MiniLM-L6-v2Modell: wird beim ersten Ausführen automatisch heruntergeladen (ca. 80MB).
Wenn Sie einen OpenAI API Key haben, können Sie ihn ebenfalls verwenden.OpenAIEmbeddingsErzielt bessere chinesische Ergebnisse.
Empfohlen für chinesische Inlandsszenarien.BAAI/bge-small-zh-v1.5usw. chinesische Embedding-Modelle
chunk_sizeundchunk_overlapMüssen an die tatsächlichen Dokumenteigenschaften angepasst werden; zu groß kann die Präzision verringern, zu klein kann den Kontext verlieren.

5. Memory

Wichtiges Update:traditionelleConversationBufferMemoryEs ist relativ schwierig, es in komplexe LCEL-Ketten zu integrieren. Die neueste Empfehlung ist die Verwendung vonChatMessageHistoryZusammenarbeitRunnableWithMessageHistory。

KernlogikMemory ist keine Eigenschaft der Kette mehr, sondern ein unabhängiger Nachrichtenspeicher, durchsession_idZwischen verschiedenen Benutzern unterscheiden.
PersistenzUnterstützt das Speichern in Redis, PostgreSQL oder im Speicher.

6. Agenten

Agent ist eine der leistungsstärksten Funktionen von LangChain. Im Gegensatz zu Chain können Agenten auf Basis von Benutzereingaben handeln.Autonome EntscheidungsfindungWelche Tools aufgerufen und in welcher Reihenfolge ausgeführt werden, ist der wahre "Agent."

Kernschleife des Agenten: Aufgabe empfangen -> denken (Tool auswählen) -> Tool ausführen -> Ergebnis beobachten -> weiter denken oder endgültige Antwort geben.

Verwendung@toolDer Decorator kann jede Python-Funktion in ein von einem LLM aufrufbares Tool verwandeln. LangChain übergibt den Funktionsnamen und den Docstring automatisch an das Modell, sodass das Modell weiß, wann und wie es dieses Tool verwenden soll.

Nachfolgend ein vollständiges praktisches Agent-Beispiel mit drei Tools: Wetterabfrage, mathematische Berechnung und Wissenssuche:

Beispiel

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.tools import tool
from langchain.agents import AgentExecutor, create_tool_calling_agent

# Umgebungsvariablen laden
load_dotenv()

# DeepSeek-Modell initialisieren
llm = ChatOpenAI(
model=os.getenv('DEEPSEEK_MODEL', 'deepseek-v4-pro'),
openai_api_key=os.getenv('DEEPSEEK_API_KEY'),
openai_api_base=os.getenv('DEEPSEEK_BASE_URL', 'https://api.deepseek.com'),
)

# --- Tools definieren ---
# Mithilfe des @tool-Decorators informiert LangChain das Modell automatisch über Funktionsnamen und Docstring

@tool
def get_current_weather(city: str) -> str:
"""Ruft die aktuellen Wetterinformationen für eine angegebene Stadt ab. Verwenden Sie dieses Tool, wenn der Benutzer nach dem Wetter fragt."""
# In realen Anwendungen würde hier eine echte Wetter-API aufgerufen.
weather_data = {
"Beijing": "Sonnig, Temperatur 28°C, Luftfeuchtigkeit 45%",
"Shanghai": "Bewölkt, Temperatur 25°C, Luftfeuchtigkeit 70%",
"Shenzhen": "Gewitterschauer, Temperatur 30°C, Luftfeuchtigkeit 85%",
}
return weather_data.get(city, f"Entschuldigung, für {city} sind keine Wetterdaten verfügbar.")

@tool
def calculate(expression: str) -> str:
"""Berechnet mathematische Ausdrücke. Verwenden Sie dieses Tool, wenn der Benutzer mathematische Berechnungen durchführen muss.
Unterstützt die vier Grundrechenarten, z. B. '2 + 3 * 4'."""
import ast
import operator

# Sichere Operator-Zuordnung
ops = {
ast.Add: operator.add,
ast.Sub: operator.sub,
ast.Mult: operator.mul,
ast.Div: operator.truediv,
ast.Pow: operator.pow,
ast.USub: operator.neg,
}

def safe_eval(node):
if isinstance(node, ast.Expression):
return safe_eval(node.body)
elif isinstance(node, ast.Constant):
return node.value
elif isinstance(node, ast.BinOp):
left = safe_eval(node.left)
right = safe_eval(node.right)
return ops[type(node.op)](left, right)
elif isinstance(node, ast.UnaryOp):
operand = safe_eval(node.operand)
return ops[type(node.op)](operand)
else:
raise ValueError(f"Nicht unterstützter Ausdruckstyp: {type(node)}")

try:
tree = ast.parse(expression, mode='eval')
result = safe_eval(tree)
return f"Berechnungsergebnis: {expression} = {result}"
except Exception as e:
return f"Berechnungsfehler: {e}"

@tool
def search_knowledge(query: str) -> str:
"""Durchsucht die Wissensdatenbank, um relevante Informationen zu erhalten. Verwende dieses Tool, wenn der Benutzer Faktenfragen stellt."""
# In realen Anwendungen würde dies eine Verbindung zu einer Vektordatenbank oder Suchmaschine herstellen.
knowledge = {
"LangChain": LangChain ist ein Open-Source-Framework zum Erstellen von LLM-Anwendungen, das verkettete Aufrufe, Speicherverwaltung und Tool-Integration unterstützt.,
"Python": Python ist eine höhere Programmiersprache, die für ihre Einfachheit und Lesbarkeit bekannt ist und in KI, Datenwissenschaft und anderen Bereichen weit verbreitet ist.,
}
for key, value in knowledge.items():
if key.lower() in query.lower():
return value
return f"Es wurden keine Informationen zu '{query}' gefunden"

# --- Tool-Liste zusammenstellen ---
tools = [get_current_weather, calculate, search_knowledge]

# --- Agent-Prompt erstellen ---
prompt = ChatPromptTemplate.from_messages([
("system", Du bist ein leistungsstarker KI-Assistent, der Tools verwenden kann, um Benutzern zu helfen. Bestimme anhand der Frage des Benutzers, ob ein Tool benötigt wird, und wähle das am besten geeignete Tool aus, um Informationen zu erhalten.),
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
])

# --- Agent erstellen ---
agent = create_tool_calling_agent(llm, tools, prompt)

# --- AgentExecutor (Agent-Ausführer) erstellen ---
# verbose=True ermöglicht es, den vollständigen Denkprozess des Agenten zu sehen
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# --- Agent testen ---
# Test 1: Wetterabfrage
print("=" * 50)
response = agent_executor.invoke({"input": Wie ist das Wetter heute in Peking?})
print(f"\nEndgültige Antwort: {response['output']}")

# Test 2: Mathematikberechnung
print("\n" + "=" * 50)
response = agent_executor.invoke({"input": Hilf mir auszurechnen, was (15 * 37 + 228) / 3 ergibt})
print(f"\nEndgültige Antwort: {response['output']}")

# Test 3: Umfassende Frage (Agent muss entscheiden, welches Tool verwendet werden soll)
print("\n" + "=" * 50)
response = agent_executor.invoke({"input": Was ist LangChain? Hilf mir außerdem, 2 hoch 10 zu berechnen.})
print(f"\nEndgültige Antwort: {response['output']}")

Führe den obigen Code aus und du siehst(Chain-of-Thought-Ausgabe bei verbose=True):

==================================================

> Entering new AgentExecutor chain...
Invoking: `get_current_weather` with `{'city': '北京'}`

晴天，气温 28°C，湿度 45%

根据查询结果，北京今天的天气是晴天，气温 28°C，湿度 45%。

> Finished chain.

Final answer: 北京今天天气晴朗，气温 28°C，湿度 45%，适合外出活动。

==================================================

> Entering new AgentExecutor chain...
Invoking: `calculate` with `{'expression': '(15 * 37 + 228) / 3'}`

计算结果：(15 * 37 + 228) / 3 = 261.0

> Finished chain.

Final answer: (15 * 37 + 228) / 3 的计算结果是 261.0

==================================================

> Entering new AgentExecutor chain...
Invoking: `search_knowledge` with `{'query': 'LangChain'}`
Invoking: `calculate` with `{'expression': '2 ** 10'}`

LangChain 是一个用于构建 LLM 应用的开源框架...
计算结果：2 ** 10 = 1024

> Finished chain.

Final answer: LangChain 是一个用于构建 LLM 应用的开源框架，支持链式调用、记忆管理和工具集成。另外，2 的 10 次方等于 1024.

Sicherheitstipp:Dieses Beispiel verwendet sicheres AST-Parsing anstelle von eval(). In echten Projekten sollte eval() niemals direkt auf Benutzereingaben angewendet werden, da dies ein ernstes Risiko für die Remote-Codeausführung darstellt.

Den "Denkprozess" des Agenten verstehen:

verbose=TrueDadurch können wir die vollständige Entscheidungskette des Agenten sehen, was das Debuggen und Verstehen seines Verhaltens erleichtert.
Der Agent bestimmt automatisch, welche Tools aufgerufen werden, ohne dass die Aufrufreihenfolge manuell angegeben werden muss.
Wenn die Frage keine Tools erfordert (z. B. einfachen Small Talk), antwortet der Agent direkt mit seinem eigenen Wissen.
Bei komplexen Problemen kann der Agent Tools mehrmals aufrufen oder sogar mehrere Tools parallel aufrufen.

Schnellstart: Erstelle deine erste LangChain-Anwendung

Lass uns die Bequemlichkeit von LangChain an einem einfachen Beispiel erleben.

In der tatsächlichen Entwicklung können wir API-bezogene Informationen im Projektstammverzeichnis.envIn der Datei, zur bequemen Verwendung.

# .env 文件内容
DEEPSEEK_API_KEY=sk-xxx
DEEPSEEK_BASE_URL=https://api.deepseek.com
DEEPSEEK_MODEL=deepseek-v4-pro

Bei der Verwendung von LangChains ChatOpenAI wird empfohlen, openai_api_base als https://api.deepseek.com zu konfigurieren; /v1 muss nicht manuell hinzugefügt werden, LangChain fügt den Pfad automatisch zusammen.

Beispiel 1: Einfache Frage-und-Antwort-Kette

Beispiel

import os
from dotenv import load_dotenv
# Korrekter Importpfad
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

# Umgebungsvariablen laden
load_dotenv()

llm = ChatOpenAI(
model=os.getenv('DEEPSEEK_MODEL'),
openai_api_key=os.getenv('DEEPSEEK_API_KEY'),
openai_api_base=os.getenv('DEEPSEEK_BASE_URL'),
)

# Prompt-Vorlage erstellen
template = """
Du bist ein freundlicher Assistent.
Bitte beantworte die folgende Frage:

Frage: {question}
Antwort:
"""
prompt = PromptTemplate.from_template(template)

# Kette mit LCEL-Syntax erstellen (empfohlener Ansatz)
# Struktur: Prompt -> LLM -> zu String parsen
chain = prompt | llm | StrOutputParser()

# Kette ausführen
question = "Was ist LangChain? Was sind seine Hauptanwendungen?"

response = chain.invoke({"question": question})

print("Frage:", question)
print("-" * 20)
print("Antwort:", response)

Beispiel 2: Konversationskette mit Gedächtnis

Erstellen wir einen einfachen Chatbot, der sich den Gesprächsverlauf merken kann.

Beispiel

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

# 1. Konfiguration laden
load_dotenv()

# 2. DeepSeek-Modell initialisieren
llm = ChatOpenAI(
model=os.getenv('DEEPSEEK_MODEL', 'deepseek-v4-pro'),
openai_api_key=os.getenv('DEEPSEEK_API_KEY'),
openai_api_base=os.getenv('DEEPSEEK_BASE_URL', 'https://api.deepseek.com'),
)

# 3. Prompt-Vorlage definieren
# MessagesPlaceholder wird zur Laufzeit mit dem Gesprächsverlauf gefüllt
prompt = ChatPromptTemplate.from_messages([
("system", "Du bist ein hilfreicher KI-Assistent."),
MessagesPlaceholder(variable_name="history"),
("human", "{question}"),
])

# 4. Kette erstellen
chain = prompt | llm

# 5. Memory verwalten: Ein Dictionary erstellen, um Verlaufseinträge für verschiedene Benutzer zu speichern
store = {}

def get_session_history(session_id: str) -> BaseChatMessageHistory:
if session_id not in store:
store[session_id] = ChatMessageHistory()
return store[session_id]

# 6. Unsere Kette mit RunnableWithMessageHistory umschließen
# Auf diese Weise behandelt LangChain das Lesen und Aktualisieren von Verlaufseinträgen automatisch
with_message_history = RunnableWithMessageHistory(
chain,
get_session_history,
input_messages_key="question",
history_messages_key="history",
)

# 7. Gesprächsschleife betreten
print("--- DeepSeek-Chatmodus gestartet (zum Beenden 'exit' eingeben) ---")
session_config = {"configurable": {"session_id": "user_001"}} # IDs verschiedener Sitzungen unterscheiden

while True:
user_input = input("Du: ")
if user_input.lower() in ["exit", "quit", "exit"]:
break

# Kette mit Memory aufrufen
response = with_message_history.invoke(
{"question": user_input},
config=session_config
)

print(f"KI: {response.content}\n")

Wenn du den obigen Code ausführst, wirst du sehen：

--- 已进入 DeepSeek 聊天模式 (输入 'exit' 退出) ---
You: 你好
AI: 你好！很高兴见到你！ 有什么我可以帮助你的吗？无论是回答问题、聊天，还是协助解决问题，我都很乐意为你提供帮助！

You: 我叫小明
AI: 你好，小明！很高兴认识你！ 
如果你有任何问题、想法，或者需要帮助的地方，随时告诉我哦～

You: 我叫什么记得吗？
AI: 当然记得！你刚刚告诉我你叫**小明**～  
我会认真记住我们的对话内容，在之后的交流中尽量保持上下文连贯。不过如果对话过长或间隔太久，我可能需要你提醒一下哦～  
有什么想聊的或需要帮助的吗？

Zusammenfassung

Dieser Artikel stellt die Kernkonzepte und praktischen Anwendungen des LangChain-Frameworks vor. LangChain ermöglicht Entwicklern, durch standardisierte Komponenten und verkettete Aufrufe schnell leistungsstarke KI-Anwendungen zu erstellen.

Die folgende Tabelle fasst die in diesem Artikel behandelten Kernwissenspunkte zusammen:

Konzept	Beschreibung	Wichtiger Code
LCEL-Kette	Pipe-Operator \| verwenden, um Prompt, Model und Parser zu verbinden	`chain = prompt \| llm \| parser`
Prompt-Vorlage	Strukturierter Prompt, Unterscheidung zwischen System-/Benutzerrollen	`ChatPromptTemplate.from_messages()`
Streaming-Ausgabe	Wortweise Ausgabe zur Verbesserung der Benutzererfahrung	`chain.stream()`
Gesprächsgedächtnis	Mehrrunden-Gesprächsverlauf über session_id verwalten	`RunnableWithMessageHistory`
RAG – retrieval-augmentierte Generierung	Integration externen Wissens, um die Wissensgrenzen von LLMs zu durchbrechen	`retriever \| format_docs`
Agent	Autonome Entscheidungsfindung zum Aufrufen von Tools, die zentralste fortgeschrittene Funktion	`create_tool_calling_agent()`

Empfohlener Lernpfad

Weitere Erweiterungen

Agenten-Tools

Python-Implementierung von Agenten

LangChain Agents erstellen

Umgebungsvorbereitung

Beispiel

Beispiel

LCEL-Ketten erstellen (LangChain Expression Language)

Beispiel

Streaming-Ausgabe

Beispiel

Codestruktur

Prompt

LLM

OutputParser

Kernkomponenten erklärt

1. Modelle

2. Prompts

3. Chains & LCEL

4. Indizes & Retrieval

Beispiel

5. Memory

6. Agenten

Beispiel

Schnellstart: Erstelle deine erste LangChain-Anwendung

Beispiel 1: Einfache Frage-und-Antwort-Kette

Beispiel

Beispiel 2: Konversationskette mit Gedächtnis

Beispiel

Zusammenfassung

Empfohlener Lernpfad