Warum einen eigenen KI-Chatbot mit lokalen Dokumenten?
Die Integration von künstlicher Intelligenz in eigene Anwendungen ist mittlerweile auch für einzelne Entwickler zugänglich geworden. Mit LangChain, einem leistungsstarken Python-Framework, lassen sich KI-Chatbots erstellen, die auf eigenen Dokumenten basieren. Das ist besonders nützlich für Unternehmenswissen, technische Dokumentationen oder spezifische Wissensdatenbanken, die nicht in öffentlichen Large Language Models enthalten sind.
In diesem linux-installation-ohne-dual-boot-2026" title="Kali Linux in 5 Minuten auf jedem PC installieren">Tutorial zeige ich dir, wie du einen funktionsfähigen Chatbot erstellst, der deine lokalen Dokumente durchsucht und intelligent beantwortet. Wir verwenden dabei moderne Technologien wie Embeddings, Vektordatenbanken und Retrieval-Augmented Generation (RAG).
Voraussetzungen und Installation
Bevor wir starten, benötigst du Python 3.8 oder höher. Erstelle zunächst ein neues Projektverzeichnis und eine virtuelle Umgebung:
mkdir chatbot-projekt
cd chatbot-projekt
python -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activateInstalliere nun die erforderlichen Paketen:
pip install langchain langchain-community langchain-openai
pip install chromadb pypdf python-dotenv tiktokenFür dieses Projekt verwenden wir ChromaDB als Vektordatenbank, da sie einfach zu handhaben ist und keine externe Infrastruktur benötigt. PyPDF ermöglicht das Einlesen von PDF-Dokumenten, und tiktoken hilft bei der Tokenisierung.
Projekt-Struktur und Konfiguration
Erstelle folgende Dateien in deinem Projektverzeichnis:
chatbot-projekt/
├── .env
├── main.py
├── document_loader.py
├── chatbot.py
└── documents/ # Ordner für deine DokumenteIn der .env-Datei speicherst du deinen OpenAI API-Schlüssel:
OPENAI_API_KEY=dein_api_schluessel_hierWenn du keine OpenAI API verwenden möchtest, kannst du alternativ auf Open-Source-Modelle wie Llama oder Mistral über Ollama zurückgreifen. Das würde den Chatbot vollständig lokal und kostenfrei machen.
Dokumente laden und verarbeiten
Der erste Schritt besteht darin, deine Dokumente zu laden und in kleinere Textabschnitte zu unterteilen. Erstelle die Datei document_loader.py:
from langchain_community.document_loaders import PyPDFLoader, DirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
import os
class DocumentProcessor:
def __init__(self, documents_path="./documents"):
self.documents_path = documents_path
self.text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200,
length_function=len
)
def load_documents(self):
loader = DirectoryLoader(
self.documents_path,
glob="**/*.pdf",
loader_cls=PyPDFLoader
)
documents = loader.load()
return self.text_splitter.split_documents(documents)
def get_document_count(self):
pdf_files = [f for f in os.listdir(self.documents_path) if f.endswith('.pdf')]
return len(pdf_files)Die Klasse DocumentProcessor lädt alle PDF-Dateien aus dem Dokumentenordner und teilt sie in Chunks von 1000 Zeichen auf. Die Überlappung von 200 Zeichen stellt sicher, dass zusammenhängende Informationen nicht getrennt werden.
Vektordatenbank und Embeddings erstellen
Nun erstellen wir die eigentliche Chatbot-Logik in chatbot.py. Hier implementieren wir die Vektordatenbank und das Retrieval-System:
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
import os
from dotenv import load_dotenv
load_dotenv()
class DocumentChatbot:
def __init__(self, documents):
self.embeddings = OpenAIEmbeddings()
self.vectorstore = Chroma.from_documents(
documents=documents,
embedding=self.embeddings,
persist_directory="./chroma_db"
)
self.memory = ConversationBufferMemory(
memory_key="chat_history",
return_messages=True,
output_key="answer"
)
self.llm = ChatOpenAI(
temperature=0.7,
model_name="gpt-3.5-turbo"
)
self.qa_chain = ConversationalRetrievalChain.from_llm(
llm=self.llm,
retriever=self.vectorstore.as_retriever(search_kwargs={"k": 3}),
memory=self.memory,
return_source_documents=True
)
def ask(self, question):
result = self.qa_chain({"question": question})
return result["answer"], result["source_documents"]Diese Implementierung erstellt Embeddings für alle Dokumenten-Chunks und speichert sie in ChromaDB. Das ConversationalRetrievalChain-Objekt kombiniert Retrieval und Sprachmodell, während die Memory-Komponente den Gesprächsverlauf speichert.
Hauptanwendung zusammenführen
Jetzt fügen wir alles in der main.py zusammen:
from document_loader import DocumentProcessor
from chatbot import DocumentChatbot
import sys
def main():
print("Initialisiere Chatbot...")
# Dokumente laden
processor = DocumentProcessor()
doc_count = processor.get_document_count()
print(f"Gefundene Dokumente: {doc_count}")
if doc_count == 0:
print("Keine Dokumente gefunden. Bitte PDF-Dateien in ./documents ablegen.")
return
documents = processor.load_documents()
print(f"Dokumente in {len(documents)} Chunks aufgeteilt")
# Chatbot initialisieren
chatbot = DocumentChatbot(documents)
print("Chatbot bereit!\n")
# Chat-Schleife
while True:
question = input("Du: ")
if question.lower() in ['exit', 'quit', 'bye']:
print("Auf Wiedersehen!")
break
answer, sources = chatbot.ask(question)
print(f"\nBot: {answer}\n")
if sources:
print("Quellen:")
for i, doc in enumerate(sources[:2], 1):
print(f"{i}. Seite {doc.metadata.get('page', 'N/A')}")
print()
if __name__ == "__main__":
main()Den Chatbot testen und erweitern
Lege nun einige PDF-Dokumente in den documents-Ordner und starte den Chatbot:
python main.pyDer Chatbot wird die Dokumente einlesen, verarbeiten und ist dann bereit für Fragen. Er antwortet basierend auf dem Inhalt deiner Dokumente und gibt sogar die Quellen an.
Mögliche Erweiterungen:
- Unterstützung für weitere Dateiformate (TXT, DOCX, Markdown)
- Web-Interface mit Streamlit oder Flask
- Verwendung lokaler Modelle über Ollama für vollständige Offline-Funktionalität
- Optimierung der Chunk-Größe für spezifische Dokumenttypen
- Implementierung von Metadaten-Filtern für gezielteres Retrieval
Performance-Optimierung und Best Practices
Für produktive Anwendungen solltest du folgende Aspekte beachten: Die initiale Verarbeitung großer Dokumentensammlungen kann zeitintensiv sein. Speichere die Vektordatenbank persistent und lade sie bei Bedarf neu, statt sie jedes Mal neu zu erstellen. Die Chunk-Größe beeinflusst die Antwortqualität erheblich – experimentiere mit verschiedenen Werten zwischen 500 und 2000 Zeichen.
Bei sensiblen Daten empfiehlt sich der Einsatz lokaler Modelle. Ollama bietet eine einfache Möglichkeit, Modelle wie Llama 2 oder Mistral lokal auszuführen. Dafür musst du lediglich die LLM-Komponente anpassen und statt OpenAI die Ollama-Integration von LangChain verwenden.
Tipp: Verwende für große Dokumentensammlungen produktionsreife Vektordatenbanken wie Pinecone, Weaviate oder Qdrant, die bessere Skalierbarkeit bieten.
Fehlerbehandlung und Troubleshooting
Häufige Probleme und Lösungen: Wenn der Import fehlschlägt, überprüfe die Installation aller Pakete. Bei API-Fehlern stelle sicher, dass dein OpenAI-Schlüssel gültig ist und ausreichend Credits verfügbar sind. Falls die Antworten ungenau sind, experimentiere mit der Anzahl der abgerufenen Dokumente (Parameter k im Retriever) und passe die Chunk-Größe an.
Mit diesem Tutorial hast du einen funktionsfähigen KI-Chatbot erstellt, der deine eigenen Dokumente intelligent durchsuchen und beantworten kann. Das Grundgerüst lässt sich beliebig erweitern und an spezifische Anforderungen anpassen.
