Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Komplet RAG-pipeline

Lektion 14 af 18 Opdateret 2. november 2026 Udvikler
På denne side
  1. Samling af det hele
  2. Den komplette pipeline
  3. Kørsel af pipeline’en
  4. Fem retninger for yderligere forbedring
  5. Vigtige pointer

Samling af det hele

De foregående lektioner har dækket hvert led i kæden separat: indlæsning, opdeling i bidder (chunking), kodning, indeksering, hentning og generering. Nu er det tid til at svejse dem sammen til ét komplet, end-to-end program, som du kan køre med det samme og derefter tilpasse til dine egne dokumenter. Dette script passer i én fil og kræver kun fire afhængigheder.

pip install mistralai faiss-cpu numpy requests

Den komplette pipeline

To designvalg strukturerer denne kode. For det første samler vi al konfiguration øverst i filen: modeller, chunk-størrelse, batch-størrelse og TOP_K er navngivne konstanter. Det sparer dig for at skulle lede efter hard-codede værdier begravet inde i funktioner, når du skal finjustere adfærden. For det andet opdeler vi logikken i seks uafhængige funktioner, der hver svarer til ét trin og udskriver deres fremskridt som [n/6]. Denne sporning er ikke bare pynt: Når pipeline’en fejler eller returnerer et mærkeligt svar, fortæller den dig med det samme, om problemet ligger i indlæsning, opdeling eller hentning. Hver funktion kan også udskiftes isoleret – du kan fx indsætte en PDF-indlæser til load_data uden at røre resten.

Funktionen main kæder trinnene sammen og stiller derefter spørgsmål til korpusset med tre spørgsmål om Paul Graham-essayet, der bruges som vores demo-datasæt. Bemærk, at hentning og generering kører inde i løkken, mens indeksering kun sker én gang på forhånd: At genkode hele korpusset for hvert spørgsmål ville være absurd både med hensyn til omkostninger og ventetid.

import os
import json
import numpy as np
import faiss
import requests
from mistralai.client import Mistral

# ============================================================
# Configuration
# ============================================================
MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY")
EMBED_MODEL = "mistral-embed"
CHAT_MODEL = "mistral-large-latest"
CHUNK_SIZE = 2048
BATCH_SIZE = 25
TOP_K = 3

client = Mistral(api_key=MISTRAL_API_KEY)


# ============================================================
# Step 1: Load Data
# ============================================================
def load_data(url):
    """Load a text document from a URL."""
    print("[1/6] Loading data...")
    response = requests.get(url)
    response.raise_for_status()
    text = response.text
    print(f"  -> {len(text)} characters loaded")
    return text


# ============================================================
# Step 2: Create Chunks
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
    """Split text into chunks."""
    print("[2/6] Creating chunks...")
    chunks = []
    paragraphs = text.split("\n\n")
    current = ""

    for para in paragraphs:
        para = para.strip()
        if not para:
            continue
        if len(current) + len(para) + 2 <= chunk_size:
            current = current + "\n\n" + para if current else para
        else:
            if current:
                chunks.append(current)
            current = para

    if current:
        chunks.append(current)

    print(f"  -> {len(chunks)} chunks created (avg size: {sum(len(c) for c in chunks) // len(chunks)} chars)")
    return chunks


# ============================================================
# Step 3: Generate Embeddings
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
    """Encode chunks into embeddings via mistral-embed."""
    print("[3/6] Generating embeddings...")
    all_embeddings = []

    for i in range(0, len(chunks), batch_size):
        batch = chunks[i:i + batch_size]
        response = client.embeddings.create(
            model=EMBED_MODEL,
            inputs=batch,
        )
        all_embeddings.extend([d.embedding for d in response.data])
        print(f"  -> Batch {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1} encoded")

    embeddings = np.array(all_embeddings, dtype=np.float32)
    print(f"  -> Matrix: {embeddings.shape}")
    return embeddings


# ============================================================
# Step 4: Create FAISS Index
# ============================================================
def create_index(embeddings):
    """Create and populate a FAISS index."""
    print("[4/6] Creating FAISS index...")
    dimension = embeddings.shape[1]
    index = faiss.IndexFlatL2(dimension)
    index.add(embeddings)
    print(f"  -> Index: {index.ntotal} vectors, dimension {dimension}")
    return index


# ============================================================
# Step 5: Retrieve Relevant Chunks
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
    """Retrieve the most relevant chunks."""
    print(f"[5/6] Searching for: '{question[:50]}...'")
    response = client.embeddings.create(
        model=EMBED_MODEL,
        inputs=[question],
    )
    query_vector = np.array([response.data[0].embedding], dtype=np.float32)

    distances, indices = index.search(query_vector, k)

    results = []
    for dist, idx in zip(distances[0], indices[0]):
        if idx >= 0:
            results.append({
                "text": chunks[idx],
                "distance": float(dist),
            })

    print(f"  -> {len(results)} chunks retrieved")
    return results


# ============================================================
# Step 6: Generate Answer
# ============================================================
def generate(question, context_chunks):
    """Generate the answer using retrieved context."""
    print("[6/6] Generating answer...")

    context = "\n\n---\n\n".join([c["text"] for c in context_chunks])

    prompt = f"""Informative context:

{context}

---

Based ONLY on the context above, answer the following question precisely and completely.

Question: {question}"""

    response = client.chat.complete(
        model=CHAT_MODEL,
        messages=[
            {"role": "system", "content": "You are an assistant that answers based on the provided context."},
            {"role": "user", "content": prompt},
        ],
        temperature=0.1,
    )

    answer = response.choices[0].message.content
    print(f"  -> Answer generated ({len(answer)} characters)")
    return answer


# ============================================================
# Main Pipeline
# ============================================================
def main():
    """Run the complete RAG pipeline."""
    # 1. Load
    url = "https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt"
    text = load_data(url)

    # 2. Chunk
    chunks = create_chunks(text)

    # 3. Encode
    embeddings = create_embeddings(chunks)

    # 4. Index
    index = create_index(embeddings)

    # 5+6. Question -> Answer
    questions = [
        "What were the two main things the author worked on before college?",
        "What did the author do during their time at Y Combinator?",
        "What programming language did the author learn first?",
    ]

    for question in questions:
        print(f"\n{'='*60}")
        context = retrieve(question, index, chunks)
        answer = generate(question, context)
        print(f"\nQ: {question}")
        print(f"A: {answer}")


if __name__ == "__main__":
    main()

Kørsel af pipeline’en

Gem denne kode som rag_pipeline.py, eksportér din API-nøgle i miljøet – hard-cod den aldrig direkte i filen, da den før eller siden ender i et repository – og kør derefter scriptet. Outputtet guider dig gennem de seks trin og behandler derefter de tre spørgsmål med deres svar. Hvis et svar virker irrelevant, så sammenlign det med de chunks, der vises i trin 5, før du giver genereringsmodellen skylden.

export MISTRAL_API_KEY="your-api-key"
python rag_pipeline.py

Fem retninger for yderligere forbedring

Denne pipeline er et fundament, ikke et færdigt produkt, og hver af dens begrænsninger peger mod et næste skridt. Det mest umiddelbare er persistens: I sin nuværende form genkoder scriptet hele korpusset ved hver kørsel, hvorimod det at gemme FAISS-indekset og chunks ville gøre efterfølgende kørsler næsten øjeblikkelige. Re-ranking er næste niveau, hvor FAISS-resultater sendes gennem en cross-encoder, der bedømmer relevans langt mere præcist end vektorafstand alene. Metadata-filtrering adresserer et andet behov: At begrænse søgningen efter dato, kategori eller forfatter udover lighedsmål. To sidste forbedringer fokuserer på brugeroplevelsen: Streaming, der viser svaret, mens det genereres, i stedet for efter flere sekunders stilhed, og samtalehistorik, der lader brugere følge op med „hvad med version 2?” uden at skulle gentage hele deres spørgsmål.

# 1. Save the index to avoid recalculating
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))

# 2. Add re-ranking
# After FAISS retrieval, use a cross-encoder model
# to re-order results by fine-grained relevance

# 3. Metadata filtering
# Add filters (date, category, author) in addition
# to vector similarity

# 4. Response streaming
# Use client.chat.stream() to display the answer
# as it generates

# 5. Conversation history
# Add previous exchanges to the prompt
# for a contextual RAG chatbot

Vigtige pointer

  • Den komplette RAG-pipeline opdeles i 6 trin: indlæs, opdel, kod, indeksér, hent, generér
  • Hvert trin er en uafhængig funktion, der er nem at teste og udskifte
  • Brug temperature=0.1 til faktuelle svar
  • Gem FAISS-indekset og embeddings for at undgå genberegning ved hver kørsel
  • Denne pipeline er et solidt udgangspunkt, som du kan berige efter dine behov