So erstellen Sie ein RAG-System mit Claude: Eine KI, die mit Ihren eigenen Daten arbeitet (Vollständige Anleitung)

Fragen Sie Claude nach Ihrem Unternehmen, Ihren Notizen oder Ihren Dateien, und es zieht eine Leerstelle. Es hat sie nie gesehen. Es kennt nur das, was es im Training gelernt hat, und Ihre Sachen waren nicht dabei.

Ein RAG-System behebt das. Anstatt aus dem Gedächtnis zu antworten, sucht Claude zuerst in Ihren Dokumenten, holt die relevanten Teile heraus und antwortet auf Basis dessen, was es tatsächlich gefunden hat. Ihre Daten, seine Quelle, keine Rätselraten.

Warum es besser ist, als Dateien einfach in den Chat zu kopieren:

Es skaliert. Ihre gesamte Wissensbasis passt nicht in einen Chat. RAG speichert alles und zieht nur das heran, was jede Frage benötigt.

Es ist günstiger. Wenn Sie eine Datei einfügen, liest Claude das gesamte Dokument bei jeder einzelnen Frage erneut. RAG liest es einmal und ruft dann nur den relevanten Teil ab. Statt jedes Mal ein 10.000-Token-Handbuch zu senden, sendet es vielleicht 500 Token des genauen Abschnitts, den Sie brauchen. Reale Konfigurationen reduzieren die Token-Nutzung um 80 % oder mehr.

Es ist präziser. Füttert man einem Modell einen riesigen Textblock, verliert es Details in der Mitte. Gibt man ihm ein paar präzise Abschnitte, werden die Antworten genauer.

Es bleibt aktuell. Aktualisieren Sie Ihre Dateien einmal, und das System verwendet die neue Version. Kein erneutes Einfügen nötig.

Am Ende dieses Leitfadens haben Sie ein System, das auf Ihren eigenen Dateien läuft, Schritt für Schritt, ohne dass Sie einen Doktortitel brauchen.

Was Sie brauchen werden

Bevor wir auch nur eine Zeile Code anfassen, hier die vollständige Liste. Die gute Nachricht: Diese Version benötigt nur einen API-Schlüssel, und alles andere läuft kostenlos auf Ihrem eigenen Rechner.

1. Python 3.9 oder neuer. Um zu prüfen, ob Sie es haben, öffnen Sie Ihr Terminal (Terminal auf dem Mac, Eingabeaufforderung unter Windows) und geben Sie python --version ein. Wenn Sie so etwas wie 3.11 sehen, sind Sie startklar. Wenn nicht, laden Sie es von python.org herunter und führen Sie den Installer aus. Unter Windows aktivieren Sie während der Installation das Kästchen "Add Python to PATH", sonst funktionieren die untenstehenden Befehle nicht.

2. Ein Claude-API-Schlüssel, plus ein kleines Guthaben. Dies ist der einzige Schlüssel und das einzige Geld, das der gesamte Leitfaden benötigt. Hier ist der genaue Weg, Klick für Klick:

Gehen Sie zu platform.claude.com und melden Sie sich dort an (oder registrieren Sie sich).

Die API benötigt ein positives Guthaben, um zu funktionieren. Fügen Sie also zuerst Geld hinzu. Wenn Sie dazu aufgefordert werden, wählen Sie, ob das Guthaben für sich selbst oder ein Unternehmen bestimmt ist. Dann landen Sie auf dem Zahlungsbildschirm. Wählen Sie die Option $5 "Starting out" . Das ist völlig ausreichend: Alles andere in diesem Leitfaden ist kostenlos und läuft lokal, daher ist Claude die einzige Kostenstelle, und jede Frage kostet Sie nur einen Bruchteil eines Cents. Das Guthaben verfällt ein Jahr nach dem Kauf.

Nach der Zahlung landen Sie auf Ihrem Console-Dashboard. Sie sollten Ihr Guthaben (z. B. $5.00) oben links unter "Organization credits" sehen.

Jetzt holen Sie sich den Schlüssel. Klicken Sie auf Get API key (oben rechts), dann auf Create Key. Geben Sie ihm einen beliebigen Namen (z. B. mein-rag-schluessel) und lassen Sie den Arbeitsbereich als Default stehen. Klicken Sie auf "Create" und kopieren Sie dann die angezeigte Zeichenfolge. Sie beginnt mit sk-ant- und Sie sehen sie nur einmal. Fügen Sie sie daher für einen Moment an einem sicheren Ort ein.

Das ist die gesamte Einrichtung.

Schritt 1: Fügen Sie Ihren Schlüssel hinzu und laden Sie Ihre Dateien

1. Erstellen Sie den Projektordner. Erstellen Sie einen neuen Ordner auf Ihrem Desktop und nennen Sie ihn rag-project. Hier kommt alles hinein.

2. Öffnen Sie Ihr Terminal. Auf dem Mac: Cmd+Leertaste, Terminal eingeben, Enter drücken. Unter Windows: Start-Taste, cmd eingeben, Enter drücken.

3. Navigieren Sie im Terminal zu Ihrem Ordner. Geben Sie cd und ein Leerzeichen ein, ziehen Sie dann den rag-project-Ordner auf das Terminalfenster und drücken Sie die Eingabetaste. Jeder Befehl unten wird von innerhalb dieses Ordners ausgeführt.

1cd Desktop/rag-project

4. Installieren Sie die Werkzeuge. Fügen Sie dies in Ihr Terminal ein und drücken Sie die Eingabetaste (der erste Durchlauf kann eine Minute dauern):

1pip install anthropic chromadb sentence-transformers pypdf python-dotenv

Wenn Sie "pip: command not found" erhalten, verwenden Sie pip3 anstelle von pip. Wenn das Terminal eine neue Zeile ohne rote Fehler anzeigt, ist es fertig.

5. Erstellen Sie Ihre Codedatei. Erstellen Sie innerhalb von rag-project eine leere Datei mit dem Namen rag.py. Öffnen Sie sie in einem beliebigen Texteditor.

6. Erstellen Sie Ihre Schlüsseldatei. Erstellen Sie im selben Ordner eine Datei mit dem Namen .env (beginnt mit einem Punkt, kein Name davor). Fügen Sie dies hinein, mit dem echten Schlüssel, den Sie während der Einrichtung erstellt haben, nach dem =, ohne Leerzeichen, ohne Anführungszeichen:

1ANTHROPIC_API_KEY=sk-ant-paste-your-real-key-here

Wenn Sie den Schlüssel in der .env-Datei aufbewahren und nicht in Ihrem Code, wird er nicht preisgegeben, falls Sie das Skript teilen oder auf GitHub stellen.

7. Laden Sie den Schlüssel. Setzen Sie dies an den Anfang von rag.py:

1import os
2from dotenv import load_dotenv
3
4load_dotenv()  # reads your .env file
5api_key = os.getenv("ANTHROPIC_API_KEY")

8. Erstellen Sie Ihre Wissensdatenbank. Erstellen Sie innerhalb von rag-project einen Ordner mit dem Namen documents. Legen Sie dort beliebige .txt-, .md- oder .pdf-Dateien ab: Ihre Notizen, ein Produktdokument, Besprechungszusammenfassungen, alles.

8.1. Wenn Sie noch keine Dateien haben, verwenden Sie diese Testdatei. Erstellen Sie notes.txt im Ordner documents und fügen Sie dies ein:

Project Northstar ist unser internes Tool zur Verfolgung von Kundenfeedback. Es wurde im März 2026 gestartet und wird vom Plattform-Team betreut. Die leitende Ingenieurin ist Dana Reyes. Feedback wird jeden Freitag überprüft. Northstar ersetzte das alte Tabellenkalkulationssystem, das wir bis 2025 verwendeten.

Am Ende werden Sie Claude nach Northstar fragen und zusehen, wie es aus dieser genauen Datei antwortet.

9. Fügen Sie den Code hinzu, der Ihre Dateien liest. Fügen Sie in rag.py unter dem Code von Schritt 7 Folgendes ein:

1from pathlib import Path
2from pypdf import PdfReader
3
4def load_documents(folder="documents"):
5    docs = []
6    for file in Path(folder).iterdir():
7        if file.suffix in [".txt", ".md"]:
8            text = file.read_text(encoding="utf-8")
9            docs.append({"source": file.name, "text": text})
10        elif file.suffix == ".pdf":
11            reader = PdfReader(str(file))
12            text = "\n".join(page.extract_text() or "" for page in reader.pages)
13            docs.append({"source": file.name, "text": text})
14    return docs
15
16documents = load_documents()
17print(f"Loaded {len(documents)} document(s).")

10. Führen Sie es aus. Speichern Sie rag.py, dann in Ihrem Terminal:

1python rag.py

Sie sollten Folgendes sehen:

Loaded 1 document(s)

Wenn Sie "Loaded 0 document(s)" sehen, ist der Ordner documents leer oder befindet sich am falschen Ort. Er muss direkt innerhalb von rag-project liegen, neben rag.py.

Schritt 2: Teilen Sie Ihre Dateien in Abschnitte auf

Im Moment ist jede Datei ein großer Textblock. Bevor wir darin suchen können, müssen wir sie in kleinere Stücke, sogenannte Abschnitte (Chunks), aufteilen. Der Grund: Wenn jemand eine Frage stellt, findet das System die passenden Abschnitte und sendet nur diese an Claude. Wenn Ihre Abschnitte ganze 50-seitige Dokumente sind, senden Sie viel zu viel. Wenn es einzelne Sätze sind, verlieren sie den Kontext. Kleine Absätze sind der optimale Punkt.

1. Fügen Sie den Code zum Aufteilen hinzu. Fügen Sie in rag.py unter dem Code von Schritt 10 Folgendes ein:

1def chunk_text(text, chunk_size=500, overlap=100):
2    words = text.split()
3    chunks = []
4    start = 0
5    while start < len(words):
6        end = start + chunk_size
7        chunk = " ".join(words[start:end])
8        chunks.append(chunk)
9        start = end - overlap  # step back a little so chunks overlap
10    return chunks

Zwei Zahlen, die Sie hier verstehen sollten, einfach erklärt:

• chunk_size=500 bedeutet, dass jeder Abschnitt etwa 500 Wörter lang ist. Groß genug, um eine vollständige Idee zu enthalten, klein genug, um präzise zu bleiben.
• overlap=100 bedeutet, dass jeder Abschnitt die letzten 100 Wörter des vorherigen wiederholt. Das ist wichtig, weil eine Antwort genau an der Grenze zwischen zwei Abschnitten liegen könnte. Ohne Überlappung könnte ein Satz, der in der Mitte getrennt wird, verloren gehen. Die Überlappung stellt sicher, dass keine Idee durch das Raster fällt.

2. Wandeln Sie jedes Dokument in Abschnitte um. Fügen Sie dies unten hinzu:

1all_chunks = []
2for doc in documents:
3    for chunk in chunk_text(doc["text"]):
4        all_chunks.append({"source": doc["source"], "text": chunk})
5
6print(f"Created {len(all_chunks)} chunk(s) from {len(documents)} document(s).")

Beachten Sie, dass jeder Abschnitt seine Quelle (den Dateinamen, aus dem er stammt) trägt. Wir behalten das während des gesamten Prozesses bei, sodass Claude später bei der Antwort mitteilen kann, aus welcher Datei die Antwort stammt.

3. Führen Sie es aus. Speichern Sie rag.py, dann in Ihrem Terminal:

1python rag.py

Sie sollten so etwas sehen:

Loaded 1 document(s).

Created 1 chunk(s) from 1 document(s).

Die kleine Testdatei wird nur zu einem Abschnitt, da sie kurz ist. Echte Dokumente erzeugen viele. Wenn Sie eine lange PDF-Datei in den Ordner gelegt haben, werden Sie möglicherweise Dutzende oder Hunderte von Abschnitten sehen, was genau das ist, was Sie wollen.

Schritt 3: Wandeln Sie Ihre Abschnitte in Embeddings um

Dies ist der Schritt, der es dem Computer ermöglicht, nach Bedeutung und nicht nach exakten Wörtern zu suchen. Jeder Abschnitt wird in eine Liste von Zahlen (ein Embedding) umgewandelt, die erfasst, worum es geht. Abschnitte mit ähnlicher Bedeutung erhalten ähnliche Zahlen. Später, wenn eine Frage eingeht, wandeln wir die Frage ebenfalls in Zahlen um und finden die ähnlichsten Treffer.

Das Modell, das dies durchführt, läuft lokal auf Ihrem Rechner. Es wird einmal heruntergeladen und arbeitet dann offline und kostenlos, und Ihre Dateien verlassen nie Ihren Computer.

1. Laden Sie das Embedding-Modell. Fügen Sie in rag.py unter dem Code von Schritt 2 Folgendes ein:

1from sentence_transformers import SentenceTransformer
2
3print("Loading the embedding model (first run downloads it, about 90 MB)...")
4embedder = SentenceTransformer("all-MiniLM-L6-v2")

Beim ersten Ausführen wird das Modell heruntergeladen, geben Sie ihm also einen Moment Zeit. Jeder weitere Durchlauf ist sofort, da es bereits auf Ihrem Rechner ist.

2. Wandeln Sie jeden Abschnitt in ein Embedding um. Fügen Sie dies unten hinzu:

1chunk_texts = [chunk["text"] for chunk in all_chunks]
2embeddings = embedder.encode(chunk_texts)
3
4print(f"Created {len(embeddings)} embedding(s).")
5print(f"Each embedding is a list of {len(embeddings[0])} numbers.")

embedder.encode(...) nimmt Ihre Liste von Abschnittstexten und gibt ein Embedding pro Abschnitt zurück. Das ist alles, was nötig ist.

3. Führen Sie es aus. Speichern Sie rag.py, dann in Ihrem Terminal:

1python rag.py

Der erste Durchlauf pausiert, während das Modell heruntergeladen wird. Dann sollten Sie so etwas sehen:

Loaded 1 document(s).

Created 1 chunk(s) from 1 document(s).

Loading the embedding model (first run downloads it, about 90 MB)...

Created 1 embedding(s).

Each embedding is a list of 384 numbers.

Diese Zeile "384 numbers" macht die ganze Idee sichtbar: Ihr Text ist jetzt eine Zahlenreihe, die der Computer vergleichen kann. Sie müssen diese Zahlen nicht selbst lesen oder verstehen. Die Datenbank im nächsten Schritt übernimmt den gesamten Vergleich für Sie.

Wenn der Download mit einem Verbindungsfehler fehlschlägt, führen Sie den Befehl einfach erneut aus. Er setzt dort fort, wo er aufgehört hat.

Schritt 4: Speichern Sie alles in Ihrer Vektordatenbank

Jetzt legen wir die Abschnitte und ihre Embeddings in Chroma, Ihrer lokalen Datenbank, ab. Dadurch wird die Suche schnell: Anstatt Ihre Frage jedes Mal manuell mit jedem Abschnitt zu vergleichen, speichert Chroma sie einsatzbereit und führt den Abgleich für Sie durch. Es speichert die Daten in einem Ordner auf Ihrem Rechner, sodass Sie es nur einmal aufbauen müssen.

1. Richten Sie die Datenbank ein. Fügen Sie in rag.py unter dem Code von Schritt 3 Folgendes ein:

1import chromadb
2
3client = chromadb.PersistentClient(path="chroma_db")
4collection = client.get_or_create_collection("my_documents")

PersistentClient(path="chroma_db") weist Chroma an, in einem Ordner namens chroma_db zu speichern (es wird automatisch erstellt, direkt neben Ihrem Skript). Da es auf der Festplatte gespeichert wird, bleiben Ihre Daten erhalten, nachdem das Skript beendet ist. Eine Collection ist einfach der benannte Behälter, in dem Ihre Abschnitte leben.

2. Fügen Sie Ihre Abschnitte zur Datenbank hinzu. Fügen Sie dies unten hinzu:

1collection.add(
2    ids=[str(i) for i in range(len(all_chunks))],
3    embeddings=[emb.tolist() for emb in embeddings],
4    documents=[chunk["text"] for chunk in all_chunks],
5    metadatas=[{"source": chunk["source"]} for chunk in all_chunks],
6)
7
8print(f"Stored {collection.count()} chunk(s) in the database.")

Hier ist, was jede Zeile an Chroma übergibt, einfach erklärt: ids gibt jedem Abschnitt eine eindeutige Kennung (0, 1, 2...), embeddings sind die Zahlen aus Schritt 3, documents ist der eigentliche Abschnittstext und metadatas trägt den Dateinamen mit sich, damit wir später die Quelle anzeigen können. Chroma behält alle vier miteinander verknüpft.

3. Führen Sie es aus. Speichern Sie rag.py, dann in Ihrem Terminal:

1python rag.py

Sie sollten Folgendes sehen:

Stored 1 chunk(s) in the database.

Eine Sache, die Sie für später wissen sollten. Jedes Mal, wenn Sie das Skript jetzt ausführen, werden die Abschnitte erneut hinzugefügt, sodass die Zählungen bei wiederholten Ausführungen steigen können (1, dann 2, dann 3...). Das ist in Ordnung, solange wir bauen. Um sauber zu beginnen, löschen Sie den Ordner chroma_db und führen Sie das Skript einmal erneut aus. In der endgültigen Version werden wir das ordnungsgemäß handhaben, sodass es keine Doppelungen gibt.

Schritt 5: Durchsuchen Sie Ihre Dokumente

Dies ist der "Retrieval"-Teil von RAG, das R im Namen. Wir nehmen eine Frage, wandeln sie auf die gleiche Weise wie die Abschnitte in ein Embedding um und bitten Chroma um die Abschnitte, deren Bedeutung am nächsten kommt. Diese passenden Abschnitte werden wir im nächsten Schritt an Claude übergeben.

1. Fügen Sie die Suchfunktion hinzu. Fügen Sie in rag.py unter dem Code von Schritt 4 Folgendes ein:

1def search(question, n_results=3):
2    question_embedding = embedder.encode([question])[0]
3    results = collection.query(
4        query_embeddings=[question_embedding.tolist()],
5        n_results=n_results,
6    )
7    return results

Was das tut, Zeile für Zeile einfach erklärt: Es wandelt die Frage mit demselben Modell, das Sie auf Ihre Abschnitte angewendet haben, in Zahlen um (das ist wichtig, beide müssen die gleiche "Zahlensprache" sprechen) und bittet dann Chroma um die nächsten Treffer. n_results=3 bedeutet "gib mir die 3 relevantesten Abschnitte." Drei ist ein guter Standardwert: genug Kontext, aber nicht so viel, dass Sie Token verschwenden.

2. Probieren Sie eine Suche aus. Fügen Sie dies unten hinzu, um es zu testen:

1question = "Who runs Northstar and when is feedback reviewed?"
2results = search(question)
3
4for i, doc in enumerate(results["documents"][0]):
5    source = results["metadatas"][0][i]["source"]
6    print(f"\n--- Match {i+1} (from {source}) ---")
7    print(doc)

Dies führt eine echte Frage gegen Ihre Datenbank aus und gibt die gefundenen Abschnitte aus, jeweils mit dem Dateinamen, aus dem sie stammen.

3. Führen Sie es aus. Speichern Sie rag.py, dann in Ihrem Terminal:

1python rag.py

Mit der Northstar-Testdatei sollten Sie sehen, wie der passende Abschnitt zurückgegeben wird, etwa so:

--- Match 1 (from notes.txt) ---

Project Northstar ist unser internes Tool zur Verfolgung von Kundenfeedback. Es wurde im März 2026 gestartet und wird vom Plattform-Team betreut. Die leitende Ingenieurin ist Dana Reyes. Feedback wird jeden Freitag überprüft. Northstar ersetzte das alte Tabellenkalkulationssystem, das wir bis 2025 verwendeten.

Beachten Sie, was gerade passiert ist: Ihre Frage verwendete die Wörter "who runs" und "reviewed", aber die Datei sagt "leitende Ingenieurin" und "jeden Freitag überprüft". Es wurde trotzdem übereinstimmend gefunden, weil die Suche auf Bedeutung und nicht auf exakten Wörtern basiert. Das ist der ganze Sinn von Embeddings, und deshalb ist dies besser als eine einfache Stichwortsuche (Strg+F) in Ihren Dateien.

Wenn Sie mehr Dateien haben, sehen Sie die Top-3-Abschnitte aus allen, sortiert nach ihrer Übereinstimmung.

Schritt 6: Lassen Sie Claude auf Basis der Funde antworten

Dies ist der "Generierungs"-Teil, das G in RAG. Wir nehmen die Abschnitte aus Schritt 5, übergeben sie zusammen mit der Frage an Claude Opus 4.8 und sagen ihm, dass es nur mit diesem Kontext antworten soll. Das verhindert, dass es rät: Claude antwortet aus Ihren Dateien, nicht aus seinem eigenen Gedächtnis, und teilt Ihnen mit, welche Datei es verwendet hat.

1. Fügen Sie die Antwortfunktion hinzu. Fügen Sie in rag.py unter dem Code von Schritt 5 Folgendes ein:

1import anthropic
2
3claude = anthropic.Anthropic(api_key=api_key)
4
5def answer(question):
6    results = search(question)
7    chunks = results["documents"][0]
8    sources = [m["source"] for m in results["metadatas"][0]]
9
10    context = ""
11    for i, chunk in enumerate(chunks):
12        context += f"[From {sources[i]}]\n{chunk}\n\n"
13
14    message = claude.messages.create(
15        model="claude-opus-4-8",
16        max_tokens=1024,
17        system=(
18            "You answer questions using only the context provided. "
19            "If the answer is not in the context, say you don't know. "
20            "Always mention which file your answer came from."
21        ),
22        messages=[
23            {
24                "role": "user",
25                "content": f"Context:\n{context}\nQuestion: {question}",
26            }
27        ],
28    )
29    return message.content[0].text

Was hier passiert, einfach erklärt: Wir suchen nach den relevanten Abschnitten, fügen sie zu einem Kontext-Block zusammen (jeder mit seinem Dateinamen beschriftet) und senden diesen Block plus die Frage an Claude. Die System-Anweisung ist der entscheidende Teil. Sie sagt Claude drei Dinge: Antworte nur aus dem Kontext, gib zu, wenn die Antwort nicht vorhanden ist, und nenne die Quelldatei. Diese drei Regeln machen die Antworten vertrauenswürdig, statt erfunden.

model="claude-opus-4-8" ist der genaue Modellname (Bindestriche, keine Punkte). max_tokens=1024 begrenzt die Länge der Antwort.

2. Stellen Sie eine Frage. Fügen Sie dies unten hinzu:

1question = "Who runs Northstar and when is feedback reviewed?"
2print(answer(question))

3. Führen Sie es aus. Speichern Sie rag.py, dann in Ihrem Terminal:

1python rag.py

Sie sollten eine echte Antwort erhalten, die aus Ihrer Datei erstellt wurde, etwa so:

Dana Reyes ist die leitende Ingenieurin, die Project Northstar leitet, und das Feedback wird jeden Freitag überprüft. (Quelle: notes.txt)

Das ist ein voll funktionsfähiges RAG-System. Claude hat diese Datei während des Trainings nie gesehen, es kann nicht wissen, wer Dana Reyes ist, und trotzdem hat es richtig geantwortet und Ihnen genau gesagt, woher die Antwort stammt. Fragen Sie etwas, das nicht in Ihren Dateien steht, und es wird sagen, dass es es nicht weiß, anstatt eine Antwort zu erfinden. Dieses "Ich weiß es nicht" ist eine Funktion, kein Fehler: Es ist der Unterschied zwischen einem Werkzeug, dem Sie vertrauen können, und einem, das rät.

Schritt 7: Machen Sie daraus etwas, das Sie tatsächlich nutzen können

Im Moment müssen Sie den Code bearbeiten und das gesamte Skript jedes Mal neu ausführen, wenn Sie etwas fragen möchten. Schlimmer noch: Bei jedem Durchlauf werden Ihre Dateien neu gelesen und erneut zur Datenbank hinzugefügt, sodass sich Abschnitte anhäufen. Lassen Sie uns beides beheben: Bauen Sie die Datenbank nur einmal auf und lassen Sie sich dann Fragen in einer Schleife stellen, die Sie direkt ins Terminal eingeben.

1. Beheben Sie das erneute Hinzufügen. Suchen Sie den Block aus Schritt 4, der Abschnitte hinzufügt (den collection.add(...)-Teil), und ersetzen Sie ihn durch diese Version, die die Datenbank nur dann aufbaut, wenn sie leer ist:

1if collection.count() == 0:
2    collection.add(
3        ids=[str(i) for i in range(len(all_chunks))],
4        embeddings=[emb.tolist() for emb in embeddings],
5        documents=[chunk["text"] for chunk in all_chunks],
6        metadatas=[{"source": chunk["source"]} for chunk in all_chunks],
7    )
8    print(f"Stored {collection.count()} chunk(s) in the database.")
9else:
10    print(f"Database already has {collection.count()} chunk(s), skipping rebuild.")

Jetzt findet die schwere Arbeit (Dateien lesen, Embeddings erstellen, Datenbank füllen) nur beim ersten Mal statt. Spätere Durchläufe springen direkt zur Antwort.

2. Fügen Sie die Frageschleife hinzu. Ersetzen Sie am Ende von rag.py die einzelne Testfrage aus Schritt 6 durch Folgendes:

1print("\nAsk a question about your documents (or type 'quit' to exit).\n")
2
3while True:
4    question = input("You: ")
5    if question.lower() in ["quit", "exit"]:
6        break
7    print("\nClaude: " + answer(question) + "\n")

input("You: ") wartet darauf, dass Sie eine Frage eingeben und die Eingabetaste drücken. while True hält es am Laufen, sodass Sie so viele Fragen stellen können, wie Sie möchten. Die Eingabe von quit beendet es.

3. Führen Sie es aus. Speichern Sie rag.py, dann in Ihrem Terminal:

1python rag.py

Jetzt können Sie einfach mit Ihren Dateien sprechen:

Stellen Sie eine Frage zu Ihren Dokumenten (oder geben Sie 'quit' ein, um zu beenden).

Sie: Wer ist die leitende Ingenieurin bei Northstar?

Claude: Die leitende Ingenieurin bei Project Northstar ist Dana Reyes. (Quelle: notes.txt)

Sie: Was wurde dadurch ersetzt?

Claude: Northstar ersetzte das alte Tabellenkalkulationssystem, das bis 2025 verwendet wurde. (Quelle: notes.txt)

Sie: quit

Das ist Ihr fertiges RAG-System. Es liest Ihre Dateien einmal, merkt sie sich und beantwortet bei Bedarf Fragen dazu, jedes Mal mit der Quellenangabe.

Eine Sache, die Sie wissen sollten, wenn Sie neue Dateien hinzufügen. Da die Datenbank jetzt nur einmal aufgebaut wird, werden neue Dateien, die Sie in documents ablegen, nicht automatisch angezeigt. Um neue Dateien zu laden, löschen Sie den Ordner chroma_db und führen Sie das Skript einmal aus. Es baut alles von Grund auf mit allem im Ordner neu auf.

Optional: Geben Sie ihm ein Chat-Fenster in Ihrem Browser

Das Terminal funktioniert, aber wenn Sie ein richtiges Chat-Fenster möchten, fügt Streamlit eines mit etwa 20 Zeilen hinzu.

1. Installieren Sie es. In Ihrem Terminal:

1pip install streamlit

2. Erstellen Sie app.py im selben Ordner und fügen Sie dies ein. Es verwendet die Antwortfunktion aus Ihrer rag.py wieder:

1import streamlit as st
2from rag import answer
3
4st.title("Chat with your documents")
5
6if "history" not in st.session_state:
7    st.session_state.history = []
8
9question = st.chat_input("Ask about your files...")
10
11if question:
12    reply = answer(question)
13    st.session_state.history.append((question, reply))
14
15for q, a in st.session_state.history:
16    st.chat_message("user").write(q)
17    st.chat_message("assistant").write(a)

3. Führen Sie es aus. In Ihrem Terminal (beachten Sie: streamlit run, nicht python):

1streamlit run app.py

Es öffnet automatisch ein Chat-Fenster in Ihrem Browser. Geben Sie eine Frage ein, erhalten Sie eine Antwort mit Quelle, genau wie im Terminal, aber schöner anzusehen.

Ein Hinweis: Damit dies funktioniert, darf die Frageschleife aus Schritt 7 beim Import nicht ausgeführt werden. Wickeln Sie diese Schleife am Ende von rag.py in if __name__ == "__main__": ein, sodass sie nur ausgelöst wird, wenn Sie rag.py direkt ausführen, nicht wenn app.py es importiert.

Allgemeine Fragen zulassen

Wenn Sie möchten, dass es auch allgemeine Fragen beantwortet. Derzeit antwortet das System nur aus Ihren Dateien, sodass eine Frage wie "Was ist die Hauptstadt von Venezuela?" die Antwort erhält, dass dies nicht in den Dokumenten steht, obwohl Claude die Antwort kennt. Wenn Sie möchten, dass es auf sein eigenes Wissen zurückgreift, öffnen Sie rag.py, suchen Sie den system=(...)-Block in Schritt 6 und tauschen Sie diese Zeile aus:

1"Wenn die Antwort nicht im Kontext ist, sag, dass du es nicht weißt. "

für dies:

1"Wenn die Antwort nicht im Kontext ist, antworte aus deinem eigenen Allgemeinwissen, aber sag, dass du das tust. "

Speichern und erneut ausführen. Jetzt antwortet es zuerst aus deinen Dateien und fällt auf Allgemeinwissen zurück, wenn die Dateien es nicht abdecken, und sagt dir, welches es verwendet hat.

Zusammenfassung

Du hast gerade ein funktionierendes RAG-System gebaut. Es liest deine eigenen Dateien, findet die relevanten Teile und lässt Claude daraus antworten – jedes Mal mit der genauen Quelle. Das gleiche Setup skaliert von ein paar Notizen bis zu deiner gesamten Wissensdatenbank.

Von hier aus kannst du es überallhin ausrichten: deinen Obsidian-Vault, deine Arbeitsdokumente, deine gespeicherte Forschung. Lege die Dateien hinein, baue einmal neu auf und fange an zu fragen. Alles, was du hier gelernt hast – die Chunks, die Embeddings, die Suche, die Antwort – ist das gleiche Rückgrat hinter jedem „Chat mit deinen Dokumenten“-Tool, das du gesehen hast.

Wenn das nützlich war, geh zu meinem Profil und folge mir. Ich schreibe über Technik, KI und Systeme, die tatsächlich laufen.

Ciao,

[@undefinedKi**](https://x.com/@undefinedKi