AI-promptteknik · Lektion

Bortom naiv RAG

Förstå begränsningarna med grundläggande retrieval.

Lektion 1 av 413 steg

Bortom naiv RAG är en gratis lektion i AI-promptteknik på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för AI-promptteknik, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i AI-promptteknik innehåller totalt 4 lektioner.

Vad Naive RAG gör

Naive RAG är baslinjen: dela upp dokument i textblock, skapa embeddingar för dem, lagra vektorerna, skapa en embedding för frågan, hämta de top-k mest lika resultaten enligt cosinuslikhet, stoppa in textblocken i prompten och generera ett svar. Det är en stark utgångspunkt, men får förutsägbara problem när skalan ökar.

Att förstå dessa felkällor är en förutsättning för de avancerade teknikerna (omrankning, komprimering och omskrivning av frågor) som behandlas i kursen.

def naive_rag(query, k=5):
    q = embed(query)
    chunks = vector_store.search(q, k)        # top-k by cosine
    context = '\n\n'.join(c.text for c in chunks)
    return llm('Context:\n' + context + '\n\nQ: ' + query)

Recall kontra precision i hämtningen

Naiv top-k-hämtning optimerar rå vektorbaserad likhet, vilket blandar ihop relevans med ytlig semantisk närhet. Ni ställs inför en avvägning: ett litet k riskerar att missa svaret (låg recall), medan ett stort k fyller kontexten med distraktioner (låg precision).

Den embeddinglikhet som styr hämtningen är en grov approximation av verklig relevans och ligger bakom flera efterföljande problem.

# The core dilemma
# small k -> may miss the gold chunk (recall problem)
# large k -> distractors crowd context (precision + cost problem)
# Advanced RAG decouples 'retrieve many' from 'use few'

Problemet med embeddingmismatch

Frågor och dokument använder ofta olika språkliga register: en kort fråga jämfört med ett långt deklarativt textstycke. Bi-encoder-embeddingar kan placera ett relevant svar långt från frågan eftersom de är formulerade på olika sätt (problemet med vokabulärmismatch).

Detta ligger bakom tekniker som omskrivning av frågor och HyDE, som omformar frågan så att den bättre matchar dokumentrymden före hämtningen.

# Query:  'how do I revoke a token?'
# Doc:    'Token invalidation is performed via the /sessions endpoint.'
# Lexically and semantically distant -> bi-encoder may miss it
sim = cos(embed('how do I revoke a token?'),
          embed('Token invalidation via /sessions'))  # may be low

Lost-in-the-middle

Även när rätt textblock hämtas kan många textblock i prompten utlösa effekten lost-in-the-middle: modellen riktar mindre uppmärksamhet mot innehåll som placeras i mitten av en lång kontext. Ett korrekt textblock som ligger på rang 3 av 10 kan i praktiken ignoreras.

Detta motiverar omrankning (placera det bästa textblocket där modellen riktar sin uppmärksamhet) och komprimering (förminska kontexten så att inget begravs).

# Retrieval rank != attention rank
# Place the highest-relevance chunk at the START or END,
# never stranded in the middle of a large concatenation.

Känslighet för distraktorer

LLM:er är känsliga för irrelevant kontext. Om ni lägger till rimliga men felaktiga textblock kan svaret ledas fel, även när det korrekta textblocket också finns med. Mer hämtad kontext är inte automatiskt bättre.

Därför är precision viktig: en avgränsad, omrankad och komprimerad kontext överträffar ofta en stor mängd löst relaterade textblock.

# Empirically: appending a single highly-similar but WRONG chunk
# can flip a previously-correct answer. RAG quality depends on
# keeping distractors OUT, not just getting the gold chunk IN.

Problem med textblockindelning

Indelning i textblock av fast storlek delar idéer mitt i meningar, skiljer ett påstående från dess belägg och tar bort strukturell kontext (vilket avsnitt och vilket dokument). Ett textblock som verkar sammanhängande för sig kan vara oanvändbart eller vilseledande utan sin omgivning.

Avancerade pipelines använder strukturmedveten textblockindelning, överlappning, expansion till överordnade dokument och metadata för att bevara betydelsen.

def structure_aware_chunks(doc, max_tokens=400, overlap=50):
    sections = split_by_headings(doc)        # respect document structure
    chunks = []
    for sec in sections:
        for c in sliding_window(sec.text, max_tokens, overlap):
            chunks.append(Chunk(c, meta={'section': sec.title}))
    return chunks

Brister i enbart semantisk hämtning

Ren tät hämtning missar behov av exakta träffar: identifierare, felkoder, ovanliga egennamn och API-namn. Det är just i dessa fall som användare förväntar sig bokstavlig precision. Hybrid hämtning kombinerar täta (semantiska) och glesa (BM25-/nyckelordsbaserade) signaler för att täcka båda behoven.

Reciprocal rank fusion är ett enkelt och robust sätt att slå ihop de två rangordnade listorna utan att behöva justera en vikt.

def rrf(dense_ranks, sparse_ranks, k0=60):
    scores = {}
    for ranks in (dense_ranks, sparse_ranks):
        for rank, doc_id in enumerate(ranks):
            scores[doc_id] = scores.get(doc_id, 0) + 1.0 / (k0 + rank)
    return sorted(scores, key=scores.get, reverse=True)

Föråldrad och overifierbar kontext

Naive RAG har ingen uppfattning om aktualitet eller proveniens. Det kan hämta föråldrade dokument och saknar ett inbyggt sätt att koppla påståenden till källor, vilket undergräver förtroendet och gör hallucinationer svåra att upptäcka.

Avancerade system kopplar metadata till textblocken (tidsstämpel, källa och version), filtrerar utifrån den och kräver att generatorn hänvisar till textblockens ID:n så att svaren kan verifieras.

def filtered_retrieve(q, after_date):
    cands = vector_store.search(embed(q), k=50)
    fresh = [c for c in cands if c.meta['date'] >= after_date]
    return fresh  # then re-rank; generator must cite c.id

Ingen återkoppling, ingen anpassning

Naive RAG hämtar utan återkoppling: det kan inte avgöra när hämtningen misslyckades, kan inte besluta att ingen hämtning behövs och kan inte iterera. Avancerade mönster lägger till en relevanskontroll, villkorad hämtning och flerstegshämtning (agentisk hämtning) som omformulerar frågan när resultaten verkar svaga.

Pipelinen blir en loop med självbedömning i stället för ett enda framåtriktat pass.

def adaptive_rag(q):
    chunks = retrieve(q)
    if relevance_score(q, chunks) < 0.4:
        q2 = rewrite_query(q)            # reformulate and retry
        chunks = retrieve(q2)
    if relevance_score(q, chunks) < 0.4:
        return 'I could not find this in the sources.'
    return generate(q, chunks)

Den avancerade RAG-stacken

När man sammanför felkällorna består en avancerad pipeline av flera lager: strukturmedveten textblockindelning med metadata, hybrid hämtning med hög recall, en Cross-Encoder-baserad omrankare för precision, kontextkomprimering för att få plats med och fokusera kontexten, omskrivning av frågor / HyDE för att lösa mismatch och en relevansgrind med källhänvisningar.

De följande lektionerna bygger upp varje lager. Den röda tråden är: hämta brett och filtrera och förfina sedan aggressivt.

def advanced_rag(q):
    cands = hybrid_retrieve(rewrite_query(q), k=50)  # high recall
    top = rerank(q, cands)[:8]                       # precision
    ctx = compress(q, top)                            # focus + fit
    return generate_with_citations(q, ctx)            # verifiable

Mät innan ni optimerar

Diagnostisera vilket problem ni faktiskt har innan ni lägger till mer teknik. Mät recall@k för hämtningen (hämtas det korrekta textblocket över huvud taget?) separat från svarens träffsäkerhet (använder generatorn det?). Ett recall-problem och ett precisionsproblem kräver olika lösningar.

Instrumentera båda delarna. Lägg inte till en omrankare när det verkliga problemet är textblockindelning eller mismatch mellan fråga och dokument.

def diagnose(eval_set):
    return {
        'recall@5':  recall_at_k(eval_set, k=5),     # retrieval health
        'recall@50': recall_at_k(eval_set, k=50),    # ceiling with rerank
        'answer_acc': answer_accuracy(eval_set),      # generation health
    }

Snabbkontroll

Diagnostisera en felkälla i RAG.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Viktiga slutsatser:

Naive RAG (dela upp i textblock, skapa embeddingar, top-k, stoppa in och generera) är en stark baslinje med förutsägbara felkällor.
Bi-encoder-likhet är en grov approximation av relevans; mismatch mellan frågans och dokumentets språkliga register försämrar recall.
Mer kontext är inte bättre: känslighet för distraktorer och lost-in-the-middle försämrar svaren när k ökar.
Problem med textblockindelning, brister i enbart semantisk hämtning, föråldrad information och brist på återkoppling begränsar alla Naive RAG.
Avancerad RAG hämtar brett och filtrerar sedan: hybrid hämtning, omrankning, komprimering, omskrivning av frågor och relevansgrindar. Mät recall och svarens träffsäkerhet separat innan ni optimerar.

Gratis att börja

Lär dig AI-promptteknik med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 53
Lektioner: 199

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Bortom naiv RAG” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen AI-promptteknik, inklusive ”Bortom naiv RAG”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i AI-promptteknik innehåller totalt 4 lektioner.

Vad lär jag mig i ”Bortom naiv RAG”?

Förstå begränsningarna med grundläggande retrieval. Ni övar på AI-promptteknik med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig AI-promptteknik?

Du behöver inga förkunskaper. Utbildningen i AI-promptteknik på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Bortom naiv RAG”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här AI-promptteknik-lektionen?

Ja. Varje AI-promptteknik-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till AI-promptteknik