LangChain, LangGraph, LangSmith und Langflow: Was jedes Tool leistet

Vier Namen aus einem Ökosystem tauchen immer wieder gemeinsam auf: LangChain, LangGraph, LangSmith und Langflow. Oft werden sie als konkurrierende Frameworks einsortiert, dabei übernimmt jedes eine eigene Aufgabe.

• LangChain liefert Bausteine wie Modell-Wrapper, Prompt-Vorlagen, Retriever, Tool-Anbindungen und Output-Parser.
• LangGraph führt Anwendungen aus, die Gedächtnis zwischen Schritten, Verzweigungen oder Schleifen brauchen.
• LangSmith beobachtet, was passiert ist, und bewertet es, in der Entwicklung wie in der Produktion.
• Langflow legt eine Drag-and-drop-Arbeitsfläche über dieselben Ideen.

LangChain für geradlinige Pipelines

LangChain verbindet ein Modell mit Prompts, Retrievern, Tools, Datenbanken und strukturierten Ausgaben. Wenn die Arbeit in eine Richtung fließt, von der Eingabe über ein paar Schritte zum Ergebnis, ist das meist der schnellste Weg. Installieren Sie es zusammen mit der OpenAI-Integration, importieren Sie eine Prompt-Vorlage und ein Chat-Modell, definieren Sie die Vorlage mit einer Systemzeile und einer Nutzerzeile samt Platzhalter für das Thema, und legen Sie ein kleines Modell mit Temperatur null fest, damit die Antworten reproduzierbar sind.

pip install langchain langchain-openai

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a concise technical writer."),
        ("user", "Explain {topic} in three bullet points."),
    ]
)

model = ChatOpenAI(
    model="gpt-4.1-mini",
    temperature=0,
)

Ein Pipe-Operator verbindet Vorlage und Modell zu einer Chain. Ruft man die Chain mit einem Dictionary samt Thema auf, kommt eine Antwort zurück, deren Text im Attribut content steht.

chain = prompt | model
response = chain.invoke(
    {"topic": "retrieval-augmented generation"}
)

print(response.content)

Vorlage und Modell bleiben getrennte Objekte, sodass sich beide austauschen lassen, während die Chain eine saubere Eingabeform bietet. Das passt für Integrationen, Retrieval, Tool-Aufrufe, das Zusammensetzen von Prompts und das Parsen von Ausgaben.

LangGraph, wenn der Ablauf entscheiden muss

LangGraph beschreibt eine Anwendung als Graphen. Knoten erledigen die Arbeit, Kanten legen fest, was als Nächstes läuft, und ein typisiertes State-Objekt wandert mit. Das lohnt sich, sobald die Ausführung verzweigen, Schleifen drehen, wiederholen, pausieren oder fortsetzen kann. Die Demo unten leitet eine Support-Frage weiter. Nach der Installation des Pakets importiert sie Typ-Hilfsmittel und die Graph-Grundbausteine.

pip install langgraph

from typing import Literal, TypedDict

from langgraph.graph import END, START, StateGraph

Der gemeinsame State enthält eine Frage, eine Kategorie und eine Antwort. Ein Knoten weist anhand des Fragetextes eine Kategorie zu, zwei weitere erzeugen die Antwort, einer für Abrechnungsfragen und einer für alles andere.

class SupportState(TypedDict):
    question: str
    category: str
    answer: str

def classify(state: SupportState) -> dict:
    question = state["question"].lower()
    category = (
        "billing"
        if "invoice" in question
        else "general"
    )
    return {"category": category}

def answer_billing(state: SupportState) -> dict:
    return {
        "answer": "I will help you review the invoice."
    }

def answer_general(state: SupportState) -> dict:
    return {
        "answer": "I will help you with your request."
    }

Ein kleiner Router gibt das Label zurück, das der Klassifikator gespeichert hat. Beim Zusammenbau werden die vier Knoten registriert und dann die Kanten ergänzt: Der Start führt zum Klassifikator, eine bedingte Kante verzweigt zum passenden Antwortknoten, und beide Antworten führen zum Ende.

def route(
    state: SupportState,
) -> Literal["billing", "general"]:
    return state["category"]

builder = StateGraph(SupportState)
builder.add_node("classify", classify)
builder.add_node("billing", answer_billing)
builder.add_node("general", answer_general)

builder.add_edge(START, "classify")
builder.add_conditional_edges("classify", route)
builder.add_edge("billing", END)
builder.add_edge("general", END)

Kompiliert man den Builder, erhält man einen ausführbaren Graphen. Gibt man ihm eine Frage zu einer Rechnung mit leerer Kategorie, landet die Anfrage im Abrechnungszweig, und die Ausgabe des Antwortfelds bestätigt, welcher Pfad gelaufen ist.

graph = builder.compile()

result = graph.invoke(
    {
        "question": "Why is my invoice higher?",
        "category": "",
        "answer": "",
    }
)

print(result["answer"])

Dieselbe Form lässt sich auf Tool-Schleifen, Checkpoints, kooperierende Agenten und Freigabeschritte durch Menschen ausdehnen, und genau dort zahlen sich dauerhafter State, Routing, Zyklen und Wiederholungen aus.

LangSmith, um zu sehen, was das System getan hat

LangSmith konkurriert nicht mit den beiden vorigen. Es macht ihr Verhalten sichtbar: Prompts, Modellaufrufe, Tool-Auswahl, Latenz, Fehler, Token-Zahlen und Kosten lassen sich im Nachhinein untersuchen. Die Einrichtung besteht aus zwei Umgebungsvariablen, eine schaltet das Tracing ein, die andere enthält den API-Schlüssel.

import os

os.environ["LANGSMITH_TRACING"] = "true"
os.environ["LANGSMITH_API_KEY"] = (
    "your-langsmith-api-key"
)
os.environ["LANGSMITH_PROJECT"] = (
    "agent-comparison-demo"
)

Der Schlüssel oben ist ein Platzhalter. Echte Zugangsdaten gehören in die Umgebung oder in einen Secrets-Manager, niemals in Quelldateien. Ist das Tracing aktiv, erscheinen unterstützte Aufrufe von LangChain und LangGraph im gewählten Projekt.

Für die Evaluierung bauen Sie einen Datensatz, der echtem Traffic ähnelt, und vergleichen Versionen nach Korrektheit, Faktentreue, Genauigkeit der Tool-Auswahl, Geschwindigkeit und Kosten. LangSmith eignet sich für Debugging, Regressionstests, Produktions-Traces, Monitoring und die Auswertung von Feedback.

Langflow zum Bauen auf einer Arbeitsfläche

Langflow ist eine visuelle Low-Code-Umgebung. Eingaben, Prompts, Modelle, Retriever, Vector Stores, Tools und Ausgaben werden auf eine Arbeitsfläche gezogen und verbunden. Das glänzt bei Experimenten, Demos, in der Lehre und in gemischten Teams.

Ein bereitgestellter Flow lässt sich per HTTP aufrufen. Der Client unten importiert os und requests, liest die Serveradresse aus einer Umgebungsvariablen mit dem lokalen Standardport als Rückfallwert und kapselt den Aufruf in einer Hilfsfunktion, die die Endpunkt-URL zusammensetzt.

import os

import requests

LANGFLOW_URL = os.getenv(
    "LANGFLOW_URL",
    "http://localhost:7860",
)
FLOW_ID = os.environ["LANGFLOW_FLOW_ID"]
API_KEY = os.environ["LANGFLOW_API_KEY"]

def run_flow(message: str) -> dict:
    url = (
        f"{LANGFLOW_URL}/api/v1/run/{FLOW_ID}"
    )
    headers = {"x-api-key": API_KEY}
    payload = {
        "input_value": message,
        "input_type": "chat",
        "output_type": "chat",
    }

Die Hilfsfunktion sendet die Nutzdaten per POST mit Headern und Timeout, prüft auf HTTP-Fehler und gibt den JSON-Body zurück. Ein Aufruf mit einer Vergleichsfrage gibt das strukturierte Ergebnis aus.

response = requests.post(
        url,
        headers=headers,
        json=payload,
        timeout=60,
    )
    response.raise_for_status()
    return response.json()

result = run_flow(
    "Compare LangChain and LangGraph."
)
print(result)

Die Konfiguration bleibt aus dem Quellcode heraus, Anfragen können nicht ewig hängen, und Fehler lösen Exceptions aus. Greifen Sie zu Langflow für visuelles Prototyping, wiederverwendbare Flows, Demos und schnellere Teamarbeit. Stark angepasste Produktionslogik lässt sich womöglich leichter als versionierter Python-Code pflegen.

Alle vier in einem Produkt

In einem Kundensupport-Agenten verbindet LangChain Modell, Prompt, Wissensbasis und Tools. LangGraph steuert Klassifizierung, Retrieval, Freigabe und Wiederholungen. LangSmith zeichnet jeden Schritt auf und bewertet Qualität, Geschwindigkeit und Kosten. Langflow bietet einen visuellen Entwurf, durch den sich Stakeholder klicken können.

Faustregeln:

• Lineare Pipeline: mit LangChain beginnen.
• State, Verzweigungen, Schleifen oder fortsetzbare Läufe: LangGraph hinzunehmen.
• Qualitätsnachweis: LangSmith einbinden.
• Schnelle visuelle Experimente: Langflow ausprobieren.

Keines ersetzt ein anderes. Eines liefert Komponenten, eines State und Routing, eines Beobachtbarkeit und Evaluierung und eines einen visuellen Weg, Flows zu bauen und bereitzustellen. Verwenden Sie die kleinste Kombination, die das Team noch verstehen, testen und der es vertrauen kann.