RAG verstehen, indem du es baust: die kleinste funktionierende App mit Spring AI

Du brauchst weder LangChain noch eine Vektordatenbank noch einen fünfstündigen Framework-Kurs, um RAG zu verstehen. Der ganze Loop passt in zwei Java-Klassen. Ich weiss es, weil ich ihn gerade so gebaut habe — bewusst so klein wie möglich — als Teil 1 einer vierteiligen Tutorial-Serie. Dieser Post erklärt, was RAG wirklich ist, anhand von Code, den du klonen und starten kannst.

Das Problem, das RAG löst

Ein Sprachmodell kennt seine Trainingsdaten. Es kennt weder euer Wiki noch eure Verträge noch die Meeting-Notizen von gestern. Fragt man trotzdem, tut es das Schlimmstmögliche: Es antwortet selbstbewusst. RAG — Retrieval-Augmented Generation — löst das, ohne das Modell anzufassen. Statt dem Modell eure Dokumente beizubringen, reichst du ihm die relevanten Ausschnitte zum Zeitpunkt der Frage und sagst ihm, es soll daraus antworten.

Drei Schritte, bei jeder einzelnen Frage:

1. Retrieval — die Dokument-Chunks finden, die der Frage am ähnlichsten sind.
2. Augmentation — diese Chunks als Kontext in den Prompt einfügen.
3. Generation — das Modell antworten lassen, gestützt auf diesen Kontext.

Damit Schritt 1 funktioniert, durchläuft jedes Dokument vorher einmal die Ingestion-Pipeline: Text extrahieren (Apache Tika für PDFs und Office-Dateien, Jsoup für Webseiten), in Chunks teilen, für jeden Chunk ein Embedding berechnen — einen Vektor aus Gleitkommazahlen, der seine Bedeutung erfasst — und die Vektoren speichern. Ähnliche Bedeutung, nahe Vektoren. Das ist der ganze Trick.

Der komplette Loop, in Code

Die Ingestion ist eine Pipeline aus vier Aufrufen:

List<Document> chunks = splitter.apply(List.of(new Document(text, metadata)));
vectorStore.add(chunks); // embeddet jeden Chunk und speichert ihn

Und das Antworten sind drei Schritte, auf die du zeigen kannst:

// 1. Retrieval
List<Document> chunks = vectorStore.similaritySearch(
        SearchRequest.builder().query(question).topK(4).build());

// 2. Augmentation
String context = chunks.stream().map(Document::getText)
        .collect(Collectors.joining("\n---\n"));
Prompt prompt = new Prompt(List.of(
        new SystemMessage(SYSTEM_TEMPLATE.formatted(context)),
        new UserMessage(question)));

// 3. Generation
String answer = chatModel.call(prompt).getResult().getOutput().getText();

Das war's. Der „augmentierte Prompt", von dem alle reden, ist ein String mit deinen Chunks drin. Keine Magie, keine Chains, kein Graph aus Runnables. Der Vektorspeicher in Teil 1 ist Spring AIs In-Memory-SimpleVectorStore — nach einem Neustart weg, und das ist okay: Solange du lernst, ist Persistenz nur ein weiteres Ding, das verdeckt, was wirklich passiert.

Was dir das Dashboard beibringt

Das Angular-Frontend sind zwei Panels: links ingestieren (Datei-Upload + URL), rechts chatten. Das Detail, auf das es ankommt: Jede Antwort zeigt, auf welche Chunks sie sich stützt, mit Quelle und Ähnlichkeits-Score. Beim ersten Mal, wenn eine Antwort den falschen Chunk zitiert, hörst du auf, RAG für Magie zu halten, und fängst an, über Retrieval-Qualität nachzudenken — genau das mentale Modell, das du brauchst, bevor irgendetwas Schlaueres dazukommt.

Was ich bewusst weggelassen habe

Hybrid-Suche, Reranking, Metadaten-Filter, semantisches Chunking — alles echte Techniken, alles Verbesserungen, die du irgendwann willst, alles nicht in Teil 1. Nicht weil sie egal wären, sondern weil jede davon eine der vier Pipeline-Stufen tunt — und du keine Stufe tunen kannst, die du nie isoliert gesehen hast. Wenn ein produktives RAG-System eine schlechte Antwort gibt, sitzt der Fehler in einem dieser Schritte: Die Extraktion hat Müll produziert, das Chunking hat mitten im Satz geschnitten, das Retrieval hat die falschen Chunks geholt, oder der Prompt hat dem Modell erlaubt, seinen Kontext zu ignorieren. Um das zu debuggen, musst du die naive Version auswendig kennen.

Dasselbe gilt für die Framework-Frage. Spring AIs ChatModel, EmbeddingModel und VectorStore sind gewöhnliche Spring-Beans — wer JVM-Services in Produktion betreibt, bekommt RAG als Bibliothek, nicht als neue Plattform. Wer Python-nativ ist, nimmt LangChain oder LlamaIndex; die Konzepte dieser Serie übertragen sich eins zu eins.

Der Takeaway

Bau den kleinsten RAG-Loop, bevor du irgendeinen RAG-Stack übernimmst. Es ist ein Nachmittag Arbeit, und er verwandelt RAG von einem Buzzword in vier debugbare Funktionen. Das komplette Projekt — Backend, Dashboard, Walkthrough auf Deutsch und Englisch — ist eigenständig lauffähig mit einem einzigen Azure-OpenAI-Key.

Teil 2 macht die beiden grossen Infrastruktur-Entscheidungen austauschbar: Azure OpenAI vs. normale OpenAI-API vs. ein komplett offline laufendes lokales Mistral, und in-memory vs. persistentes pgvector — per Spring-Profil, ohne diesen Anwendungscode anzufassen. Der Tausch klingt trivial. War er nicht, und die Details sind der interessante Teil.

Code: github.com/halviclabs/rag-tutorials — Teil 1 ist rag-tutorial-01-basics. Und wenn dein Agent-Tooling über Dokumente hinaus an Systeme muss, gilt dieselbe Regel „klein, explizit, debugbar" — siehe deinen ersten MCP Server bauen.