Retrieval-Augmented Generation (RAG):Definition und Architektur für verlässliche Finanz-KIs

Die RAG-Architektur verbindet die generative Sprachflexibilität eines Large Language Models mit der mathematischen Präzision einer vektorisierten Datenbanksuche. Während das LLM als Synthese-Engine fungiert, übernimmt die Datenbank die exakte Faktenwiedergabe.

Unstrukturierte Finanzdokumente werden in semantische Textblöcke (Chunks) zerlegt. Ein spezialisiertes Embedding-Modell überführt diese Textabschnitte in hochdimensionale mathematische Vektoren, deren geometrische Abstände zueinander semantische Ähnlichkeiten repräsentieren.

Bei einer spezifischen Nutzerfrage (z. B. nach dem operativen Cashflow eines Konzerns) wird die Anfrage ebenfalls vektorisiert. Das System berechnet die Kosinus-Ähnlichkeit (Cosine Similarity) zwischen dem Anfragevektor und den gespeicherten Dokumentenvektoren, um die relevantesten Textstellen zu ermitteln:

Dadurch ermittelt das System exakt diejenigen Textsegmente, deren Vektoren im n-dimensionalen Raum den geringsten Winkelabstand zur Fragestellung aufweisen.

Die ermittelten Top-Textfragmente werden dynamisch in den Prompt des LLMs injiziert („Hier ist der Kontext: […] Beantworte die Frage ausschließlich basierend darauf“). Das Sprachmodell formuliert die Antwort auf Basis dieser verifizierten Primärquellen.

Betrachte den Unterschied zwischen einem isolierten Sprachmodell und einer RAG-Pipeline wie zwei Studenten in einer anspruchsvollen Bilanzsteuer-Klausur:

• Die geschlossene Klausur (Standard-LLM): Der erste Student darf keinerlei Unterlagen verwenden und muss sämtliche Kennzahlen, Steuersätze und Bilanzpositionen aus dem Gedächtnis niederschreiben. Bei geläufigen Definitionen glänzt er mit perfekter Formulierung. Fragt man ihn jedoch nach den exakten Verbindlichkeiten eines spezifischen Nebenwerts im dritten Quartal des Vorjahres, verwechselt er Zahlen, erfindet plausible Werte und halluziniert mit voller Überzeugung.
• Die Open-Book-Prüfung (RAG-Architektur): Der zweite Student besitzt exakt denselben Intellekt, darf jedoch eine strukturierte Bibliothek mit sämtlichen Original-Geschäftsberichten nutzen. Bevor er eine einzige Zeile formuliert, schlägt er gezielt die Bilanzseite des entsprechenden Quartals auf, prüft die Fußnoten und zitiert die Zahl exakt aus der Primärquelle. RAG verwandelt ein kreatives Sprachmodell in einen prüfbaren Analysten, indem es Texterzeugung strikt an nachweisbare Dokumentenauszüge koppelt.

Klassische Suchmaschinen scheitern an Begriffsvielfalt: Wer nach Zinsbelastung sucht, findet keine Textpassagen, in denen das Unternehmen lediglich von steigenden Fremdkapitalkosten spricht.

Der mathematische Vorteil dichter Vektoren:
RAG überwindet diese Schwachstelle durch hochdimensionale Vektoreinbettungen (Embeddings). Ein Embedding-Modell wandelt Absätze eines Geschäftsberichts in Zahlenreihen um, die semantische Bedeutungen im mathematischen Raum abbilden. Fragt ein Portfoliomanager nach Risiken für die Lieferkette, misst die Vektordatenbank über die Kosinus-Ähnlichkeit, welche Text-Chunks der Frage inhaltlich am nächsten liegen, selbst wenn völlig andere Worte verwendet wurden. Das Sprachmodell erhält daraufhin ausschließlich diese relevanten Fragmente als Kontext injiziert.

Die folgende Referenz-Implementierung in reinem NumPy und Pandas demonstriert den mathematischen Kern einer Finanz-RAG-Pipeline ohne externe Framework-Abhängigkeiten: Sie zerlegt Finanzberichte in Chunks, simuliert normalisierte Vektor-Embeddings und führt eine vektorisierte Kosinus-Ähnlichkeitssuche zur deterministischen Fakten-Extraktion durch:

import numpy as np
import pandas as pd
from typing import List, Dict

def cosine_similarity_matrix(query_vec: np.ndarray, doc_vecs: np.ndarray) -> np.ndarray:
    """Berechnet die normalisierte Kosinus-Aehnlichkeit zwischen Query und Dokumenten."""
    dot_products = np.dot(doc_vecs, query_vec)
    query_norm = np.linalg.norm(query_vec)
    doc_norms = np.linalg.norm(doc_vecs, axis=1)
    return dot_products / (query_norm * doc_norms + 1e-10)

class FinancialRAGIndex:
    """Autarker In-Memory Vektor-Index fuer Finanzberichte und Bilanzen."""
    def __init__(self, embedding_dim: int = 128):
        self.embedding_dim = embedding_dim
        self.chunks: List[Dict[str, str]] = []
        self.embeddings: np.ndarray = np.empty((0, embedding_dim))

    def add_document(self, text: str, meta: Dict[str, str], chunk_size: int = 200) -> None:
        """Zerlegt Dokument in Chunks und erzeugt deterministische Pseudovektoren."""
        words = text.split()
        new_vectors = []
        for i in range(0, len(words), chunk_size):
            chunk_str = " ".join(words[i:i + chunk_size])
            self.chunks.append({"text": chunk_str, **meta})
            # Deterministisches Vektor-Mocking via Text-Hash fuer Reproduzierbarkeit
            rng = np.random.default_rng(abs(hash(chunk_str)) % (2**32))
            v = rng.standard_normal(self.embedding_dim)
            new_vectors.append(v / np.linalg.norm(v))
        if new_vectors:
            self.embeddings = np.vstack([self.embeddings, np.array(new_vectors)])

    def retrieve(self, query_text: str, top_k: int = 3) -> pd.DataFrame:
        """Findet die semantisch aehnlichsten Textbausteine fuer den LLM-Prompt."""
        rng = np.random.default_rng(abs(hash(query_text)) % (2**32))
        query_vec = rng.standard_normal(self.embedding_dim)
        query_vec = query_vec / np.linalg.norm(query_vec)
        scores = cosine_similarity_matrix(query_vec, self.embeddings)
        top_indices = np.argsort(scores)[::-1][:top_k]
        results = []
        for idx in top_indices:
            item = self.chunks[idx].copy()
            item["similarity_score"] = float(scores[idx])
            results.append(item)
        return pd.DataFrame(results)

Im institutionellen Asset Management und im Research ist absolute Verlässlichkeit gefordert. RAG bildet die technologische Grundlage, um KI-Systeme fehlerfrei mit Live-Daten und Berichten zu füttern.

Finanzanalysten müssen komplexe Kennzahlen gegen Originalberichte prüfen. RAG-Systeme durchsuchen Hunderte Seiten von 10-K- oder HGB-Filings sekundengenau und liefern die exakte Textzeile samt Seitenzahl als revisionssicheren Beleg.

Da Standard-LLMs zu plausibel klingenden Falschaussagen neigen, verhindert RAG, dass frei erfundene Bilanzergebnisse oder Zinsentwicklungen in algorithmische Handelsmodelle einfließen.

Moderne Ansätze (Graph-RAG) verknüpfen Vektorsuche mit Wissensgraphen, um komplexe Firmengeflechte, Tochtergesellschaften und Lieferkettenabhängigkeiten in Konzernberichten fehlerfrei zuzuordnen.

Der Einsatz von RAG-Systemen im Finanzsektor unterliegt strengen organisatorischen und rechtlichen Leitplanken:

• Nachvollziehbarkeit (Explainability): Jede KI-Antwort muss zwingend mit einem maschinenlesbaren Beleg verknüpft sein, um den Anforderungen von Compliance-Abteilungen zu genügen.
• Datenschutz und Vertraulichkeit: Finanzdaten unterliegen strengem Geheimhaltungsstatus; RAG-Architekturen müssen daher lokal on-premise oder in isolierten Cloud-Umgebungen betrieben werden.
• Aktualität der Vektordatenbank: Ändern sich regulatorische Vorgaben (z. B. BaFin-Richtlinien), muss die Vektordatenbank kontinuierlich synchronisiert werden, um veraltete Auskünfte auszuschließen.