LangChain Chatbot: Python-Anleitung für Einsteiger

TL;DR

LangChain ist das meistgenutzte Python-Framework für KI-Chatbots mit eigenen Datenquellen. Diese Anleitung führt Einsteiger in 90 Minuten vom leeren Terminal zum funktionierenden RAG-Chatbot. Der Bot durchsucht Firmendokumente und beantwortet Fragen kontextbezogen. Voraussetzung: Grundlegende Python-Kenntnisse. Kosten: €0 mit lokalem Ollama-Modell oder €15/Monat mit Azure OpenAI.

Warum LangChain für den Mittelstand

Python-Entwickler im Mittelstand stehen vor einer praktischen Frage: Wie baue ich einen Chatbot, der nicht nur allgemeines Wissen wiedergibt, sondern Firmendokumente, Produktkataloge und interne Prozesse kennt?

LangChain löst genau dieses Problem. Das Open-Source-Framework verbindet ein Sprachmodell (LLM) mit eigenen Datenquellen zu einer RAG-Pipeline (Retrieval-Augmented Generation). Die Architektur ist modular: LLM, Vektor-Datenbank und Dokumentenlader sind austauschbar. Ob lokales Ollama-Modell oder Azure OpenAI als Backend, der Code bleibt identisch.

LangChain dominiert das Feld durch die größte Auswahl an Integrations und die aktivste Community. Für Einsteiger ist es der pragmatischste Einstiegspunkt.

Schritt 1: Umgebung einrichten (10 Minuten)

# Voraussetzungen und Installation
voraussetzungen:
  python: ">=3.10"
  betriebssystem: "Linux, macOS, Windows"
  ram: "8 GB (16 GB empfohlen)"
  festplatte: "5 GB frei"

installation:
  # Virtuelle Umgebung erstellen
  venv_erstellen: "python -m venv chatbot-env"
  venv_aktivieren_linux: "source chatbot-env/bin/activate"
  venv_aktivieren_windows: "chatbot-env\\Scripts\\activate"

  # LangChain und Abhängigkeiten
  pakete: >
    pip install langchain langchain-community langchain-core
    langchain-openai chromadb sentence-transformers
    pypdf python-docx unstructured

  # Optional: Ollama fuer lokales LLM
  ollama_installieren: "curl -fsSL https://ollama.ai/install.sh | sh"
  ollama_modell: "ollama pull llama3.1:8b"

Wer Ollama noch nicht kennt, findet in unserer Ollama Modelfile Anleitung eine detaillierte Einführung.

Schritt 2: Einfacher Chatbot ohne RAG (15 Minuten)

# chatbot_basic.py - Minimaler LangChain Chatbot
code_beschreibung: "Einfacher Chatbot mit Ollama oder Azure OpenAI"

# Option A: Lokales Modell (Ollama)
ollama_setup:
  import: "from langchain_community.llms import Ollama"
  initialisierung: "llm = Ollama(model='llama3.1:8b')"
  aufruf: "antwort = llm.invoke('Was ist LangChain?')"

# Option B: Azure OpenAI
azure_setup:
  import: "from langchain_openai import AzureChatOpenAI"
  initialisierung: |
    llm = AzureChatOpenAI(
      azure_endpoint="https://firma.openai.azure.com/",
      api_key="AZURE_KEY",
      api_version="2024-10-21",
      deployment_name="gpt-4o-prod"
    )
  aufruf: "antwort = llm.invoke('Was ist LangChain?')"

# Chat mit Verlauf (Konversation)
chat_mit_verlauf:
  imports:
    - "from langchain_core.messages import HumanMessage, SystemMessage"
    - "from langchain_core.chat_history import InMemoryChatMessageHistory"

  system_prompt: >
    Du bist ein hilfreicher Assistent fuer ein deutsches
    Mittelstandsunternehmen. Antworte praezise und auf Deutsch.

  ablauf:
    - "history = InMemoryChatMessageHistory()"
    - "history.add_message(SystemMessage(content=system_prompt))"
    - "history.add_message(HumanMessage(content=frage))"
    - "antwort = llm.invoke(history.messages)"

Dieser Basis-Chatbot beantwortet allgemeine Fragen. Für unternehmensrelevante Antworten fehlt ihm jedoch der Zugriff auf Firmendaten. Das löst RAG.

Schritt 3: RAG-Pipeline mit Firmendokumenten (30 Minuten)

RAG erweitert den Chatbot um eine Dokumentensuche. Bei jeder Frage werden zuerst relevante Textpassagen aus den Firmendokumenten gefunden und dann als Kontext an das LLM übergeben.

# rag_chatbot.py - LangChain RAG Pipeline
pipeline_schritte:

  1_dokumente_laden:
    beschreibung: "PDF, DOCX und TXT aus einem Verzeichnis laden"
    imports:
      - "from langchain_community.document_loaders import DirectoryLoader"
      - "from langchain_community.document_loaders import PyPDFLoader"
    code: |
      loader = DirectoryLoader(
        './firmendokumente/',
        glob='**/*.pdf',
        loader_cls=PyPDFLoader
      )
      dokumente = loader.load()

  2_dokumente_splitten:
    beschreibung: "Texte in suchbare Chunks aufteilen"
    import: "from langchain.text_splitter import RecursiveCharacterTextSplitter"
    code: |
      splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=200,
        separators=['\n\n', '\n', '.', ' ']
      )
      chunks = splitter.split_documents(dokumente)

  3_vektordatenbank_erstellen:
    beschreibung: "Chunks vektorisieren und in ChromaDB speichern"
    imports:
      - "from langchain_community.embeddings import HuggingFaceEmbeddings"
      - "from langchain_community.vectorstores import Chroma"
    code: |
      embeddings = HuggingFaceEmbeddings(
        model_name='sentence-transformers/all-MiniLM-L6-v2'
      )
      vectorstore = Chroma.from_documents(
        documents=chunks,
        embedding=embeddings,
        persist_directory='./chroma_db'
      )

  4_rag_chain_erstellen:
    beschreibung: "LLM mit Dokumentensuche verbinden"
    imports:
      - "from langchain.chains import RetrievalQA"
      - "from langchain_core.prompts import PromptTemplate"
    prompt_template: |
      Beantworte die Frage basierend auf dem folgenden Kontext.
      Wenn der Kontext die Antwort nicht enthaelt, sage das.
      Gib immer die Quelle an.

      Kontext: {context}
      Frage: {question}
      Antwort:
    code: |
      qa_chain = RetrievalQA.from_chain_type(
        llm=llm,
        chain_type='stuff',
        retriever=vectorstore.as_retriever(
          search_kwargs={'k': 4}
        ),
        return_source_documents=True
      )
      ergebnis = qa_chain.invoke({'query': 'Wie ist der Rueckgabeprozess?'})

Nach diesem Schritt beantwortet der Chatbot Fragen mit Bezug auf die hochgeladenen Firmendokumente. Die Vektor-Datenbank ChromaDB speichert die Embeddings lokal und persistiert zwischen Neustarts.

Schritt 4: Web-Interface hinzufügen (20 Minuten)

Für ein einfaches Web-Interface eignet sich Gradio oder Streamlit:

# web_interface.py - Streamlit Chat-Oberfläche
framework: "Streamlit"
installation: "pip install streamlit"
start: "streamlit run web_interface.py"

code_struktur:
  imports:
    - "import streamlit as st"
    - "# ... LangChain imports aus Schritt 3"

  initialisierung: |
    st.title('Firmen-Chatbot')
    st.caption('Fragen Sie mich zu internen Dokumenten')

    # Vektordatenbank laden (einmalig)
    vectorstore = Chroma(
      persist_directory='./chroma_db',
      embedding_function=embeddings
    )

  chat_interface: |
    if frage := st.chat_input('Ihre Frage...'):
      with st.spinner('Suche in Dokumenten...'):
        ergebnis = qa_chain.invoke({'query': frage})
      st.write(ergebnis['result'])
      with st.expander('Quellen'):
        for doc in ergebnis['source_documents']:
          st.write(f"- {doc.metadata['source']}")

url: "http://localhost:8501"

Alternativ kann der fertige Chatbot in OpenWebUI integriert werden. Details zur Implementierung von KI im Unternehmen bieten den organisatorischen Rahmen.

Häufige Fehler und Lösungen

Problem 1: Halluzinationen trotz RAG Der Bot erfindet Antworten, obwohl die Information nicht in den Dokumenten steht. Lösung: Den Prompt verschärfen ("Antworte NUR basierend auf dem Kontext. Wenn keine Information vorhanden, sage: Dazu habe ich keine Information.") und die Temperatur auf 0.1 setzen.

Problem 2: Relevante Dokumente werden nicht gefunden Die Chunks sind zu groß oder zu klein. Optimale Werte: chunk_size=800-1200, chunk_overlap=150-250. Bei technischen Dokumenten mit Tabellen: chunk_size=1500.

Problem 3: Langsame Antworten mit Ollama Llama 3.1 (8B) benötigt ohne GPU 15-30 Sekunden pro Antwort. Lösung: GPU nutzen (5x schneller) oder auf das kleinere Llama 3.2 (3B) wechseln (3x schneller, 10% weniger Qualität).

Problem 4: Deutsche Antworten mangelhaft Einige Modelle antworten trotz deutscher Frage auf Englisch. Lösung: System-Prompt mit "Antworte ausschließlich auf Deutsch" versehen. Bei Ollama: Mixtral (8x7B) liefert bessere deutsche Texte als Llama.

Für die strategische Planung empfehlen wir den KI-Leitfaden für Unternehmen.

Kosten und Deployment-Optionen

Für die meisten Mittelständler empfehlen wir den Start mit Ollama lokal (kostenlos, volle Datenkontrolle) und bei steigenden Qualitätsanforderungen den Wechsel zu Azure OpenAI. Der LangChain-Code bleibt identisch; nur die LLM-Initialisierung wird geändert.

Details zur Kostenplanung von KI-Projekten helfen bei der Budgetierung.

FAQ: Die 5 wichtigsten Fragen

1. Brauche ich Programmiererfahrung für LangChain? Grundlegende Python-Kenntnisse (Variablen, Funktionen, pip) reichen für den Einstieg. Fortgeschrittene Features wie Custom Chains oder Agents erfordern solide Python-Erfahrung. Die LangChain-Dokumentation ist umfangreich und gut strukturiert.

2. Wie viele Dokumente kann der RAG-Chatbot verarbeiten? ChromaDB verarbeitet problemlos 10.000+ Dokumente. Die Suchgeschwindigkeit bleibt bei unter 200 Millisekunden. Für größere Datenmengen (50.000+ Dokumente) empfiehlt sich Weaviate oder Qdrant als Vektor-Datenbank.

3. Kann ich den Chatbot in mein bestehendes Intranet integrieren? Ja. LangChain-Chatbots lassen sich als REST-API deployen (FastAPI oder Flask). Die API wird dann in jedes bestehende Intranet, SharePoint oder Teams eingebunden. Alternativ: OpenWebUI als fertige Chat-Oberfläche.

4. Wie aktualisiere ich die Wissensbasis? Neue Dokumente werden in den Ordner gelegt und ein Update-Script ausgeführt (5 Zeilen Code). Die Neuindizierung von 100 Dokumenten dauert 2-5 Minuten. Ein Cron-Job kann dies automatisch täglich ausführen.

5. LangChain oder LlamaIndex: Was ist besser für Einsteiger? LangChain bietet mehr Flexibilität und eine größere Community. LlamaIndex ist spezialisierter auf RAG und etwas einfacher für reine Dokumenten-Chatbots. Für den Einstieg empfehlen wir LangChain wegen der besseren Dokumentation und der zahlreichen Tutorials.

Fazit und nächste Schritte

LangChain macht den Einstieg in KI-Chatbots mit eigenen Daten zugänglich. Der RAG-Chatbot aus dieser Anleitung ist in 90 Minuten lauffähig und liefert sofort Mehrwert für interne Teams.

Starten Sie mit 20 PDF-Dokumenten und testen Sie die Antwortqualität. Unser Komplett-Leitfaden für KI im Unternehmen bietet den strategischen Rahmen für die Skalierung. Bei Fragen erreichen Sie uns unter kontakt@ki-mittelstand.eu.