Retrieval-Augmented Generation

Have you ever encountered a scenario like this:

  • You have a product manual that’s hundreds of pages long, and a user asks a very specific question. You search for a long time but can’t find where the answer is.

  • Your company has accumulated several years of internal documents, meeting minutes, and technical specifications. New employees who want to understand a particular business rule have no idea where to even start looking.

  • You have a pile of ebooks, research reports, and papers, and you want AI to answer questions based on this content, but if you paste the entire book directly to AI, the context window won't fit it.

This is the problem RAG aims to solve.

RAG (Retrieval-Augmented Generation) is a technology that enables large language models to answer questions based on specific knowledge bases.。

The core idea of RAG is simple: first retrieve the most relevant content from your knowledge base, then send that content together with the user's question to the LLM, and let the LLM answer based on this context.

Without RAG, the LLM only knows what's in its training data; with RAG, the LLM can use your private, up-to-date data.


Why is RAG needed?

RAG is not the only solution to these problems, but it is currently one of the most practical and lowest-cost options.

LLM knowledge cutoff issue.

  • All LLMs have a knowledge cutoff date—the training data only goes up to a certain point in time, and it doesn't know about events after that.

  • For example, GPT-4's knowledge cutoff is October 2023. If you ask it about news from 2024, it can only say 'I don't know.'

  • More importantly, your private data (internal documents, product manuals, company policies) has never appeared in the LLM's training data—how could it possibly know?

Private data cannot be directly input into an LLM.

You might think: can't I just paste the documents directly into the LLM?

The answer is: short documents work, but long documents don't.

  • First, the LLM's context window is limited. For example, GPT-3.5 only has 16K tokens, roughly 10,000 characters. A manual of several hundred pages simply won't fit.

  • Second, even if the context window is large enough, stuffing the entire document in doesn't work well. LLMs tend to get lost in long text and fail to find the truly relevant information.

  • Finally, there's the cost. GPT-4 with a 128K context costs $10 per million input tokens. If you stuff a whole book in every time, your wallet will cry.

RAG vs Fine-tuning: How to Choose

Another way to give an LLM new data is fine-tuning—continuing to train the model with new data.

But fine-tuning and RAG are fundamentally different, with entirely different use cases:

VergleichspunktRAGFine-Tuning
Data freshnessCan be updated at any time, immediately usableRequires retraining, long cycle
Applicable data volumeVery large (millions of documents)Medium (thousands to tens of thousands of samples)
Citation sourceCan show which document the answer comes fromCannot trace the source
Hallucination problemReduces hallucinations by providing contextMay still hallucinate
Modifying knowledgeSimply delete or update documentsRequires retraining, hard to 'forget'
Technical barrierRelatively low, can use existing frameworksRelatively high, requires GPU and training experience
KostenMainly vector database and EmbeddingHigh training cost, and high inference cost as well

A simple rule of thumb: if you want the LLM to "know" certain factual knowledge (such as product descriptions, company policies), use RAG; if you want the LLM to "learn" a certain style or capability (such as writing style, code conventions), use fine-tuning.


RAG Architecture Overview

RAG is divided into two phases: the offline indexing phase and the online retrieval phase.

First, let's look at a complete architecture diagram:

RAG 整体架构流程图

Offline indexing stage (data preparation)

This phase runs in the background, and users won't see it directly.

Its task is to process your documents into a format that can be quickly retrieved.

The steps are as follows:

  • 1. Document loading: Read documents in various formats such as PDF, TXT, DOCX, and web pages.

  • 2. Document splitting: Split long documents into smaller text chunks, usually a few hundred to a thousand words.

  • 3. Vectorization: Use an Embedding model to convert each text chunk into a vector (a string of numbers).

  • 4. Storage: Store the vectors and original text together in a vector database.

This phase only needs to be done once, or rerun when documents are updated.

Online retrieval stage (user query)

This phase happens in real time when the user asks a question.

The steps are as follows:

  • 1. Question vectorization: Use the same Embedding model to convert the user's question into a vector as well.

  • 2. Similarity retrieval: Find the text chunks closest to the question vector in the vector database.

  • 3. Build Prompt: Use the retrieved text chunks as context, and assemble them together with the user's question into a Prompt.

  • 4. LLM generation: Send the Prompt to the LLM, and let it answer based on the context.

  • 5. Return the answer: Return the LLM's answer to the user, usually along with the cited document sources.


Einführung in Vektordatenbanken

Die Vektordatenbank ist eine der Kernkomponenten von RAG. Um sie zu verstehen, müssen Sie zunächst verstehen, was ein Vektor ist.

Was ist ein Vektor (Embedding)?

Ein Vektor (Embedding) ist eine aus Text konvertierte Zeichenfolge von Zahlen.

Das Wort „Katze“ könnte beispielsweise in einen Vektor mit mehreren Hundert Dimensionen wie [0.23, -0.45, 0.12, 0.89, ...] konvertiert werden.

Der entscheidende Punkt ist:Texte mit ähnlicher Semantik haben Vektoren, die im Raum nahe beieinander liegen.。

Zum Beispiel:

  • Der Vektorabstand zwischen „Katze“ und „Kätzchen“ ist sehr gering.
  • Der Vektorabstand zwischen „Katze“ und „Hund“ ist geringer als zwischen „Katze“ und „Auto“.
  • Der Vektorabstand zwischen „Ich mag Katzen“ und „Ich liebe Katzen“ ist sehr gering.

Dies ist die Grundlage für die „semantische Suche“ – das Abgleichen nach Bedeutung, nicht nach Schlüsselwort.

Das Berechnungsprinzip der semantischen Ähnlichkeit.

Die Ähnlichkeit zweier Vektoren wird normalerweise mithilfe der „Kosinus-Ähnlichkeit“ berechnet.

Der Bereich der Kosinus-Ähnlichkeit liegt zwischen -1 und 1:

  • 1 bedeutet exakt gleich
  • 0 bedeutet in keiner Beziehung zueinander
  • -1 bedeutet völlig entgegengesetzt

In der Praxis kümmern wir uns normalerweise nur um positive Ähnlichkeit; je näher an 1, desto relevanter.

Wenn Sie eine Frage stellen, berechnet die Vektordatenbank schnell die Ähnlichkeit zwischen dem Fragevektor und allen Dokumentenvektoren und gibt die relevantesten Top-Ergebnisse zurück.

Gängige Vektordatenbanken

Es gibt viele Vektordatenbanken auf dem Markt, jede mit ihren eigenen Merkmalen:

DatenbankTypeFunktionenAnwendungsfälle
ChromaLokal/Open SourceLeichtgewichtig, einfach zu bedienen, Python-freundlichPrototyping, klein angelegte Anwendungen
PineconeCloud-Dienst/SaaSVerwalteter Dienst, keine Betriebsprozesse erforderlich, elastische SkalierungProduktionsumgebungen, groß angelegte Anwendungen
WeaviateOpen Source/VerwaltetFunktionsreich, unterstützt GraphQLSzenarien, die fortgeschrittene Funktionen erfordern
QdrantOpen Source/VerwaltetHohe Leistung, in Rust geschriebenSzenarien mit hohen Leistungsanforderungen
MilvusOpen Source/VerwaltetUmfassende Funktionen, Enterprise-GradeGroß angelegte Unternehmenseinrichtungen
FAISSLokale BibliothekVon Facebook, extrem schnellSzenarien, in denen keine Persistenz erforderlich ist

Für Anfänger empfehlen wir, mit Chroma zu beginnen – es ist einfach zu installieren, erfordert keine zusätzliche Konfiguration und eignet sich hervorragend zum Lernen und Prototyping.


Dokumentenverarbeitungs-Workflow

Die Dokumentenverarbeitung ist ein in RAG leicht zu übersehender, aber tatsächlich sehr wichtiger Schritt.

Ob Ihre Suche gut funktioniert, hängt größtenteils davon ab, wie gut die Dokumente verarbeitet werden.

Unterstützte Dokumentformate.

LangChain unterstützt viele Dokumentformate:

  • Reiner Text: .txt, .md
  • PDF: .pdf
  • Office: .docx, .pptx, .xlsx
  • Websites: HTML, URL
  • Code: .py, .js, .java usw.
  • JSON: .json, .jsonl
  • CSV: .csv

Jedes Format hat einen entsprechenden Loader, was die Verwendung sehr bequem macht.

Strategie zur Dokumentensegmentierung

Das Dokumenten-Chunking ist der Prozess des Aufteilens langer Dokumente in kleinere Teile.

Das klingt einfach, birgt jedoch viele Feinheiten:

  • Zu klein: Kontext kann verloren gehen, eine vollständige Bedeutung wird abgeschnitten
  • Zu groß: Kann irrelevante Informationen enthalten, wodurch das Kontextfenster verschwendet wird

Gängige Chunking-Strategien:

StrategiePrinzipAnwendbare Szenarien
Nach ZeichenanzahlEinfache Aufteilung nach Zeichenanzahl, z. B. alle 500 Zeichen pro ChunkEinfache Szenarien mit geringen Kontextanforderungen
Nach AbsatzAufteilung nach Zeilenumbruchzeichen, wobei Absätze so intakt wie möglich bleibenGut formatierte Dokumente
Rekursives ChunkingZuerst Absätze bevorzugen, bei zu großer Länge Sätze und schließlich WörterDie erste Wahl für die meisten Szenarien
Semantisches ChunkingAufteilung basierend auf semantischer Ähnlichkeit, um die semantische Vollständigkeit sicherzustellenSzenarien mit hohen semantischen Anforderungen

In den meisten Fällen reicht die Verwendung von RecursiveCharacterTextSplitter von LangChain aus.

Tipps zur Auswahl der Segmentierungsgröße

Chunk Size ist ein Parameter, der an das jeweilige Szenario angepasst werden muss.

Einige Richtlinien als Referenz:

  • Frage-Antwort-Szenarien: 500-1000 Zeichen, genug, um ein vollständiges Frage-Antwort-Paar zu enthalten
  • Zusammenfassungsszenarien: 1000-2000 Zeichen, mehr Kontext ist erforderlich
  • Code-Szenarien: Kann nach Funktion oder Klasse aufgeteilt werden, wodurch Codeblöcke intakt bleiben

Es gibt auch einen wichtigen Parameter: Overlap – die Anzahl der überlappenden Zeichen zwischen benachbarten Text-Chunks.

Overlap kann verhindern, dass wichtige Informationen auf zwei Chunks aufgeteilt werden, und wird normalerweise auf 10%-20% der Chunk-Größe eingestellt.

Jagen Sie nicht blind nach „optimalen“ Chunking-Parametern. Beginnen Sie mit 500 Zeichen und 50 Überlappungen, testen Sie die tatsächlichen Ergebnisse und passen Sie sie dann an.


Embedding-Modell

Ein Embedding-Modell ist ein Modell, das Text in Vektoren konvertiert.

Seine Qualität beeinflusst direkt die Suchleistung – ein gutes Embedding-Modell kann die Semantik präzise verstehen und relevante Dokumente weiter oben einordnen.

Was ist ein Embedding-Modell?

Ein Embedding-Modell ist ein vortrainiertes neuronales Netz, das Text als Eingabe entgegennimmt und Vektoren ausgibt.

Sein Trainingsziel ist: Für Texte mit ähnlicher Semantik sollten auch die ausgegebenen Vektoren ähnlich sein.

Zum Beispiel:

  • „Wie man Python lernt“ und „Methoden zum Erlernen von Python“ → Vektoren liegen nah beieinander
  • „Katzen sind süß“ und „Welpen sind süß“ → Vektoren sind etwas entfernt, aber dennoch relativ nah
  • „Wie man Python lernt“ und „Katzen sind süß“ → Vektorabstand ist sehr weit

OpenAI text-embedding-3-Serie

OpenAI bietet derzeit die beliebtesten Embedding-Modelle an:

ModellDimensionenPreis (pro Million Token)Funktionen
text-embedding-3-small1536$0.02Hohe Kosteneffizienz, ausreichend für die meisten Szenarien
text-embedding-3-large3072$0.13Bessere Leistung, geeignet für Anforderungen mit hoher Präzision

text-embedding-3-small ist derzeit die erste Wahl – es leistet mehr als die vorherige Generation text-embedding-ada-002 und ist günstiger.

Open-Source-Embedding-Modell

Wenn Sie OpenAI nicht verwenden möchten oder Anforderungen an den Datenschutz haben, gibt es auch viele Open-Source-Optionen:

ModellDimensionenFunktionen
sentence-transformers/all-MiniLM-L6-v2384Leichtgewichtige, schnelle und ordentliche Leistung
sentence-transformers/all-mpnet-base-v2768Bessere Leistung, aber langsamer und größer
BAAI/bge-large-zh-v1.51024Speziell für Chinesisch optimiert
Alibaba-NLP/gte-large-zh1024Von Alibaba erstellt, gute Leistung bei Chinesisch

Für chinesische Szenarien empfehlen wir die BAAI/bge-Serie oder die Alibaba-NLP/gte-Serie – sie sind speziell für Chinesisch optimiert und leisten mehr als Allzweckmodelle.


Retrieval-Strategie

Die Suche ist nicht so einfach wie „die relevantesten Dokumente finden“ – unterschiedliche Strategien passen zu unterschiedlichen Szenarien.

Vektor-Ähnlichkeitssuche

Dies ist die gängigste Suchmethode: Berechnen Sie die Ähnlichkeit zwischen dem Vektor der Frage und allen Dokumentvektoren und geben Sie die Top-K-relevantesten zurück.

Vorteile: Versteht Semantik, Synonyme und Beinahe-Synonyme können alle abgeglichen werden.

Nachteile: Bei präzisen Begriffen und Eigennamen möglicherweise weniger genau als die Stichwortsuche.

Wenn ein Benutzer beispielsweise „Beispiel-Python-Tutorial“ fragt, kann die Vektorsuche verstehen, dass „Tutorial“ und „Kurs“ ähnlich sind. Wenn der Benutzer jedoch „Beispiel Python3.10 Dokumentation“ fragt, ist die Stichwortsuche möglicherweise genauer.

Stichwortsuche (BM25)

Dies ist die Methode herkömmlicher Suchmaschinen: Schlüsselwörter abgleichen und basierend auf Begriffshäufigkeit, inverser Dokumenthäufigkeit usw. bewerten.

  • Vorteile: Effektiv für die exakte Übereinstimmung von Begriffen, Produktnamen, Modellnummern usw.

  • Nachteile: Kann keine Synonyme oder semantischen Beziehungen verstehen.

Wenn ein Benutzer beispielsweise fragt, wie man das Programmieren lernt, kann die Stichwortsuche nur Dokumente finden, die „Programmieren“ enthalten, und keine Dokumente, die „Code schreiben“ sagen, aber dasselbe meinen.

Hybride Suche

Da beide Methoden ihre Vor- und Nachteile haben, warum sie nicht zusammen verwenden?

Die hybride Suche führt gleichzeitig eine Vektorsuche und eine Stichwortsuche durch und führt dann die Ergebnisse zusammen und ordnet sie neu an.

Auf diese Weise kann sie das semantische Verständnis nutzen und gleichzeitig eine exakte Übereinstimmung sicherstellen.

Viele Vektordatenbanken unterstützen die hybride Suche, wie Weaviate, Pinecone, Qdrant usw.

Wenn Sie sich nicht sicher sind, welche Sie verwenden sollen, wählen Sie die hybride Suche – in den meisten Fällen funktioniert sie am besten.


Optimierung der Generierungsphase

Das Abrufen relevanter Dokumente ist nur der erste Schritt. Es gibt auch viele Techniken, um das LLM dazu zu bringen, basierend auf diesen Dokumenten gute Antworten zu generieren.

Prompt-Template-Design

Das Prompt-Template ist ein Schlüsselfaktor, der die Ausgabequalität bei RAG beeinflusst.

Ein gutes RAG-Prompt enthält normalerweise:

  • Rollenfestlegung: Sagen Sie dem LLM, welche Rolle es hat
  • Kontext: Der Inhalt des abgerufenen Dokuments
  • Aufgabenbeschreibung: Was das LLM tun soll
  • Einschränkungen: Zum Beispiel „Antworten Sie nur basierend auf dem Kontext“ und „Wenn Sie es nicht wissen, sagen Sie, dass Sie es nicht wissen“
  • Ausgabeformat: Wie das LLM antworten soll

Ein klassisches Template:

Beispiel

# Ein typisches RAG-Prompt-Template
RAG_PROMPT_TEMPLATE = """Sie sind ein professioneller {role}.
Bitte beantworten Sie die Frage des Benutzers basierend auf dem folgenden Kontext. Wenn der Kontext keine relevanten Informationen enthält, sagen Sie „Entschuldigung, ich konnte keine relevanten Informationen finden.“

Kontext:
{context}

Benutzerfrage: {question}

Bitte antworten Sie in prägnanter und präziser Sprache: """

Wie reduziert man Halluzinationen?

Halluzination ist das Phänomen, bei dem ein LLM Fakten erfindet – es kann sehr überzeugend klingen, ist aber frei erfunden.

RAG kann Halluzinationen reduzieren, sie aber nicht vollständig beseitigen.

Einige Techniken zur Reduzierung von Halluzinationen:

  • Betonen Sie im Prompt „Nur basierend auf dem Kontext antworten“
  • Lassen Sie das LLM in seinen Antworten Auszüge aus dem Originaltext zitieren
  • Wenn die Suchergebnisse irrelevant sind, lassen Sie das LLM „Ich weiß es nicht“ sagen
  • Verwenden Sie mehrere LLMs, um Antworten gegenseitig zu validieren
  • Lassen Sie das LLM zuerst relevante Inhalte aus dem Kontext finden und dann antworten

Quellenangaben-Annotation

Es ist wichtig, die Benutzer wissen zu lassen, woher die Antwort stammt – dies erhöht nicht nur die Glaubwürdigkeit, sondern erleichtert den Benutzern auch die Überprüfung.

Gängige Praktiken:

  • Markieren Sie die Quelle in der Antwort, z. B. „gemäß Dokument A, Seite 2“
  • Listen Sie die Titel und Links von Referenzdokumenten am Ende der Antwort auf
  • Ermöglichen Sie Benutzern, auf den Originaltextspeicherort zu klicken und dorthin zu springen

Einige fortgeschrittene Frameworks in LangChain (wie LlamaIndex) können dies automatisch für Sie tun.


Praxis: Aufbau eines Dokument-Frage-Antwort-Systems basierend auf LangChain

Genug geredet – lassen Sie uns praktisch werden und ein vollständiges RAG-System aufbauen.

Wir werden LangChain + Chroma + OpenAI verwenden, um ein Dokument-Frage-Antwort-System aufzubauen.

Umgebungseinrichtung

Installieren Sie zuerst die erforderlichen Bibliotheken:

pip install langchain langchain-openai langchain-chroma python-dotenv

Erstellen Sie dann eine .env-Datei im Projektverzeichnis und tragen Sie Ihren OpenAI-API-Schlüssel ein:

OPENAI_API_KEY=你的-api-key-在这里

Vollständige Code-Implementierung

Dies ist ein vollständiges RAG-System, einschließlich Indexerstellung und Abfragefunktionalität:

Beispiel

# ============================================
# Vollständige Implementierung des RAG-Dokument-Frage-Antwort-Systems
# ============================================

import os
from dotenv import load_dotenv
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma
from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
from langchain.schema import Document


def load_documents_from_directory(directory: str) -> list[Document]:
    """Dokumente aus Verzeichnis laden
Zu Demonstrationszwecken erstellen wir manuell einige Dokumente
In tatsächlichen Projekten können Sie DirectoryLoader verwenden, um reale Dateien zu laden
    """

    documents = [
        Dokumentation(
            page_content="""Die BEISPIEL-Tutorial-Website wurde 2013 gegründet und vom Rookie-Tutorial-Team ins Leben gerufen.
Die Website zielt darauf ab, leicht verständliche Programmiertutorials für Programieranfänger bereitzustellen.
Wir bieten Tutorials für mehrere Programmiersprachen an, darunter HTML, CSS, JavaScript, Python, Java, C++ und mehr."""
,
            metadata={"source": "example_intro.txt", "page": 1}
        ),
        Dokumentation(
            page_content="""Das Python-Tutorial von EXAMPLE deckt alle wichtigen Wissenspunkte von Python ab.
Einschließlich: Python-Grundsyntax, Datentypen, Kontrollanweisungen, Funktionen, Module, Dateioperationen usw.
Das Tutorial bietet eine große Anzahl von Codebeispielen, die jeweils sorgfältig entworfen und getestet wurden.
Wir bieten auch einen Online-Python-Editor an, mit dem Sie Code direkt in Ihrem Browser ausführen können."""
,
            metadata={"source": "python_tutorial.txt", "page": 1}
        ),
        Dokumentation(
            page_content="""EXAMPLE-Tutorials zeichnen sich durch prägnante Inhalte, reichhaltige Beispiele und einen Fokus auf die Praxis aus.
Wir glauben, dass „der beste Weg, das Programmieren zu lernen, das Schreiben von Code ist“.
Daher wird jeder Wissenspunkt von ausführbaren Codebeispielen begleitet, sodass Sie gleichzeitig lernen und üben können.
Unsere Tutorials sind völlig kostenlos und jeder kann darauf zugreifen und lernen."""
,
            metadata={"source": "features.txt", "page": 1}
        ),
        Dokumentation(
            page_content="""Neben Text-Tutorials bietet EXAMPLE auch Video-Tutorials an.
Video-Tutorials sind intuitiver und eignen sich für visuelle Lernende.
Unsere Video-Tutorials decken beliebte Themen wie Python, Webentwicklung, Datenanalyse und mehr ab.
Sie finden unsere Videos auf Bilibili und YouTube."""
,
            metadata={"source": "video_course.txt", "page": 1}
        ),
    ]
    print(f"Loaded {len(documents)} documents")
    return documents


def split_documents(documents: list[Document], chunk_size: int = 500, chunk_overlap: int = 50) -> list[Dokumentation]:
    """Split documents"""
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=chunk_size,
        chunk_overlap=chunk_overlap,
        length_function=len,
        separators=["\n\n", "\n", "。", "!", "?", ",", " ", ""],
    )
    splits = text_splitter.split_documents(documents)
    print(f"Split {len(documents)} documents into {len(splits)} text chunks")
    return splits


def create_vector_store(splits: list[Document], persist_directory: str = "./chroma_db") -> Chroma:
    """Create vector database"""
    embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
    vector_store = Chroma.from_documents(
        documents=splits,
        embedding=embeddings,
        persist_directory=persist_directory,
    )
    print(f"Vector database created, with a total of {vector_store._collection.count()} records")
    return vector_store


def load_vector_store(persist_directory: str = "./chroma_db") -> Chroma:
    """Bestehende Vektordatenbank laden"""
    embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
    vector_store = Chroma(
        persist_directory=persist_directory,
        embedding_function=embeddings,
    )
    print(fVector database loaded, total {vector_store._collection.count()} records)
    return vector_store


def create_rag_chain(vector_store: Chroma):
    """Create RAG Q&A chain"""

    # Custom Prompt template
    template = """You are a professional EXAMPLE customer service assistant.
Please answer the user's question based on the following context. If the context does not contain relevant information, say "Sorry, I did not find relevant information."
Keep the answer concise and clear, using Chinese.

Kontext:
{context}

Benutzerfrage: {question}

Answer: """


    prompt = PromptTemplate(
        template=template,
        input_variables=["context", "question"],
    )

    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

    # Create retrieval chain
    rag_chain = RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",
        retriever=vector_store.as_retriever(search_kwargs={"k": 3}),
        chain_type_kwargs={"prompt": prompt},
        return_source_documents=True,
    )

    return rag_chain


def main():
    """Main function"""
    # Umgebungsvariablen laden
    load_dotenv()

    # Check if database already exists
    db_exists = os.path.exists("./chroma_db") and os.path.isdir("./chroma_db")

    if db_exists:
        print("Found existing database, loading...")
        vector_store = load_vector_store()
    else:
        print("Creating new database...")
        # 1. Load documents
        docs = load_documents_from_directory("./data")
        # 2. Split documents
        splits = split_documents(docs)
        # 3. Create vector database
        vector_store = create_vector_store(splits)

    # 4. Create RAG chain
    rag_chain = create_rag_chain(vector_store)

    # 5. Test queries
    test_questions = [
        "When was EXAMPLE founded?",
        "What are the features of EXAMPLE's Python tutorial?",
        "Does EXAMPLE have video tutorials?",
        "How to learn C++ on EXAMPLE?",
        "Do EXAMPLE's tutorials require payment?",
    ]

    for question in test_questions:
        print(f"\n{'='*60}")
        print(f"Frage: {question}")
        print(f"{'='*60}")

        result = rag_chain.invoke({"query": question})
        answer = result["result"]
        sources = result["source_documents"]

        print(f"Antwort: {answer}")
        print("\nReference sources:")
        for i, doc in enumerate(sources, 1):
            print(f" [{i}] {doc.metadata['source']} (page {doc.metadata['page']})")
            print(f" Snippet: {doc.page_content[:50]}...")


if __name__ == "__main__":
    main()

Wenn Sie dieses Programm ausführen, sehen Sie eine Ausgabe ähnlich dieser:

创建新的数据库...
已加载 4 个文档
已将 4 个文档切分为 4 个文本块
向量数据库已创建,共 4 条记录

============================================================
问题:EXAMPLE 是什么时候创立的?
============================================================
回答:EXAMPLE 教程网站创立于 2013 年。

参考来源:
  [1] example_intro.txt (第 1 页)
      片段:EXAMPLE 教程网站创立于 2013 年,由Example团队创建。...
  [2] features.txt (第 1 页)
      片段:除了文字教程,EXAMPLE 还提供了视频教程。...

============================================================
问题:EXAMPLE 的 Python 教程有什么特点?
============================================================
回答:EXAMPLE 的 Python 教程涵盖了 Python 的所有重要知识点,包括基础语法、数据类型、控制语句、函数、模块、文件操作等,并且提供了大量经过精心设计和测试的代码示例,还提供了在线 Python 编辑器,可以直接在浏览器中运行代码。

参考来源:
  [1] python_tutorial.txt (第 1 页)
      片段:EXAMPLE 的 Python 教程涵盖了 Python 的所有重要知识点。...
  [2] features.txt (第 1 页)
      片段:EXAMPLE 教程的特点是内容简洁、示例丰富、注重实践。...

Herzlichen Glückwunsch! Sie haben erfolgreich ein vollständiges RAG-Dokumenten-Q&A-System aufgebaut.


Erweiterte Optimierung: Re-Ranking, HyDE

Grundlegendes RAG funktioniert, aber wenn Sie bessere Ergebnisse erzielen möchten, können Sie diese erweiterten Optimierungsmethoden ausprobieren.

Re-Ranking

Die Ergebnisse der Vektorsuche werden nach Ähnlichkeit sortiert, aber eine hohe Ähnlichkeit bedeutet nicht zwangsläufig, dass es die passendste Antwort auf die Frage ist.

Re-Ranking bedeutet: Zuerst wird die Vektorsuche verwendet, um die Top-K-Ergebnisse zurückzugeben (z. B. 20), dann wird ein präziseres Modell verwendet, um diese Ergebnisse neu zu sortieren, und die besten davon werden ausgewählt, um an das LLM gesendet zu werden.

Gängige Re-Ranking-Modelle:

  • cross-encoder/ms-marco-MiniLM-L-6-v2
  • BAAI/bge-reranker-large

Obwohl dies einen zusätzlichen Schritt hinzufügt, ist die Verbesserung der Ergebnisse offensichtlich und lohnenswert.

HyDE (Hypothetical Document Embedding)

HyDE ist eine clevere Idee: Verwenden Sie zuerst das LLM, um eine „hypothetische Antwort“ auf die Frage des Benutzers zu generieren, und verwenden Sie dann diese hypothetische Antwort für die Suche.

Warum ist das effektiv? Weil Fragen normalerweise kurz sind und eine geringe Informationsdichte aufweisen; während hypothetische Antworten länger sind, eher den Stil von Dokumenten haben und eine höhere Ähnlichkeit mit realen Dokumenten aufweisen.

Zum Beispiel:

  • Benutzerfrage: „Wann wurde EXAMPLE gegründet?“
  • Hypothetische Antwort: „Die Tutorial-Website EXAMPLE wurde 2013 vom Rookie-Tutorial-Team gegründet mit dem Ziel, qualitativ hochwertige Tutorials für Programieranfänger bereitzustellen.“

Die Verwendung der hypothetischen Antwort für die Suche findet oft relevantere Dokumente.

Weitere Erweiterungen