Chatbot mit LangChain erstellen: Praxis-Tutorial fur Entwickler

LangChain hat sich als eines der wichtigsten Frameworks fur die Entwicklung von KI-Anwendungen etabliert. In diesem Tutorial zeigen wir Ihnen, wie Sie einen funktionsfahigen Chatbot erstellen - von der Installation bis zur Produktionsreife.

Was ist LangChain?

LangChain ist ein Open-Source-Framework, das die Entwicklung von Anwendungen mit Large Language Models (LLMs) vereinfacht. Es bietet standardisierte Schnittstellen fur verschiedene LLMs, Werkzeuge fur Prompt-Management und Komponenten fur komplexe Anwendungen wie Chatbots mit Gedachtnis oder RAG-Systeme.

Kernkonzepte

• Models - Einheitliche Schnittstelle fur verschiedene LLMs (OpenAI, Anthropic, lokale Modelle)
• Prompts - Templates und Management fur Eingabeaufforderungen
• Chains - Verkettung mehrerer Operationen zu komplexen Workflows
• Memory - Speicherung von Konversationskontext
• Agents - Autonome KI, die Werkzeuge nutzen kann

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Sie folgende Komponenten installiert haben:

• Python 3.9+ - Die Programmiersprache fur unser Projekt
• pip - Pythons Paketmanager
• Ollama - Fur lokale LLM-Ausfuhrung (optional, empfohlen)
• Git - Fur Versionskontrolle

Projektstruktur erstellen

mkdir langchain-chatbot
cd langchain-chatbot
python -m venv venv
source venv/bin/activate  # Linux/Mac
# oder: venv\Scripts\activate  # Windows

Abhangigkeiten installieren

pip install langchain langchain-community
pip install langchain-ollama  # Fur lokale Modelle
pip install streamlit  # Fur die Web-Oberflache

Schritt 1: Einfacher Chatbot

Beginnen wir mit einem minimalen Chatbot, der grundlegende Konversationen ermoglicht:

# chatbot_basic.py
from langchain_ollama import OllamaLLM
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

# LLM initialisieren (lokales Modell mit Ollama)
llm = OllamaLLM(model="llama3.2")

# Prompt-Template definieren
prompt = ChatPromptTemplate.from_messages([
    ("system", "Du bist ein hilfreicher Assistent. Antworte auf Deutsch."),
    ("human", "{input}")
])

# Chain erstellen
chain = prompt | llm | StrOutputParser()

# Einfache Interaktion
while True:
    user_input = input("Sie: ")
    if user_input.lower() in ['exit', 'quit', 'bye']:
        break
    response = chain.invoke({"input": user_input})
    print(f"Bot: {response}\n")

Schritt 2: Chatbot mit Gedachtnis

Ein echter Chatbot muss sich an den Gesprachsverlauf erinnern. LangChain bietet dafur verschiedene Memory-Typen:

# chatbot_memory.py
from langchain_ollama import OllamaLLM
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.memory import ConversationBufferMemory
from langchain.schema.runnable import RunnablePassthrough

llm = OllamaLLM(model="llama3.2")

# Memory initialisieren
memory = ConversationBufferMemory(
    return_messages=True,
    memory_key="history"
)

# Prompt mit History-Platzhalter
prompt = ChatPromptTemplate.from_messages([
    ("system", "Du bist ein hilfreicher Assistent. Antworte auf Deutsch."),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])

# Chain mit Memory
def get_history(input_dict):
    return memory.load_memory_variables({})["history"]

chain = (
    RunnablePassthrough.assign(history=get_history)
    | prompt
    | llm
)

# Konversationsschleife
while True:
    user_input = input("Sie: ")
    if user_input.lower() in ['exit', 'quit']:
        break

    response = chain.invoke({"input": user_input})

    # Konversation speichern
    memory.save_context(
        {"input": user_input},
        {"output": response}
    )

    print(f"Bot: {response}\n")

Memory-Typen

• ConversationBufferMemory - Speichert alle Nachrichten (fur kurze Konversationen)
• ConversationBufferWindowMemory - Behalt nur die letzten N Nachrichten
• ConversationSummaryMemory - Erstellt Zusammenfassungen alter Nachrichten
• ConversationTokenBufferMemory - Begrenzt nach Token-Anzahl

Schritt 3: RAG-fahiger Chatbot

Fur Unternehmen besonders interessant: Ein Chatbot, der auf eigenen Dokumenten basiert. Mit RAG (Retrieval-Augmented Generation) kann der Bot Fragen zu Ihren Unternehmensdaten beantworten:

# chatbot_rag.py
from langchain_ollama import OllamaLLM, OllamaEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain.prompts import ChatPromptTemplate
from langchain_community.document_loaders import DirectoryLoader

# Dokumente laden
loader = DirectoryLoader('./docs', glob="**/*.txt")
documents = loader.load()

# Dokumente aufteilen
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
splits = text_splitter.split_documents(documents)

# Embeddings und Vektordatenbank
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma.from_documents(
    documents=splits,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# Retriever erstellen
retriever = vectorstore.as_retriever(
    search_kwargs={"k": 3}
)

# LLM und Prompt
llm = OllamaLLM(model="llama3.2")
prompt = ChatPromptTemplate.from_template("""
Beantworte die Frage basierend auf dem folgenden Kontext.
Wenn die Antwort nicht im Kontext zu finden ist, sag das ehrlich.

Kontext: {context}

Frage: {question}

Antwort:""")

# RAG-Chain
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

from langchain.schema.runnable import RunnablePassthrough

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

# Nutzung
question = "Was steht in den Dokumenten uber Projektmanagement?"
answer = rag_chain.invoke(question)
print(answer)

Schritt 4: Web-Oberflache mit Streamlit

Fur eine benutzerfreundliche Oberflache konnen wir Streamlit verwenden:

# app.py
import streamlit as st
from langchain_ollama import OllamaLLM
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.memory import ConversationBufferWindowMemory

st.title("KI-Chatbot")
st.caption("Powered by LangChain & Ollama")

# Session State initialisieren
if "messages" not in st.session_state:
    st.session_state.messages = []
if "memory" not in st.session_state:
    st.session_state.memory = ConversationBufferWindowMemory(
        k=10, return_messages=True
    )

# LLM initialisieren
@st.cache_resource
def get_llm():
    return OllamaLLM(model="llama3.2")

llm = get_llm()

# Chat-Historie anzeigen
for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.markdown(message["content"])

# Benutzereingabe
if prompt := st.chat_input("Ihre Nachricht..."):
    st.session_state.messages.append({"role": "user", "content": prompt})
    with st.chat_message("user"):
        st.markdown(prompt)

    # Bot-Antwort generieren
    with st.chat_message("assistant"):
        with st.spinner("Denke nach..."):
            chat_prompt = ChatPromptTemplate.from_messages([
                ("system", "Du bist ein hilfreicher Assistent."),
                MessagesPlaceholder(variable_name="history"),
                ("human", "{input}")
            ])

            history = st.session_state.memory.load_memory_variables({})
            response = (chat_prompt | llm).invoke({
                "input": prompt,
                "history": history.get("history", [])
            })

            st.markdown(response)

    st.session_state.messages.append({"role": "assistant", "content": response})
    st.session_state.memory.save_context({"input": prompt}, {"output": response})

Starten Sie die Anwendung mit:

streamlit run app.py

Best Practices fur Produktion

1. Prompt Engineering

Die Qualitat Ihrer Prompts bestimmt massgeblich die Qualitat der Antworten:

• Klare Rolle definieren - Was ist die Aufgabe des Chatbots?
• Einschrankungen setzen - Was darf/soll der Bot nicht tun?
• Ausgabeformat spezifizieren - Wie sollen Antworten strukturiert sein?
• Beispiele geben - Few-Shot-Learning durch Beispieldialoge

2. Fehlerbehandlung

from langchain.callbacks import get_openai_callback
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def safe_invoke(chain, input_data):
    try:
        return chain.invoke(input_data)
    except Exception as e:
        logger.error(f"Chain invocation failed: {e}")
        return "Entschuldigung, es ist ein Fehler aufgetreten."

3. Monitoring und Logging

• Anfragen loggen - Fur Debugging und Verbesserung
• Latenz messen - Performance uberwachen
• Token-Verbrauch tracken - Bei Cloud-APIs kostenkritisch
• Feedback sammeln - Nutzerbewertungen fur Optimierung

Deployment und Skalierung für Unternehmen

Ein Chatbot, der auf dem eigenen Laptop läuft, ist ein guter Prototyp. Für den Unternehmenseinsatz brauchen Sie jedoch eine robuste Infrastruktur. Hier sind die wichtigsten Aspekte für ein produktives Deployment.

API-basiertes Deployment mit FastAPI

Statt Streamlit als Frontend können Sie Ihren Chatbot als REST-API bereitstellen und in bestehende Systeme integrieren:

# api.py
from fastapi import FastAPI
from pydantic import BaseModel
from langchain_ollama import OllamaLLM
from langchain.prompts import ChatPromptTemplate

app = FastAPI()
llm = OllamaLLM(model="llama3.2")

class ChatRequest(BaseModel):
    message: str
    session_id: str = "default"

@app.post("/chat")
async def chat(request: ChatRequest):
    prompt = ChatPromptTemplate.from_messages([
        ("system", "Du bist ein hilfreicher Assistent."),
        ("human", "{input}")
    ])
    chain = prompt | llm
    response = chain.invoke({"input": request.message})
    return {"response": response}

Hardware-Empfehlungen

Die Leistung Ihres Chatbots hängt maßgeblich von der Hardware ab. Für den Unternehmenseinsatz empfehlen wir:

• Kleine Modelle (7-8B) - Mindestens eine NVIDIA RTX 4090 oder A6000 mit 24GB VRAM
• Mittlere Modelle (13-30B) - Zwei GPUs oder eine A100 mit 40-80GB VRAM
• Große Modelle (70B+) - Mehrere A100 oder H100 GPUs für optimale Leistung

Unsere On-Premise-KI-Server sind speziell für den Betrieb lokaler LLMs konfiguriert und bieten die nötige Rechenleistung für mehrere gleichzeitige Nutzer.

Nächste Schritte

Sie haben nun einen funktionierenden Chatbot. Für den Produktionseinsatz empfehlen wir:

• Modell-Auswahl optimieren - Testen Sie verschiedene lokale Modelle wie Llama 3.2, Mistral oder Qwen
• Skalierung planen - Für mehrere gleichzeitige Nutzer GPU-Server einsetzen
• Sicherheit implementieren - Authentifizierung, Rate Limiting, Input Validation
• Integration erweitern - Anbindung an Unternehmenssysteme via APIs und Webhooks

Häufig gestellte Fragen

Kann ich einen LangChain-Chatbot ohne Cloud-Dienste betreiben?

Ja, mit Ollama können Sie lokale LLMs wie Llama 3.2 oder Mistral nutzen. LangChain abstrahiert die LLM-Schnittstelle, sodass Sie problemlos zwischen Cloud-APIs und lokalen Modellen wechseln können. Für den Unternehmenseinsatz empfehlen wir On-Premise-GPU-Server für optimale Leistung und volle Datenkontrolle - keine Daten verlassen Ihr Netzwerk.

Was ist RAG und warum ist es für Unternehmens-Chatbots wichtig?

RAG (Retrieval-Augmented Generation) ermöglicht es einem Chatbot, auf unternehmensspezifische Dokumente zuzugreifen. Statt nur auf sein Trainingswissen zurückzugreifen, durchsucht der Bot eine Vektordatenbank mit Ihren Dokumenten und nutzt die relevanten Informationen für seine Antwort. So erhalten Sie präzise, aktuelle Antworten basierend auf Ihren eigenen Daten - ideal für interne Wissensdatenbanken, Kundensupport und Dokumentenmanagement.

Welche LLMs eignen sich am besten für einen LangChain-Chatbot?

Für lokale Ausführung empfehlen sich Llama 3.2 (8B oder 70B Parameter), Mistral und Qwen. Für Cloud-Nutzung sind GPT-4o und Claude die leistungsstärksten Optionen. Die Wahl hängt von Ihren Anforderungen ab: Bei Datenschutzanforderungen und Kostensensibilität sind lokale Modelle vorzuziehen, bei maximaler Antwortqualität die großen Cloud-Modelle.

Wie skaliert man einen LangChain-Chatbot für viele Nutzer?

Für Skalierung empfehlen wir GPU-Server mit ausreichend VRAM für parallele Inferenz, Load Balancing zwischen mehreren Modellinstanzen, Caching häufiger Anfragen mit Redis und asynchrone Verarbeitung. Frameworks wie FastAPI in Kombination mit LangChain eignen sich gut für produktive Deployments. Unsere KI-Beratung unterstützt Sie bei der Architekturplanung.