LangChain | JAVAPRO Germany

LangChain Requests, Prompt Tempates & Output Parser

Unsere LLM-Serie hat sich in den letzten drei Artikeln jeweils einem zentralen Thema beim programmatischen Zugriff auf Large Language Models gewidmet:

Wie kann ich via REST API Anfragen an eine LLM stellen?  Artikel Ollama REST API
Wie führe ich vollständige Chat-Verläufe mit einer LLM über den Context?  Artikel LLM Context
Wie stelle ich einer LLM Funktionen zur Verfügung, damit sie bessere Antworten erzeugen kann?  Artikel LLM Context und Tools

In all diesen Artikeln haben wir die Konzepte bewusst mit purem Python und Java implementiert – ganz ohne zusätzliche AI-Libraries. Die nächsten Artikel zeigen nun, wie sich dieselben Probleme mithilfe spezialisierter Bibliotheken eleganter und effizienter umsetzen lassen. Dieser und der nächste Artikel fokussieren sich auf die Implementierung in Python. Ein weiterer Artikel wird sich anschliessend den entsprechenden Java-Lösungen widmen.

Was ist Langchain

LangChain ist ein beliebtes Open-Source-Framework, das Entwicklern dabei hilft, Anwendungen die mit LLMs interagieren zu erstellen. Es bietet Abstraktionen, die es einfacher machen, komplexe Anwendungen zu erstellen, die KI-Modelle wie GPT-4, Claude oder andere LLMs verwenden.

Die Hauptidee hinter LangChain ist es, Entwicklern zu helfen, verschiedene Komponenten zu “verketten”, um anspruchsvolle KI-Workflows zu erstellen. Einige wichtige Funktionen umfassen:

Chains (Ketten) - Es können mehrere Aufrufe an LLMs oder andere Tools nacheinander verbunden werden, wobei die Ausgabe eines Schritts in den nächsten einfliesst.
Prompt-Vorlagen - Vorgefertigte Strukturen zur Erstellung effektiver Prompts, die es einfacher machen, konsistente Ergebnisse von LLMs zu erhalten.
Context - Mittels Context bekommen Anwendungen ein Gedächtnis für vergangene Gespräche oder Interaktionen, was für Chatbots und Assistenten nützlich ist.
Agenten - Werkzeuge, die es LLMs ermöglichen, Entscheidungen über zu ergreifende Massnahmen zu treffen, wie z.B. das Web zu durchsuchen, eine Datenbank abzufragen oder Berechnungen durchzuführen.
Integrationen - Verbindungen zu verschiedenen Datenquellen, APIs und Tools, damit LLM-Anwendungs mit externen Systemen interagieren können.

LangChain ist sowohl in Python als auch in JavaScript/TypeScript verfügbar.

Python Spezifika

Installation von Libraries

Für die Installation der LangChain Python-Libraries stehen zwei bewährte Wege zur Verfügung:

Der klassische Weg mit pip:

CODE

pip install -U langchain

Der moderne Weg mit uv:

CODE

uv add langchain

Hinweis: Das Repository zu diesem Artikel nutzt die uv-Variante.

API Keys

Für den Zugriff auf kommerzielle LLMs (Claude, OpenAI, Gemini) benötigt man einen API Key, der mit der eigenen Kreditkarte für die Bezahlung der Requests verknüpft ist. Es gibt zwei Möglichkeiten, diese API Keys in Python-Skripten verfügbar zu machen:

Möglichkeit 1: Environment Variablen

Unter macOS oder generell unter Unix-Systemen können die Keys im Konfigurationsfile der verwendeten Shell deklariert werden. Dabei muss YOUR_API_KEY durch den eigenen API Key ersetzt werden:

CODE

export ANTHROPIC_API_KEY=YOUR_API_KEY
export OPENAI_API_KEY=YOUR_API_KEY
export GEMINI_API_KEY=YOUR_API_KEY

Die API Keys stehen anschliessend automatisch im Python-Code zur Verfügung.

Möglichkeit 2: .env File

Python bietet die Möglichkeit, lokal im Projekt ein .env File zu erstellen und dort die API Keys zu deklarieren. Diese Keys sind dann nur für die Skripte in diesem spezifischen Projekt verfügbar.

CODE

ANTHROPIC_API_KEY=YOUR_API_KEY
OPENAI_API_KEY=YOUR_API_KEY
GEMINI_API_KEY=YOUR_API_KEY

Damit die Keys in Python sichtbar werden, ist etwas zusätzlicher Code erforderlich. Zur besseren Fehlerbehandlung kann geprüft werden, ob der API Key gefunden wurde, und im Fehlerfall eine entsprechende Meldung ausgegeben werden.

CODE

from dotenv import load_dotenv, find_dotenv
load_dotenv(find_dotenv())

if os.getenv("ANTHROPIC_API_KEY") is None:
    raise ValueError("ANTHROPIC_API_KEY not set")
else:
    print(f'ANTHROPIC_API_KEY loaded successfully: {os.getenv("ANTHROPIC_API_KEY")[:10]}...\n')

Ganz wichtig: Das .env File sollte nicht im Git eingecheckt werden !!!!

Requests mit LangChain

Abstraktion des Chat-Modells

LangChain bietet eine einheitliche Abstraktion für LLM- und Chat-Modelle. Die Grundlage bildet die Basisklasse BaseChatModel, die in der Bibliothek langchain_core definiert ist. Über die Methode invoke(“my_prompt”) lassen sich Anfragen an ein Language Model senden, wobei die Antwort als AIMessage-Objekt zurückgegeben wird.

Der User-Prompt wird dabei als String auf den input-Parameter gemappt.

CODE

 def invoke(self, input: LanguageModelInput,...) -> AIMessage:

Über AIMessage.content lässt sich die Textantwort extrahieren.

Vorteil dieser Abstraktion ist, dass für verschiedene LLMs konkrete Klassen existieren, die alle dasselbe Interface bereitstellen, jedoch intern unterschiedliche Implementierungen zur Kommunikation mit der jeweiligen LLM nutzen.

Ollama

Für den Zugriff auf Ollama wird die Klasse ChatOllama verwendet. ChatOllama erweitert BaseChatModel und ermöglicht dadurch eine elegante Kommunikation mit Ollama-Modellen – in diesem Beispiel mit llama3.1.

CODE

from langchain_ollama import ChatOllama
import tools

MODEL = "llama3.1"
chat_model = ChatOllama(model=MODEL)

response = chat_model.invoke(input = "What is LangChain? Please in max 1 sentences.")

print("---- Raw Output ----")
print(type(response))
print(response.content)

print("\n---- JSON Output ----")
print(tools.prettyfy_json(response))

print("\n---- Token Usage ----")
tools.print_token_usage(response)

Einige Details zum Code:

Die benötigte Funktionalität befindet sich in der langchain_ollama-Bibliothek.
Die Textantwort lässt sich über AIMessage.content extrahieren.
Die Antwort selbst enthält jedoch noch deutlich mehr Informationen, die sich mit der Hilfsmethode prettify_json() ausgeben lassen.
Mit der Hilfsmethode print_token_usage() kann man sich aus der Antwort die Anzahl der verwendeten Tokens (für die Anfrage und Antwort) ausgeben lassen.

Ollama liefert uns folgendes Resultat:

* LangChain is a Python library designed to make it easier to build conversational AI models, allowing developers to stack and compose different components, such as natural language understanding (NLU), text generation, and retrieval, to create more complex and powerful models.*

Die Token-Nutzung beträgt:

Prompt Tokens : 23
Completion Tokens: 51
Total Tokens : 74

Anthropic Claude

Der Code ist fast identisch mit dem Ollama Code. Für Claude wird einfach die Klasse ChatAnthropic verwendet (die auch wieder BaseChatModel erweitert).

Den Wert für den ANTHROPIC_API_KEY erhalten wir in diesem Beispiel über eine Umgebungsvariable.

CODE

from langchain_anthropic import ChatAnthropic
import tools

MODEL = "claude-sonnet-4-5-20250929"
chat_model = ChatAnthropic(
    model_name=MODEL,     
    temperature=0.3,        
    verbose=True, # set to False for production
)

response = chat_model.invoke("What is LangChain? Please in max 1 sentences.")

print("---- Raw Output ----")
print(type(response))
print(response.content)

print("\n---- JSON Output ----")
print(tools.prettyfy_json(response))

print("\n---- Token Usage ----")
tools.print_token_usage(response)

Zusätzlich haben wir (optional) den Parameter temperature übergeben. Aber was bedeutet der Parameter ’temperature’ in der ChatAnthropic-Klasse?

In LangChain steuert der Parameter temperature in der BaseChatModel (und somit auch in der ChatAnthropic) Klasse das Mass an Zufälligkeit bei der Antwortgenerierung des Modells.

Bei einem niedrigeren Wert (z.B. 0.3) liefert das Modell präzise und konsistente Antworten. Ein höherer Wert (z.B. 1.0) hingegen führt zu kreativeren und vielfältigeren Ausgaben.

Das Beispiel lässt sich so umschreiben, dass der Wert für den ANTHROPIC_API_KEY aus einer .env-Datei gelesen wird. Falls der API-Key nicht gefunden werden kann, wird ein Fehler ausgelöst.

CODE

import os
from langchain_anthropic import ChatAnthropic
import tools

from dotenv import load_dotenv, find_dotenv
load_dotenv(find_dotenv())

if os.getenv("ANTHROPIC_API_KEY") is None:
    raise ValueError("ANTHROPIC_API_KEY not set")
else:
    print(f'ANTHROPIC_API_KEY loaded successfully: {os.getenv("ANTHROPIC_API_KEY")[:10]}...\n')

MODEL = "claude-sonnet-4-5-20250929"
chat_model = ChatAnthropic(
    model_name=MODEL,     
    temperature=0.3,        
    verbose=True, # set to False for production
)

response = chat_model.invoke("What is LangChain? Please in max 1 sentences.")

print("---- Raw Output ----")
print(type(response))
print(response.content)

print("\n---- JSON Output ----")
print(tools.prettyfy_json(response))

print("\n---- Token Usage ----")
tools.print_token_usage(response)

OpenAI GPT-4

Der Code ist nahezu identisch. Für GPT-4 wird lediglich die Klasse ChatOpenAI verwendet (die ebenfalls BaseChatModel erweitert).

Den Wert für den OPENAI_API_KEY erhalten wir in diesem Beispiel über eine Umgebungsvariable.

CODE

from langchain_openai import ChatOpenAI
import tools

MODEL = "gpt-4o-mini"
chat_model = ChatOpenAI(
    model_name=MODEL,     
    temperature=0.3,        
    verbose=True, # set to False for production
)

response = chat_model.invoke("What is LangChain? Please in max 1 sentences.")

print("---- Raw Output ----")
print(type(response))
print(response.content)

print("\n---- JSON Output ----")
print(tools.prettyfy_json(response))

print("\n---- Token Usage ----")
tools.print_token_usage(response)

Google Gemini

Alles wie gehabt. Nur wird hier die Klasse ChatGoogleGenerativeAI (die wiederum BaseChatModel erweitert) verwendet.

CODE

from langchain_google_genai import ChatGoogleGenerativeAI
import tools

MODEL = "gemini-2.5-flash-lite"
chat_model = ChatGoogleGenerativeAI(
    model=MODEL,  # Note: parameter is 'model' not 'model_name'
    temperature=0.3,        
    verbose=True, # set to False for production
)

response = chat_model.invoke("What is LangChain? Please in max 1 sentences.")

print("---- Raw Output ----")
print(type(response))
print(response.content)

print("\n---- JSON Output ----")
print(tools.prettyfy_json(response))

print("\n---- Token Usage ----")
tools.print_token_usage(response)

Prompt Templates

In den vorherigen Beispielen haben wir jeweils ein Chat-Modell erstellt und anschliessend dessen invoke()-Methode mit dem Prompt als Parameter aufgerufen.

Für komplexere Prompts bietet LangChain eine weitere Abstraktionsebene: die Prompt Templates. Hierbei werden Modell und Prompt als separate Objekte erstellt und dann zu einer Chain miteinander verkettet.

Der Prompt-String kann dabei Platzhalter enthalten, für die beim Aufruf von invoke() konkrete Werte übergeben werden.

CODE

prompt = ChatPromptTemplate.from_template(string_with_placeholder) 
chat_model = ….
chain = prompt | chat_model
response = chain.invoke({"key":"value"})

Ein Beispiel verdeutlicht dies: Die Anfrage an die LLM lautet “Was ist die Farbe Rot?”. Wenn wir anschliessend wissen möchten, was die Farbe Blau ist, müssen wir dafür keine neue Chain erstellen. Stattdessen bauen wir einmalig eine Chain mit Modell und Prompt Template auf und können diese dann mit verschiedenen Werten für die Farbe aufrufen.

CODE

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

MODEL = "gpt-4o-mini"
chat_model = ChatOpenAI(
    model_name=MODEL,     
    temperature=0.3,        
    verbose=True,  
)

template = "Give me a brief summary about the color {color}."

prompt = ChatPromptTemplate.from_template(template)

chain = prompt | chat_model
print(f'Type of Chain: {type(chain)}')

response_red = chain.invoke({"color":"red"})
print(response_red.content)

response_blue = chain.invoke({"color":"blue"})
print(response_blue.content)

Wir erhalten folgende Antworten:  

The color red is a vibrant and powerful hue often associated with strong emotions and concepts. It symbolizes passion, love, and desire …

The color blue is often associated with calmness, serenity, and stability. It is frequently linked to the sky and the ocean, evoking feelings of tranquility and peace …

Im LangChain-Kontext bieten Prompt Templates folgende Vorteile:

Wiederverwendbarkeit und Wartbarkeit – Prompts werden einmal mit variablen Platzhaltern definiert und können anschliessend in der gesamten Anwendung wiederverwendet werden.
Dynamisches Einfügen von Inhalten – Templates ermöglichen eine saubere Trennung zwischen statischer Prompt-Struktur und dynamischen Variablen, was den Code deutlich lesbarer macht.
Komposition und Standardisierung – Templates lassen sich nahtlos mit anderen LangChain-Komponenten (wie Output-Parsern etc.) kombinieren, wodurch komplexe Prompts systematisch aufgebaut werden können – anstatt auf einfache String-Verkettung zurückzugreifen.

Output Parser

Mit Hilfe eines Output Parsers kann in LangChain die rohe Antwort einer LLM in ein strukturiertes, für die Weiterverarbeitung geeignetes Format transformiert werden.

LLMs geben standardmässig Text zurück (als AIMessage-Objekt). Output Parser wandeln diesen Text in ein gewünschtes Format um, z.B.:

String – nur der reine Textinhalt
Liste – kommaseparierte Werte
JSON/Dictionary – strukturierte Daten
Pydantic-Modelle – typsichere Objekte

Output Parser bieten folgende Vorteile:

Typsicherheit – man erhält genau das Format, das erwartet wird
Automatische Validierung – Parser prüfen, ob die LLM-Antwort dem gewünschten Schema entspricht
Konsistenz – einheitliche Datenstrukturen in der Anwendung
Chain-Komposition – Parser lassen sich nahtlos in Chains integrieren

Praktische Beispiele: String, Liste und JSON Output Parser

String Output Parser

Die Chain lässt sich durch einen Output Parser vom Typ StrOutputParser erweitern. Dadurch wird die Antwort des Large Language Models direkt als String zurückgegeben.

—- Output as String —- 
Type of response:  <class str>
The first five prime numbers are 2, 3, 5, 7, and 11.

CODE

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

MODEL = "gpt-4o-mini"
chat_model = ChatOpenAI(
    model_name=MODEL,     
    temperature=0.3,        
    verbose=True,    
)

template = "Give me the first {number} prime numbers."

prompt = ChatPromptTemplate.from_template(template)

output_parser = StrOutputParser()

chain = prompt | chat_model | output_parser

response_as_string = chain.invoke({"number":5})

print("\n---- Output as String ----")
print(f'Type of response: {type(response_as_string)}')
print(response_as_string)

List Output Parser

Die Chain lässt sich durch einen Output Parser vom Typ CommaSeparatedListOutputParser erweitern. Wichtig dabei: Die LLM muss explizit angewiesen werden, eine Liste zurückzugeben.

Der CommaSeparatedListOutputParser bietet hierfür die hilfreiche Methode get_format_instructions(), die automatisch die passenden Formatierungsanweisungen generiert. Diese zusätzlichen Instruktionen werden über den Parameter format_instructions im Prompt übergeben. Die Antwort des Models wird dann direkt als Liste zurückgegeben.

—- Output as List —- 
Type of response: <class list>
 [‘2’, ‘3’, ‘5’, ‘7’, ’11’]

CODE

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

MODEL = "gpt-4o-mini"
chat_model = ChatOpenAI(
    model_name=MODEL,     
    temperature=0.3,        
    verbose=True,    
)

template = """
Give me the first {number} prime numbers.

{format_instructions}
"""

prompt = ChatPromptTemplate.from_template(template)

output_parser = CommaSeparatedListOutputParser()

chain = prompt | chat_model | output_parser

response_as_list = chain.invoke({
    "number":5,
    "format_instructions": output_parser.get_format_instructions()
    })

print("\n---- Output as List ----")
print(f'Type of response: {type(response_as_list)}')
print(response_as_list)

JSON Output Parser

Die Chain lässt sich durch einen Output Parser vom Typ JsonOutputParser erweitern. Auch hier muss die LLM explizit angewiesen werden, die Antwort im JSON-Format zurückzugeben.

Der JsonOutputParser bietet hierfür die hilfreiche Methode get_format_instructions(), die automatisch die erforderlichen Formatierungsanweisungen generiert. Diese Instruktionen werden über den Parameter format_instructions im Prompt übergeben, sodass die Antwort des Models direkt als strukturiertes JSON-Objekt zurückgegeben wird.

—- Output as JSON —- 
Type of response: <class dict>
 {‘prime_numbers’: [2, 3, 5, 7, 11], ‘sum’: 28}

CODE

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

MODEL = "gpt-4o-mini"
chat_model = ChatOpenAI(
    model_name=MODEL,     
    temperature=0.3,        
    verbose=True,    
)

template = """
Give me the first {number} prime numbers and sum of them.

{format_instructions}
"""

prompt = ChatPromptTemplate.from_template(template)

output_parser = JsonOutputParser()

chain = prompt | chat_model | output_parser

response_as_json = chain.invoke({
    "number":5,
    "format_instructions": output_parser.get_format_instructions()
    })

print("\n---- Output as JSON ----")
print(f'Type of response: {type(response_as_json)}')
print(response_as_json)

Pydantic Output Parser

Mit dem Pydantic Output Parser lässt sich die Strukturierung von LLM-Antworten auf die nächste Stufe heben. Das Tool ermöglicht es uns, präzise zu definieren, in welchem Format das Resultat einer LLM-Anfrage zurückgegeben werden soll. Der Parser verarbeitet die Antwort des Sprachmodells und befüllt automatisch die von uns vordefinierte Datenstruktur.

Praktisches Beispiel

Betrachten wir folgendes Szenario: Wir stellen die Frage „What are the most popular programming libraries for accessing LLMs?" und möchten dabei zwei Parameter übergeben – die gewünschte Programmiersprache sowie die Anzahl der Resultate.

Vorgehensweise:

*1) Definition der Datenstruktur*
Zunächst definieren wir die Datenstruktur für unsere Resultate. Dabei interessieren uns folgende Informationen zu den verschiedenen Libraries:

Name der Library
Provider (Hersteller)
URL zur Dokumentation oder zum Repository
Unterstützte Programmiersprachen
Aktuelle Version

CODE

class LibraryOutput(BaseModel):
    name: str = Field(description="name of a library")
    provider: str = Field(description="provider of the library")
    url: str = Field(description="URL of the library")
    language: str = Field(description="programming language of the library")
    version: str = Field(description="version of the library")

Die Klasse enthält Felder für alle relevanten Daten und muss von BaseModel abgeleitet werden. Die Beschreibung mittels Field(description="…") ist optional, dient jedoch als wertvolle Dokumentation für den Code und verbessert die Lesbarkeit.

Da wir pro Programmiersprache mehrere Resultate erhalten möchten, benötigen wir zusätzlich eine Liste von LibraryOutput-Objekten:

CODE

class LibrariesOutput(BaseModel):
    libraries: list[LibraryOutput] = Field(description="list of libraries")

*2) Erstellung des Parsers*
Bei der Instanziierung des Output Parsers (vom Typ PydanticOutputParser) wird die zuvor definierte Datenstruktur als Parameter übergeben:

CODE

parser = PydanticOutputParser(pydantic_object=LibrariesOutput)

3) Erstellung des Prompts

Der Prompt muss mit präzisen Formatierungsinstruktionen versehen werden, damit das LLM die gewünschte Struktur zurückliefert. Eine beispielhafte Implementation könnte folgendermassen aussehen:

CODE

messages = [
    ("system", "What are the most popular programming libraries for accessing LLMs?  Please use the following schema {format_instructions}"),
    ("user", "Programming Language: {programming_language}, Number of Libraries: {library_count}")
]

# output parser
parser = PydanticOutputParser(pydantic_object=LibrariesOutput)

prompt_template = ChatPromptTemplate.from_messages(messages=messages).partial(format_instructions=parser.get_format_instructions())

Vollständiges Beispiel

Das folgende Code-Beispiel zeigt die Integration aller zuvor beschriebenen Komponenten:

CODE

from langchain_core.prompts import ChatPromptTemplate
from langchain_groq import ChatGroq
from langchain_core.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field

from dotenv import load_dotenv, find_dotenv
load_dotenv(find_dotenv())
    

# define output schema
class LibraryOutput(BaseModel):
    name: str = Field(description="name of a library")
    provider: str = Field(description="provider of the library")
    url: str = Field(description="URL of the library")
    language: str = Field(description="programming language of the library")
    version: str = Field(description="version of the library")


class LibrariesOutput(BaseModel):
    libraries: list[LibraryOutput] = Field(description="list of libraries")


def print_result(result: LibrariesOutput) -> None:
    print(result)
    libraries = result.model_dump()["libraries"]
    for library in libraries:
        print(f"Name: {library['name']}")
        print(f"Provider: {library['provider']}")
        print(f"Language: {library['language']}")
        print(f"Version: {library['version']}")
        print(f"Url: {library['url']}")
        print("- "*30)

# define prompt template with format instructions (to be filled in by the parser)
messages = [
    ("system", "What are the most popular programming libraries for accessing LLMs?  Please use the following schema {format_instructions}"),
    ("user", "Programming Language: {programming_language}, Number of Libraries: {library_count}")
]

# output parser
parser = PydanticOutputParser(pydantic_object=LibrariesOutput)

prompt_template = ChatPromptTemplate.from_messages(messages=messages).partial(format_instructions=parser.get_format_instructions())

MODEL_NAME = "openai/gpt-oss-120b"
model = ChatGroq(model=MODEL_NAME)

# define the chain
chain = prompt_template | model | parser

inputs = {
    "programming_language": "Python",
    "library_count": 5
}
result: LibrariesOutput = chain.invoke(input=inputs)
print_result(result)

Als Antwort erhalten wir direkt ein LibrariesOutput Objekt mit 5 LibraryOutput Objekten:

CODE

libraries=[
    LibraryOutput(name='openai', provider='OpenAI', url='https://github.com/openai/openai-python', language='Python', version='1.30.0'), 
    LibraryOutput(name='transformers', provider='Hugging Face', url='https://github.com/huggingface/transformers', language='Python', version='4.41.0'), 
    LibraryOutput(name='langchain', provider='LangChain', url='https://github.com/langchain-ai/langchain', language='Python', version='0.2.5'), LibraryOutput(name='cohere', provider='Cohere', url='https://github.com/cohere-ai/cohere-python', language='Python', version='5.2.0'), LibraryOutput(name='anthropic', provider='Anthropic', url='https://github.com/anthropics/anthropic-sdk-python', language='Python', version='0.23.0')
    LibraryOutput(name='cohere', provider='Cohere', url='https://github.com/cohere-ai/cohere-python', language='Python', version='5.2.0'), 
    LibraryOutput(name='anthropic', provider='Anthropic', url='https://github.com/anthropics/anthropic-sdk-python', language='Python', version='0.23.0')
    ]

Fazit

LangChain ist ein Open-Source-Framework, das die Entwicklung von LLM-Anwendungen vereinfacht, indem es verschiedene Komponenten wie Prompts, Chat-Modelle und Output Parser elegant miteinander verkettet.

Die zentrale Abstraktion bildet die BaseChatModel-Klasse, die eine einheitliche Schnittstelle für verschiedene LLMs (Ollama, Claude, GPT-4, Gemini) bereitstellt und über die invoke()-Methode aufgerufen wird. Prompt Templates ermöglichen die Wiederverwendung von Prompts mit Platzhaltern, während Output Parser (String, Liste, JSON, Pydantic) die rohen LLM-Antworten in strukturierte, typsichere Formate transformieren.

Der Artikel demonstriert die praktische Implementierung anhand konkreter Code-Beispiele und zeigt, wie sich durch die Verkettung von Prompt Templates, Chat-Modellen und Output Parsern robuste, wartbare LLM-Workflows erstellen lassen.

Im nächsten Beitrag knüpfen wir an unsere früheren Artikel an und zeigen, wie LangChain das Management von LLM-Context und die Tool-Integration elegant umsetzt.

Was ist Langchain

Python Spezifika

Installation von Libraries

API Keys

Requests mit LangChain

Abstraktion des Chat-Modells

Ollama

Anthropic Claude

OpenAI GPT-4

Google Gemini

Prompt Templates

Output Parser

Praktische Beispiele: String, Liste und JSON Output Parser

String Output Parser

List Output Parser

JSON Output Parser

Pydantic Output Parser

Praktisches Beispiel

Fazit

Links

Mehr aus dem Magazin

LLM-Context und Tools

LLM Context

Ollama Rest API

Remote LLMs