LangChain: LLM-Anwendungen über einfache API-Aufrufe hinaus orchestrieren

Der Fortschritt leistungsfähiger KI-Modelle (Large Language Models) führt dazu, dass der Aufbau praxisnaher Anwendungen häufig eine Orchestrierung erfordert, die über reine, direkte API-Requests hinausgeht. LangChain ist ein Open-Source-Framework für Python, das darauf abzielt, jede Phase des LLM-App-Lebenszyklus zu vereinfachen. Es stellt einheitliche Schnittstellen für Chat-Modelle, Embeddings, Vektor-Stores sowie Integrationen mit hunderten Anbietern bereit.

In diesem Beitrag zeigen wir, warum KI-Anwendungen von Frameworks wie LangChain profitieren. Wir erläutern, wie LangChain funktioniert, welche zentralen Bausteine es gibt und welche typischen Einsatzszenarien sich ergeben. Außerdem vergleichen wir LangChain mit ähnlichen Tools (unter anderem LlamaIndex und Haystack) und enden mit einer einfachen Python-Demo.

Zentrale Erkenntnisse

• LangChain ist ein modulares, Open-Source-Python-Framework, das den Aufbau fortgeschrittener LLM-Anwendungen erleichtert. Es bietet standardisierte Interfaces für Modelle, Embeddings, Vektor-Stores, Tools und Memory.
• Es reduziert die Integrationskomplexität, sodass Entwickler praktisch jedes LLM (z. B. OpenAI, Anthropic, Hugging Face) mit externen Datenquellen, APIs und eigenen Tools verbinden können – mit minimalen Code-Anpassungen.
• LangChain liefert wiederverwendbare Bausteine wie Chains, Agents, Memory, Tools und Indexes. Damit lassen sich komplexe, mehrstufige KI-Workflows, Chatbots, RAG-Pipelines und autonome Agents umsetzen.
• Die Installation ist unkompliziert, und die kompakten Python-APIs eignen sich für schnelles Prototyping, Experimente und die Bereitstellung realer KI-Anwendungen.
• Das Framework unterstützt das flexible Wechseln und Orchestrieren zwischen Modell-Providern und Backends. Zusätzlich kann es mit Alternativen wie LlamaIndex (Retrieval) und Haystack (Search-Pipelines) zu hybriden Lösungen kombiniert werden.

Was ist LangChain?

LangChain ist eine allgemeine Schnittstelle, um mit nahezu jedem LLM zu arbeiten. Es dient als zentrale Schaltstelle für die Entwicklung LLM-getriebener Anwendungen. Das Projekt startete Ende 2022 durch Harrison Chase und Ankush Gola und entwickelte sich schnell zu einem der am häufigsten genutzten Open-Source-KI-Projekte.

Vereinfacht gesagt unterstützt dich LangChain dabei, generative KI-Anwendungen (Chatbots, virtuelle Assistenten, individuelle Frage-Antwort-Systeme und mehr) zu erstellen, indem es fertige Module und APIs für gängige LLM-Aufgaben bereitstellt (Prompt-Templates, Modellaufrufe, Vektor-Embeddings und Ähnliches). Dadurch müssen Entwickler nicht jedes Mal das Rad neu erfinden. LangChain folgt dabei einem klaren Grundsatz: LLMs müssen mit den passenden Daten und Tools verknüpft werden. Als vortrainierte statistische Modelle fehlen ihnen oft aktuelle Fakten oder spezielles Domänenwissen. LangChain kann ein LLM (wie GPT-4) mit externen Quellen verbinden (Datenbanken, Dokumente, Web-APIs oder sogar deinem eigenen Code). Dadurch kann das Modell mit Echtzeit- und Kontextinformationen antworten.

Beispielsweise könnte ein LangChain-basierter Chatbot bei einer Nutzerfrage zunächst interne Unternehmensdokumente abrufen oder eine Wetter-API aufrufen, um aktuelle Daten zu beziehen, bevor er antwortet.

Ohne ein Framework müsstest du für jede Funktion die Integrationslogik von Grund auf entwickeln. LangChains Architektur nimmt dir diese Details ab, indem sie eine standardisierte Schnittstelle für den Aufruf beliebiger LLMs bereitstellt – inklusive Muster für Data Retrieval und Action Tools. So wird es deutlich einfacher, unterschiedliche Modelle auszuprobieren oder mehrere Modelle innerhalb einer Anwendung zu kombinieren.

Zentrale Bausteine: Chains, Agents, Memory, Tools, Indexes

LangChain bringt mehrere Kernbausteine für LLM-Anwendungen mit. Zusammengenommen ermöglichen sie den Aufbau anspruchsvoller KI-Workflows:

Chains

Eine Chain ist eine Abfolge von Schritten (jeder Schritt kann ein LLM-Call, ein Datenabruf oder eine andere Aktion sein), bei der das Ergebnis eines Schritts als Eingabe für den nächsten dient. LangChain bietet eine solide Grundlage, um solche Chains in Python (oder JavaScript) zu definieren und auszuführen. Zusätzlich gibt es mehrere integrierte Chain-Typen:

• LLMChain (Deprecated but not yet removed): Der ursprüngliche „einfachste“ Chain-Typ, der einen Prompt und einen LLM-Call kapselt (Frage stellen, Antwort erhalten). LLMChain ist zugunsten flexiblerer Ansätze wie RunnableSequence und der LangChain Expression Language (LCEL) als deprecated markiert.
• SimpleSequentialChain: Eine Chain, bei der die Ausgabe eines Schritts direkt als Eingabe in den nächsten Schritt fließt.
• SequentialChain: Eine erweiterte Variante von SimpleSequentialChain, die Verzweigungen oder mehrere Ein-/Ausgaben unterstützen kann – praktisch für komplexere Workflows.
• RouterChain: Eine Chain, die anhand der Eingabe entscheidet, welche Sub-Chain ausgeführt wird (im Prinzip ein if/else bzw. switch für Chains).

Du kannst beispielsweise eine Chain erstellen, die Text ins Französische übersetzt und anschließend zusammenfasst. Genauso ließe sich eine Chain denken, die aus Nutzereingaben die wichtigsten Informationen extrahiert, eine database quer erstellt und anschließend das Ergebnis nutzt, um dem Nutzer zu antworten. Durch das Aufteilen in kleinere LLM-Aufrufe unterstützen Chains schrittweises, nachvollziehbares Vorgehen.

Agents

Ein Agent ist ein LLM-gesteuertes Programm, das eigenständig entscheidet, welche Schritte als Nächstes sinnvoll sind. Es beobachtet die Unterhaltung oder die Nutzeranfrage, „denkt“ über ein oder mehrere LLM-Calls nach und legt dann fest, welche Aktionen bzw. Tools in welcher Reihenfolge ausgeführt werden. Tools können z. B. ein Rechner, eine Suchmaschine, ein Code-Interpreter, eine eigene API und vieles mehr sein.

LangChain enthält unter anderem diese Agent-Typen:

• ZeroShotAgent: Ein Agent, der das React-Framework (Reflection + Action) nutzt, um ohne beispielbasierte Aktionen die nächste Handlung zu bestimmen.
• ConversationalAgent: Ein Chatbot-ähnlicher Agent, der den Gesprächsverlauf mitführt und Tools im Dialog einsetzt (z. B. Fragen mithilfe einer Suche beantworten).
• Plan-and-Execute Agents: Ein neuerer und robusterer Ansatz: Statt einer großen Chain plant der Agent zunächst eine Schrittfolge (über ein LLM) und arbeitet sie anschließend nacheinander ab. Das ist besonders hilfreich bei komplexen Aufgaben mit mehrstufiger Recherche oder Argumentation.

Note: Agent-Typen wie ZeroShotAgent und ConversationalAgent sind seit Version 0.1.0 deprecated. Für neue Projekte wird LangGraph zur Agent-Orchestrierung empfohlen. LangGraph ist flexibler, unterstützt zustandsbehaftete Ausführung und bietet fortgeschrittenere Orchestrierungsfunktionen.

Zum Beispiel könnte ein LangChain-Agent eine Nutzeranfrage interpretieren, erkennen, dass eine Wikipedia-Suche nötig ist, einen API-Call ausführen, die Ergebnisse abrufen und daraus eine formatierte Antwort erstellen.

Hier ist ein Python-artiges LangChain-Agent-Beispiel (vereinfacht, mit Kernlogik) unter Verwendung der modernen LangChain-API. Das Beispiel zeigt einen Agent, der das passende Tool auswählt, die answe ermittelt und eine Antwort formuliert.

Note: Du musst langchain, langchain-openai, langchain-community und openai installieren. Stelle sicher, dass du deinen OpenAI API key hast. Das Wikipedia-Tool, DuckDuckGo Search und das Requests-Tool stammen aus langchain_community.tools.

# Install required packages (run this in your terminal, not in the script)
# pip install langchain langchain-openai langchain-community openai

import os
from langchain_openai import OpenAI
from langchain.agents import initialize_agent, AgentType
from langchain_community.tools import WikipediaQueryRun, DuckDuckGoSearchRun, RequestsGetTool
from langchain_community.utilities import WikipediaAPIWrapper

# 0. Set your OpenAI API key (recommended: set as environment variable)
os.environ["OPENAI_API_KEY"] = "your-openai-api-key-here"  # Replace with #your actual OpenAI API key

# 1. Set up the LLM and tools
llm = OpenAI(model="gpt-3.5-turbo-instruct", temperature=0)
wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())  # No API key needed for Wikipedia
web_search = DuckDuckGoSearchRun()
api_tool = RequestsGetTool()

# 2. Add all tools to the agent
tools = [wikipedia, web_search, api_tool]

agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,  # ReAct-style agent
    verbose=True
)

# 3. User input
user_query = "What's the latest news about NASA on Wikipedia and the web? Also, fetch the NASA API homepage."

# 4. Agent workflow: will pick the right tool for each part of the request
response = agent.run(user_query)
print(response)

Der Agent interpretiert die mehrteilige Nutzeranfrage, wählt die passenden Tools (Wikipedia für enzyklopädische Informationen, DuckDuckGo für aktuelle News, RequestsGetTool für API-Abrufe) und führt die Ergebnisse in einer Antwort zusammen.

AgentType.ZERO_SHOT_REACT_DESCRIPTION legt fest, wie ein ReAct-ähnlicher Agent aufgebaut wird, der darüber „nachdenken“ kann, welches Tool für welchen Teil einer Anfrage eingesetzt werden soll.

Memory

Im Unterschied zu einem einzelnen LLM-Call müssen viele Anwendungen (z. B. Chatbots) Kontext aus früheren Interaktionen behalten. LangChains Memory-Module speichern Chat-Verläufe, Zusammenfassungen oder andere Zustände. Für jeden neuen Prompt wird der relevante Teil aus dem Memory abgerufen und als Kontext eingebunden.

Zu den am häufigsten genutzten Memory-Typen gehören:

• ConversationBufferMemory: Speichert die komplette Konversationshistorie in einem fortlaufenden Buffer (alle Nachrichten).
• ConversationBufferWindowMemory: Speichert nur die letzten N Nachrichten. Dieses „Fenster“ verschiebt sich mit dem Gespräch und ist sinnvoll, wenn die komplette Historie zu lang wird (Kontextlängen-Limit).
• ConversationSummaryMemory: Ähnlich wie ConversationBufferMemory, aber statt alle Nachrichten direkt zu speichern, wird eine fortlaufende Zusammenfassung der bisherigen Interaktionen geführt. Das hilft, die wesentlichen Punkte langer Gespräche zu verdichten.
• VectorStore-backed Memory: Speichert Fakten oder Embeddings in einer Vektor-Datenbank und ermöglicht dadurch Langzeit-Memory sowie semantische Suche über reine „letzte Nachrichten“ hinaus.

Weitere Optionen sind ConversationSummaryBufferMemory (Mix aus Buffer und Summary) sowie EntityStoreMemory (Entity-Tracking). Wenn du jedoch ein neues Projekt startest, sind neuere Patterns zur Memory-Verwaltung wie RunnableWithMessageHistory oft die bessere Wahl, weil sie mehr Flexibilität und Kontrolle ermöglichen.

Beispielsweise kann eine Chatbot-Chain frühere Dialogturns abrufen, um die Unterhaltung stimmig fortzuführen. Das erlaubt Kontext über längere Chats hinweg – entscheidend für konsistente Multi-Turn-Antworten.

Key Notes:

• Der Nutzer sendet eine Nachricht, die im Memory abgelegt wird.
• Der Chatbot greift auf das Memory zu, um Kontinuität und Kohärenz zu sichern.
• Falls nötig, nutzt der Chatbot externe Tools, um vor der Antwort Informationen einzuholen.

Tools

In LangChain ist ein Tool jede externe Funktion oder API, die ein Agent aufrufen kann

LangChain bringt viele integrierte Tools mit, zum Beispiel:

• Web search API (SerpAPI) – das LLM kann damit eine Internet-Suche anstoßen.
• Python REPL – Python-Code ausführen (nützlich für Mathe, Datenmanipulation etc.).
• Database query tools – z. B. Verbindung zu einer SQL-Datenbank herstellen und Abfragen ausführen.
• Browser or Scraper – Webseiten navigieren (oft via Playwright oder ähnlichen Wrappern).
• Calculator – ein einfacher Mathe-Auswerter.
• …und viele weitere; außerdem kannst du eigene Tools definieren (jede Python-Funktion kann zu einem Tool werden).

Tools ermöglichen es dem LLM, Daten zu beziehen oder Aktionen auszuführen, die über Trainingsdaten und reine Modellfähigkeiten hinausgehen. Beim Ausführen eines Agents kann das LLM eine „action“ ausgeben, die festlegt, welches Tool mit welchem Input gestartet werden soll. Das hilft, Halluzinationen zu reduzieren und Antworten an echte Daten zu binden.

Indexes (Vector Stores)

Viele LangChain-Anwendungen nutzen Retrieval-Augmented Generation, bei der Antworten des LLMs in einem Dokumentenkorpus verankert werden. Um RAG zu ermöglichen, integriert LangChain Vektor-Datenbanken (auch Vector Stores genannt), die Dokumente über Embeddings indexieren. Ein Vector Store erlaubt add_documents(…) und anschließend eine Similarity Search anhand eines Query-Embeddings.

In der Praxis kannst du PDFs/Webseiten/usw. in einen LangChain-kompatiblen Vector Store laden. Wenn das LLM relevante Fakten benötigt, ruft LangChain die ähnlichsten Dokumente ab. Diese „Indexes“ liefern schnelle semantische Suche über große Textbestände. LangChain unterstützt mehrere Vector-DB-Backends (z. B. Pinecone, Weaviate, Chroma usw.) über eine gemeinsame Schnittstelle.

LangChain basiert auf einer modularen, geschichteten Architektur. Jede Ebene übernimmt eine klar definierte Aufgabe, wodurch sich LLM-basierte Anwendungen effizient entwerfen, erweitern und skalieren lassen. Dieser Aufbau erleichtert es, Workflows anzupassen und auf unterschiedliche Produktionsanforderungen auszurichten. Das Ökosystem ist in folgende Bestandteile gegliedert:

Kernschichten der Architektur

langchain-core: Dieses Paket enthält die grundlegenden Abstraktionen des Frameworks, darunter LLM-Interfaces, Prompts, Messages und das zugrunde liegende Runnable-Interface. Es definiert die essenziellen Bausteine, auf denen alle höheren LangChain-Funktionen aufsetzen.

Integration Packages: Für jeden unterstützten LLM-Provider oder externen Dienst (z. B. OpenAI, Google, Redis und weitere) stellt LangChain ein eigenes Integrationspaket bereit (etwa langchain-openai, langchain-google, langchain-redis). Diese leichten Adapter kapseln Provider-APIs und machen sie als standardisierte LangChain-Komponenten nutzbar.

langchain (Meta-Package): Dieses Meta-Paket bündelt vorgefertigte Chains, Agents und Retrieval-Pipelines. Wer LangChain installiert, erhält das Core-Framework zusammen mit den beliebtesten Funktionen zur Orchestrierung von LLM-Workflows.

langchain-community: Dieses Paket enthält Integrationen und Connectoren aus der Community. Es dient als gemeinschaftlicher Raum, in dem Support für neue Datenbanken, APIs und Drittanbieter-Tools entsteht, um LangChains Integrationen zu erweitern.

LangGraph: LangGraph bietet eine flexible Orchestrierungsschicht für fortgeschrittene Szenarien. Damit lassen sich zustandsbehaftete, streaming-fähige, produktionsreife LLM-Anwendungen erstellen, indem mehrere Chains und Agents mit Persistenz und starkem State-Management koordiniert werden. Obwohl eng mit LangChain verbunden, kann LangGraph auch eigenständig für komplexe Workflows und Orchestrierungsanforderungen genutzt werden.

In der Praxis installieren Entwickler meist LangChain und importieren anschließend nur die benötigten Komponenten. Beispielsweise befinden sich Chains in langchain.chains, Agents in langchain.agents, und es gibt eigene Subpackages für Models, Embeddings, Memory und mehr. Eine große Stärke von LangChain ist, dass Provider-spezifische Unterschiede abstrahiert werden. Dadurch kann dein Code durch Anpassung der Modellkonfiguration unkompliziert zwischen OpenAI, Anthropic, Azure, Hugging Face und weiteren Providern wechseln.

Wechsel zwischen LLM-Providern

Das folgende grundlegende Python-Beispiel zeigt, wie unkompliziert sich mit LangChain zwischen verschiedenen LLM-Providern umschalten lässt:

# Install: pip install langchain langchain-openai langchain-anthropic

import os
from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain.prompts import ChatPromptTemplate

# 1. Set your API key(s)
# For OpenAI:
os.environ["OPENAI_API_KEY"] = "your-openai-api-key-here"  # Replace with #your OpenAI API key

# For Anthropic (if you want to use Claude):
os.environ["ANTHROPIC_API_KEY"] = "your-anthropic-api-key-here"  # Replace #with your Anthropic API key

# 2. Choose a model provider (swap between OpenAI and Anthropic)
# Uncomment one of the following lines depending on the provider you want to #use:

llm = ChatOpenAI(model="gpt-3.5-turbo")  
# llm = ChatAnthropic(model="claude-3-opus")

# 3. Create a prompt template
prompt = ChatPromptTemplate.from_template("Tell me a fun fact about {topic}.")

# 4. Compose the chain using the chaining operator
chain = prompt | llm

# 5. Run the chain with user input
response = chain.invoke({"topic": "space"})
print(response.content)

Key Notes

• Für OpenAI-Modelle verwende ChatOpenAI aus langchain_openai.
• Für Anthropic-Modelle verwende ChatAnthropic aus langchain_anthropic.
• Nutze chain.invoke() für synchrone Ausführung.
• Der Provider-Wechsel erfolgt, indem du eine einzelne Zeile änderst, die das llm definiert.
• API-Keys (z. B. OPENAI_API_KEY, ANTHROPIC_API_KEY) müssen als Environment-Variablen gesetzt oder an den Model-Constructor übergeben werden.

Beliebte Einsatzfälle

LangChain wurde dafür entwickelt, Entwicklern und technischen Entscheidern zu helfen, schnell und effizient LLM-basierte Anwendungen für reale Herausforderungen zu bauen. Häufige Use Cases lassen sich wie folgt zusammenfassen:

Retrieval-Augmented Question Answering (RAG)

Erstelle Q&A-Systeme, die in deinen eigenen Daten verankert sind, Halluzinationen reduzieren und Antworten aktuell halten. LangChain unterstützt Document Loader, Text Splitter, Embeddings, Vector-Store-Retriever und RetrievalQA-Chains – inklusive Integrationen für Pinecone, FAISS und mehr. Das Ergebnis sind genaue, überprüfbare Antworten mit dynamischen Updates, ohne Modelle neu trainieren zu müssen.

Chatbots und Conversational Agents

Baue zustandsbehaftete Chatbots mit vollständigem Verlauf, Memory sowie Streaming- und Persona-Unterstützung. Mit RunnableWithMessageHistoy, Memory-Modulen und Prompt-Templates entsteht kontextreicher Dialog und kohärentes, persona-getriebenes Conversation-Management.

Autonome Agents

Entwickle Agents, die mehrstufige Workflows eigenständig planen und ausführen und dabei das Memory vorheriger Schritte behalten. Plan-and-Execute Agents, ReAct Agents, Agent-Loop-Frameworks und Memory ermöglichen Planung, Tool-Ausführung und Laufzeit-Anpassung in autonomen Abläufen.

Data Q&A und Zusammenfassung

Ermögliche Natural-Language-Queries oder Summaries über PDFs, Spreadsheets, Artikel und mehr, inklusive schrittweiser Verarbeitung über Dokumente. Mit Document Loadern, Text Splittern, Embeddings und Chain-of-thought-Prompts wird die effiziente Bearbeitung langer Texte durch hierarchische Zusammenfassung und Q&A unterstützt.

Kurz gesagt: Wenn deine LLM-Anwendung mehrere Schritte verketten muss, externe Daten integrieren soll oder Konversationskontext bewahren muss, stellt LangChain passende Komponenten bereit. Die obigen Beispiele sind nicht abschließend – Entwickler kombinieren LangChain-Bausteine fortlaufend auf neue Weise und bauen damit ganz neue Anwendungstypen.

LangChain vs. Alternativen

Nachfolgend findest du einen Vergleich zwischen LangChain und zwei weit verbreiteten Alternativen, LlamaIndex und Haystack, um besser einschätzen zu können, welches Tool am besten zu deinem Projekt passt:

LlamaIndex (formerly GPT Index)

LlamaIndex ist speziell für RAG ausgelegt: Es bietet einfache APIs, um Daten zu laden, Vektor-Indexes zu bauen und effizient zu befragen. Stärke: sehr schnelle Dokumentenrecherche und Suche mit minimaler Konfiguration. LangChain vs LlamaIndex: Während LangChain bei agentischen, mehrstufigen Workflows und LLM-Orchestrierung glänzt (z. B. Chatbots, Assistenten, Pipelines), ist LlamaIndex stärker auf Retrieval und semantische Suche fokussiert. LlamaIndex erweitert zwar Workflows und Agent-Support, doch LangChain bleibt die flexiblere Option für komplexe, multi-komponentige Anwendungen.

Haystack

Haystack ist ein robustes Python-Framework für NLP und RAG: Es begann als Extractive-QA-Tool und unterstützt heute Pipelines für Search, Retrieval und Generation. Stärke: High-Level-Interface, ideal für suchzentrierte oder produktionsreife Retrieval-Systeme. LangChain vs Haystack: LangChain bietet tiefere Agent-Tools, bessere Composability und individuelleren Agent-Entwurf. Haystacks „Haystack Agents“ bringen mehrstufiges Reasoning, dennoch bleibt LangChain flexibler für stark maßgeschneiderte agentische Systeme. Hybrid Approach: Viele Teams kombinieren LangChains Agent-Orchestrierung mit Haystacks Retrievern oder Pipelines und nutzen so die Vorteile beider Ökosysteme.

Other Tools

Weitere Tools sind beispielsweise Microsoft Semantic Kernel, OpenAI Function Calling und mehr. Viele davon konzentrieren sich auf spezielle Szenarien wie Search oder Dialog-Orchestrierung. LangChain advantage: die größte Sammlung wiederverwendbarer Agents, Chains und Orchestrierungs-Primitiven, die echte End-to-End-LLM-Anwendungen und schnelles Prototyping für komplexe Workflows ermöglichen.

Wichtig ist: Jedes Tool hat eigene Stärken. Oft können Entwicklungsteams sie gemeinsam nutzen, um von fortgeschrittener Retrieval-Funktionalität und flexibler Orchestrierung zu profitieren. Berücksichtige Komplexität und Ziele deines Projekts bei der Tool-Auswahl (und scheue dich nicht vor einem Hybrid-Ansatz, wenn er sinnvoll ist).

Erste Schritte mit LangChain in Python

Diese Schritt-für-Schritt-Anleitung zeigt den Einstieg mit LangChain in Python – von der Installation bis zur ersten Demo.

1. Voraussetzungen

Bevor du startest, stelle sicher, dass du Folgendes in deiner Umgebung hast:

• Python 3.8 oder höher
• pip (Python package manager)
• (Optional, aber empfohlen) Eine virtuelle Umgebung zur Verwaltung von Abhängigkeiten

2. Installation

Öffne dein Terminal oder die Eingabeaufforderung und installiere das Core-LangChain-Paket mit folgendem Befehl:

pip install langchain

Um mit OpenAI-Modellen und anderen beliebten Providern zu arbeiten, installierst du zusätzlich das passende Integrationspaket. Für OpenAI lautet der Befehl:

pip install langchain-openai

Dank des modularen Ansatzes installierst du nur die Integrationen, die du wirklich benötigst.

3. API-Key einrichten

Option 1: Als Environment-Variable setzen.

Unter macOS/Linux:

export OPENAI_API_KEY="your_openai_api_key_here"

Unter Windows:

set OPENAI_API_KEY="your_openai_api_key_here"

Option 2: Eine .env-Datei nutzen (empfohlen für lokale Entwicklung):

Installiere python-dotenv:

pip install python-dotenv

Lege eine .env-Datei in deinem Projektverzeichnis an:

OPENAI_API_KEY=your_openai_api_key_here

Füge am Anfang deines Python-Skripts Folgendes ein:

from dotenv import load_dotenv
load_dotenv()

4. Eine einfache LangChain-Demo ausführen

Betrachte das folgende Minimalbeispiel mit OpenAIs GPT-3.5 Turbo Instruct Modell:

# If using a .env file, load environment variables
from dotenv import load_dotenv
load_dotenv()

from langchain_openai import OpenAI
from langchain_core.prompts import PromptTemplate

# Create a prompt template
prompt = PromptTemplate.from_template("Answer concisely: {query}")

# Initialize the OpenAI LLM
llm = OpenAI(model="gpt-3.5-turbo-instruct", temperature=0)

# Compose the chain
chain = prompt | llm

# Run the chain with a sample query
answer = chain.invoke({"query": "What is LangChain used for?"})
print(answer)

Key Points

• Imports: Verwende langchain_openai für OpenAI-Modelle und langchain_core.prompts für Prompt-Templates.
• PromptTemplate: Definiert die Struktur deines Prompts mit Platzhaltern.
• Chaining: Der |-Operator verbindet den Prompt direkt mit dem Modell.
• Invocation: Rufe chain.invoke() mit deinem Input auf, um eine Antwort zu erhalten.

LangChain übernimmt die API-Calls und das Formatting im Hintergrund. Du musst keine eigenen HTTP-Requests schreiben oder Conversation-Tokens manuell verwalten. Wenn du deine App ausbaust, kannst du zusätzliche Chains, tool-gestützte Agents oder eine Memory-Komponente integrieren. Dennoch zeigt schon diese Basisdemo, wie kompakt LangChain-Code sein kann.

Fazit

LangChain ist ein leistungsfähiges, modulares Framework, das den Aufbau anspruchsvoller LLM-getriebener Anwendungen erleichtert. Durch die komponentenbasierte Architektur, die umfangreichen Bausteine und die vielen Integrationen lassen sich Sprachmodelle bequem mit externen Daten, Tools und Workflows verbinden.

Egal, ob du einen Chatbot, einen RAG-gestützten Assistenten oder ein komplexes Multi-Agent-System entwickelst: LangChain liefert die Grundlage und Flexibilität, um KI-Projekte umzusetzen. Während das Ökosystem wächst, kann es außerdem mit Tools wie LlamaIndex und Haystack kombiniert werden, um die Fähigkeiten deiner Anwendung zu erweitern.