# RAG förklarade ":", ursprung och grundlagen
Har du någonsin sökt efter "implementeringsführern" och fått ingentingM SK2 trots att det finns en artikel om "utpublicering till produktionMska5 RAG mska6RettvinningMske7Augmented Generation~Mska8 löser detta genom att förstå meningen~,~ inte bara nyckelord~.~ Den här serien visar dig hur RAG kom till sig~Mske11~ hur den fungerar under kapseln~M Ska12~ och hur man bygger produktionssystem?Mska13~ Från semanticisk sök till AI?-~ kraftfulla Q?M Ska15? A med citat?—? allt med hjälp av fungerande C!
2025-11-22T09:00
# Inleiding
**Navigation** Det här är en del av RAG: s 1
- **Del 1: RAG ursprung och grundlagen** (den här artikeln) - Vad är inbäddar?
- [Del 2: RAG arkitektur och inre](/blog/rag-architecture) - ,-tokenisering
- [Del 3: RAG i praktiken](/blog/rag-practical-applications) - Att bygga kompletta RAG-system
- [Del 4a: ONNX & Garantiimplementering](/blog/semantic-search-with-onnx-and-qdrant) - CPU-vänligt semantisk sökgrund
- [Del 4b: Semantisk sökande i aktivitet](/blog/semantic-search-in-action) - Typahead, ,, hybridsökning, , och gränssnittkomponenter
- [Del 5: Hybridsökning & Auto-Indexering](/blog/rag-hybrid-search-and-indexing) - Produktionsintegreringsmönster
- [Del 6: GraphRAG](/blog/graphrag-knowledge-graphs-for-rag) - kunskapsgrafer för korpusen
RAG (Retrieval-Augmented GenerationM SK2 utvecklades för att göra AI smartare — som ger LLMs tillgång till information de inte var utbildade på . Men här är vad, ' det intressanta, ' den teknologin öppnar upp möjligheter långt bortom AI chatboter M SK9 Den ger makt till semantisk sökningar på webbsidorna Mska10 innehållsbeveelning, Mska11 hjälp när man skriver, M Ska12 och kunskapsmanagement, Mkka13
**Den dubbla naturen:** RAG kan hjälpa kunder | ( | bättre sökningar | , | korrekta svar med citationer | МSK2 | eller utnyttja dem |( | manipulativa förslag ♫ , | begravande negativa recensioner ♪ , | uppsellerande uppsellning av innehåll ♪
**Här är sanningen om RAG** Det låter skrämmande, men precis som allt annat i mjukvaran, så handlar det bara om att förstå hur den fungerar.
**RAG i tre steg:**
1. Omvandla text till siffror (inbäddar)
2. Hitta liknande tal (vectorssuche)
3. Använd vad du funnit (display results or feed to LLM
Det "'" är det "." resten är implementeringsdetails
Den här serien visar er hur man bygger RAG-system med fungerande C# kode . Inget handdragning M SK2 Inga antaganden . Bara bitar och hur de passar ihop
**Vad du kommer lära dig i den här serien**
- **Del 1 (den här artikelnM SK2**: Hur RAG skapades och varför det spelar roll
- **Del 2**: Komplett teknisk arkitektur och LLM-interner
- **Del 3**: Att bygga riktiga system med kodexempler
Senare kommer jag också visa er hur man bygger kompletta RAG-system inklusive
- [CPU-vänliga semantiska sökningar med ONNX inbäddar](/blog/semantic-search-with-onnx-and-qdrant) (Teil 4)
- [Self-drivna vektordatabaser med Qdrant](/blog/semantic-search-with-onnx-and-qdrant) (Teil 4)
- [Hybridsökning och automatisk indexering](/blog/rag-hybrid-search-and-indexing) (Teil 5)
[TOC]
# Vad är RAG?
**Uppfinning-Augmented Generation:** hitta den relevanta informationen, och använda den
```mermaid
flowchart LR
A[User Question] --> B[Retrieve Relevant Info]
B --> C[Retrieved Documents/Context]
C --> D[Generate Response]
A --> D
D --> E[Grounded, Accurate Answer]
style B stroke:#f9f,stroke-width:2px
style D stroke:#bbf,stroke-width:2px
```
**Utan RAG:** Användaren frågar → LLM gissar från minnet → kan hallucinera
**Med RAG:** Användaren frågar → Hitta relevanta dokument → LLM svara med hjälp av dessa dokument | → grundade i verkligheten
```csharp
// Without RAG: Hope the LLM knows
var answer = await llm.GenerateAsync("How do I deploy Docker?");
// Risk: Might make up outdated or wrong steps
// With RAG: Give it the docs
var relevantDocs = await vectorSearch.FindSimilar("How do I deploy Docker?");
var context = string.Join("\n", relevantDocs.Select(d => d.Text));
var answer = await llm.GenerateAsync($"Context: {context}\n\nQuestion: How do I deploy Docker?");
// Result: Answer based on YOUR actual Docker deployment docs
```
**Nyckelinsikten:** Separerade kunskapsskivor (sökningar ) från resonemang | ( | LLM | МSK3 | Datera upp dina dokument |, | sökandet stannar aktuellt
# Var kom RAG ifrån?
RAG bygger på årtionden av sökande och NLP-forskning
## Traditionella sökningar (pre-2010sM SK2
**Keyword-baserade sökningar:**
- **TF-IDF**: Lauftidsfrekvens × omvänd dokumentfrequens - vanliga ord betyder mindre
- **BM25**: Probabilistisk ranking - är fortfarande grundlinjen för sökord
- **Fuzzy matchning**:
- **Soundex**: Telefonisk algoritm ("Smith
- **Avstånd:**: Redigera avstånd ( hur många inkorporationer
- **N-Gramer**: tecken / ordsekvenser för partiellt matchning
**Problemet:** De här matchade *tecken*, inte *mening*. sök "containerorchesterning" och du kommer att vinnaM SK3 hittar du inte ♫ "Dockerswarm ♫ МSK5 ♫ om de exakta orden inte dyker upp
## Svar på tidiga frågor (2010s)
**Watson (IBM**
- Kombinerad sökning med regeln-baserade resonemang
- Won Jeopardy ! men krävde massiv hand- skapad kunskapsingenjörskonst
- Fortfarande litade vi mycket på Keyword matching
**Läsande förståelsemodeller:**
- Could extract answers from provided passages
- Men du var tvungen att ge dem rätt väg först.
- Ingen semantisk sökning för att hitta passagen
## Den djupinlärningsrevolutionen (2017+)
**Transformator (2017):** "[Attityd är allt du behöver](https://arxiv.org/abs/1706.03762)"
- Neuronätverk som kunde förstå sammanhanget
- Fundament för allt som följde
**BERT (2018):**
- Kontextuellt förståelse av språk
- "Banken, " betyder olika saker i ", flodbank, ", jämfört med ", sparande bank, "
- Could generate embeddings that captured meaning
**GPT-2/3 M SK1**
- Stora språkmodeller som kunde generera konsekvent text
- Men begränsat till deras utbildningsdata
- Hallucinationsproblem uppstod
**Dense vektorrepresentationer:**
- Text → meningsfulla siffror i hög dimension
- liknande betydelser → nära vektorer
- Detta gjorde det möjligt att göra semantiska sökningar
**BART (Facebook AI**
- Bidirektional och Auto-Regressiv förvandlare av Mike Lewis et al.
- Kombinerad BERT-liknande enkoder med GPT-liknasande dekoder
- Denoising av en självbyggare tränad av korrumperande text som sedan rekonstrueras
- Utmärkt för textskapande och förståelseuppgifter
- blev grunden för RAG
**M2**
- Först många-till-manliga flerspråkiga översättningsmodeller
- Direkt översättning mellan 100 språk utan engelska pivot
- 2,200 språkriktning (10x mer än tidigare modeller
- De visade förvandlararna kunde hantera massiva översättningar av språk
**Verklig-world example:** Min [neural machine translation tool](https://github.com/scottgal/mostlyucid-nmt) använder BART som en fallback-översättningsmodell när primära tjänster inte är tillgängliga.
## Den moderna RAGs födelse ( Maj 2020)
Det avgörande papperet "[Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks](https://arxiv.org/abs/2005.11401)" av Patrick Lewis et al
**Vad de kombinerade**
- Dense Passage Retrieval (DPR
- BART-generatör - den seq2seq-modellen från 2019
- Slutar -till - slutar différerabla arkitekturer - hämtar och genererar tillsammans
**Resultaten:** RAG-system presterade bättre än mycket större modeller på kunskap.
## Varför exploderade RAG?
ChatGPT, GPT -4, och Claude gjorde RAG nödvändigt
1. **Hallucinationsproblem** - LLMs hittar på fakta utan tvekan . RAG baserar på svar i riktiga dokument
2. **Knyvets-utbrott** - LLMs som tränats med data från 2021 vet inte om | | ' | händelser | МSK4 | RAG använder nuvarande dokument
3. **Privatdata** - LLMs kan ' inte få tillgång till ditt företag
4. **kostnaderna** - Fint-LLMs tunning är dyrt ($10KM SK3K~+). RAG är billigt | | 5 | lagring | 6 | inbäddar | 7
5. **Förklaring** - RAG kan citera källor , så att den är kontrollbar och tillförlitlig
**Idag (2024-2025):** RAG är de facto standarden för produktions-AI-system som behöver exakthet och kontrollerability
# Hur RAG fungerar: Den stora bilden
Innan vi dyker djupt in i de tekniska detaljerna ( som vi ' kommer att omfatta i del | 2), | låter ' | förstå den höga ♫ - ♫ nivån av arbetsflödet
## De tre faserna
RAG-system fungerar i tre olika stadier:
### Fasen 1: Indisering (En | - | Timing Settings
```mermaid
flowchart LR
A[Your Documents] --> B[Split into Chunks]
B --> C[Generate Embeddings]
C --> D[Store in Vector DB]
style C stroke:#f9f,stroke-width:2px
style D stroke:#bbf,stroke-width:2px
```
**Vad händer?**
1. Ta din kunskapsbas (docs, bloggar
2. Splittra in i skötbara chunks (paragrafer , sektioner)
3. Omvandla varje stycke till en vektor som inbäddar (sorter av siffror)
4. Speichera vektorer i en databas optimerad för likhetsökning
**Key concept:** Samma betydelser skapar liknande vektorer , så "Dockercontainern " och "containeriseringsplattformen M SK4 hamnar nära varandra i vektorn
### Fas 2: Tillförsel (Varenda fråga)
```mermaid
flowchart LR
A[User Question] --> B[Generate Query Embedding]
B --> C[Search Vector DB]
C --> D[Top K Most Similar Chunks]
style B stroke:#f9f,stroke-width:2px
style C stroke:#bbf,stroke-width:2px
```
**Vad händer?**
1. Användaren ställer en fråga
2. Konvertera frågan till en vektor ( Samma modell som används för indexeringM SK1
3. Hitta de mest liknande vektorerna i databasen
4. Ge uppe K de mest relevanta skivorna ( vanligtvis 3-10)
**Varför det fungerar:** " Hur ska jag utsätta behållare? ?" | | ( | fråga | ) | är semantiskt lika med fragment om Dockers utplacering
### Fas 3: Generering | ( | Varje fråga |)
```mermaid
flowchart TB
A[User Question] --> B[Build Prompt]
C[Retrieved Context] --> B
B --> D[LLM]
D --> E[Generated Answer with Citations]
style B stroke:#f9f,stroke-width:2px
style D stroke:#bbf,stroke-width:2px
```
**Vad händer?**
1. Ta user's fråga
2. Ta de hämtade kontextklossarna
3. Konstruera en prompt : "Given this context
4. skicka till LLM för att generera
5. LLM ger ett svar baserat på den förmedlade kontexten
**Magien:** LLM kan hallucinera fakta som inte finns i sammanhanget. Det kan bara syntetisera och förklara vad
## Ett enkelt exempel
Låt oss spåra en fråga genom systemet
**Användaren frågar:** " Hur använder jag Docker Compose?"
**steg 1 - Lösning**
```
Query embedding: [0.234, -0.891, 0.567, ...]
Search vector DB for similar embeddings...
Retrieved chunks:
1. "Docker Compose is a tool for defining multi-container applications..." (similarity: 0.92)
2. "To use Docker Compose, create a docker-compose.yml file..." (similarity: 0.87)
3. "The docker-compose up command starts all services..." (similarity: 0.83)
```
**steg 2 - Generering**
```
Prompt to LLM:
"Context:
[1] Docker Compose is a tool for defining multi-container applications...
[2] To use Docker Compose, create a docker-compose.yml file...
[3] The docker-compose up command starts all services...
Question: How do I use Docker Compose?
Answer (use the context above):"
LLM Response:
"To use Docker Compose [1], start by creating a docker-compose.yml file [2] that
defines your services. Then run 'docker-compose up' to start all services [3]..."
```
**Resultat:** Ett korrekt svar med implika citationer från din dokumentation.
# RAG vs. Andra angreppssätt
För att förstå när man ska använda RAG ( och när man inte ska använda ) måste man jämföra det med alternativ
## RAG vs. Bra-Tuning
| Aspect | RAG | Fin - Anpassning |
|--------|-----|-------------|
| **Nutida kunskaper** | Omedelbart | | bara uppdatera kunskapsbasen | МSK2 | | | kräver omutbildning
| **kostnaderna** | lågt | ( | lagring ♫ + | inbäddar ♫ ) | | | högt ♫ МSK5 | GPU utbildningstid ♫
| **Precision** | Begrundat i källor | | | Kan hallucinera
| **Customisering** | Begränsat med att få fram data | | | djup modellanpassning |
| **Förklaring** | Högt ( kan citera källor) | lågt ♫ ( ♫ svarta lådan ♫
| **Den bästa för** |kunskapen-intensiva uppgifter
**När ska man använda Fine-Tuning:**
- Du behöver modellen för att lära dig en specifik **styl** eller **format**
- Du har en stor, ren datauppsättning
- Man behöver modellen för att internalisera **mönster**, inte fakta
- exempel: Att få GPT att skriva som Shakespeare
**När använda RAG:**
- Du behöver **faktiska precision** med citat
- Din kunskapsbas förändras ofta
- Du har privata data
- kostnad och enkelhet
- exempel: Kundensupport chatbot (my companyM SK2docs ändras varje vecka
**Kan du kombinera båda?** Ja! BraM SK1 tur för stilen , RAG för fakta
## RAG vs. Langa Kontext Windows
Moderna LLMs skryter om enorma kontextfenster (GPT-4: 128K tokensM SK3 ClaudeMST4 | | MST5 | K token | SST6 | Varför inte bara kappa alla dina dokument i kontexten
**Problemet med lång kontext:**
1. **kostnaderna**: Pricing skalar med tokens | | - | $10-100 | per fråga ökar snabbt
2. **Tillfällighet**: Processering 100K-token tar tid
3. **Förlust i mitten**: LLMs kämpar för att använda information mitt i långa sammanhang
4. **Dilution**: relevant information göms i oväsen
5. **Praktiska gränser**: Du kan ' inte få plats med hela ditt företag
**När lång kontext är logiskt:**
- Ett enda stort dokument (e.gM SK2 för att analysera ett kontrakt
- Allt är relevant (utan behöva filtrera
- "Kosten är inte orolig"
- låg efterfrågans volym
**När RAG är logiskt:**
- Den stora kunskapsbasen (miljoner dokument
- Det behövs att hitta relevanta undergrupper
- Hög efterfrågans volym (kostnader
- Real-time-updater till kunskap
**Vad man gör bäst:** Använd RAG för att välja den mest relevanta innehållet
## RAG vs. Prompting med exempel
Väldigt få "-", Shot prompting , "(", som ger exempel i Prompt , och МSK2 , är en enkel basnivå.
**exempel prompt:**
```
Examples:
Q: What is Docker?
A: Docker is a containerization platform...
Q: How does Kubernetes work?
A: Kubernetes orchestrates containers...
Q: What is my new question?
A: [LLM generates answer]
```
**Begränsningar:**
- Begränsat till vad som passar i ett kontextfenster
- Handutskrifter av exempel
- Skalar inte till stora kunskapsbaser
- Inget semantiskt sök - så kan du manualt välja exempel
**RAG förbättring:**
- Automatiskt hittar de bästa exemplen (med hjälp av likhetssökningar)
- Skalar till oändliga exempel ( endast uppe K skickat till LLM)
- Adapterar till query (different queries retrieve different examples)
Man kan föreställa sig RAG som "automatiserad få -flygproppar på skalan ."
## Hybridsökning: RAG + Traditionellsökning
Du kan kombinera RAG med traditionell full search -text genom Reciprocal Rank Fusion (RRF).
**Varför hybrida?**
- **Semantiska sökningar**: Bra för konceptuella matchar (" felbekämpning
- **Keywords-sökning**: Bra för exakta villkor ("Docker Compose
- **Hybrid**: Den bästa av båda världarna
```csharp
public async Task> HybridSearchAsync(string query)
{
// Run both searches in parallel
var semanticTask = SemanticSearchAsync(query, limit: 20);
var keywordTask = KeywordSearchAsync(query, limit: 20);
await Task.WhenAll(semanticTask, keywordTask);
var semanticResults = await semanticTask;
var keywordResults = await keywordTask;
// Combine using Reciprocal Rank Fusion
return ApplyRRF(semanticResults, keywordResults);
}
private List ApplyRRF(
List list1,
List list2,
int k = 60)
{
var scores = new Dictionary();
// Score from first list
for (int i = 0; i < list1.Count; i++)
{
var id = list1[i].Id;
scores[id] = scores.GetValueOrDefault(id, 0) + 1.0 / (k + i + 1);
}
// Score from second list
for (int i = 0; i < list2.Count; i++)
{
var id = list2[i].Id;
scores[id] = scores.GetValueOrDefault(id, 0) + 1.0 / (k + i + 1);
}
// Merge and sort by combined score
var allResults = list1.Concat(list2)
.GroupBy(r => r.Id)
.Select(g => g.First())
.OrderByDescending(r => scores[r.Id])
.ToList();
return allResults;
}
```
# Varför RAG spelar roll
Nu när ni förstår vad RAG är, varifrån kommer det, och hur det jämförs med alternativa, så är det viktigt
**1. Demokratisering av AI**
- Du behöver inte en beskattning
- Du behöver inte ett team av ML-ingenjörer
- Alla utvecklare kan bygga RAG-system med existerande verktyg
**2. Praktisk noggrannhet**
- Hallucinationer är det #1 problemet med LLMs i produktion
- RAG löser det genom att basera på svar i riktiga dokument
- Citationer gör det kontrollbart och tillförlitligt
**3. alltid uppåt**
- Traditionell AI: Train once , kunskap är frusen
- RAG: Datera upp dina dokument, kunskapsaktualiseringar omedelbart
- Kritiskt för snabba domains
**4. Privatliv och kontroll**
- Din data stannar i din infrastruktur
- Kan köra fullständigt lokalt (lokala embeddings + lokal LLM ♫ ♫ + ♫ Lokala vektor DB ♫
- Ingen data skickad till OpenAI eller andra cloud-provider
**5. kostnad - Effektiv**
- Storage är billigt (pennies per GB)
- Embedding är billigt (fraktioner av en cent per 1000 dokument
- Mycket billigare än fin-passning eller långa kontextfenster
**6. varierande tillämpningar**
- Semantiska sökningar ( inget LLM behövs!)
- Q&A system med citat
- innehållsrecommendation
- Redare
- kunskapsmanagement
- Dokumentationsassistenter
- Forskningsassistenter
# slutsats : Från historien till implementation
Vi har spårat RAGs utveckling
- **Pre-2010s**: Keyword search
- **2010s**: Förståelsen för läsning ( krävde rätt passage
- **2017-2020**: Omvandlare och inbäddar (medvetande → vektorer)
- **2020**: Modern RAG (avlägsna ♫ ♫ + ♫ generera ♫
- **2023-Present**: produktionsstandard
**Nyckelinsikter från del 1:**
- RAG separerar **kunskapslager** (vector DB) från **resonemang** (LLM)
- Det löser hallucinationsproblemet genom att basera reaktioner på riktiga dokument
- Det är billigare och mer flexibelt än det fina
- Det fungerar bättre än en lång kontext för stora kunskapsbaser
- Det är i grund och botten
**Den treste mentala modellen**
1. Omvandla text till siffror (inbäddar)
2. Hitta liknande tal (vectorssuche)
3. Använd vad du har funnit (display eller mata till LLM
Allt annat är optimering.
# Continue to Part 2: Architecture and Internals
Ni förstår nu **vad** RAG är, **varför** det spelar roll **var** den kom från ".". Men hur funkar den egentligen under kapseln?
I **[Del 2: RAG arkitektur och inre](/blog/rag-architecture)**, dyker vi djupt in i tekniska detaljer
**Komplett RAG-torn**
- Fasen 1: Indexering ( textextraktion | , | blockeringsstrategier |, | embedding generation |
- Fas 2: Tillförsel ( sökintegreringar , likhetsmätriker
- Fasen 3: Generering ( snabbt konstruerad konstruktion, LLM-parameternM SK3 efterprocessingMSC4 bearbetande
**LLM insidan:**
- Vad är tokens och varför de är viktiga för RAG
- KV cache: Hur LLMs minns kontexten
- Kontextfenster och tokenshanteringsstrategier
- Optimering av RAG för tokeneffektivitet och kostnad
**Teknikliga djupdykar:**
- Vektordatabaser och liknande sökalgoritmer
- Embedding av modeller och normalisering
- Maskerande strategier som bevarar kontext
- Praktiska exempel på koder i C#
**[Continue to Part 2: Architecture and Internals →](/blog/rag-architecture)**
Efter del 2, kommer du | ' | vara redo för del ♪ 3, | där vi bygger riktiga system | , | lösa vanliga problem |, | och utforska avancerade tekniker som HyDE | МSK5 | multi | - | sök RAG | , | samt kontextuell kompression |.
## resurser
**Grunddokument:**
- [Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks](https://arxiv.org/abs/2005.11401) - Den ursprungliga RAG pappret
- [Dense Passage Retrieval for Open-Domain Question Answering](https://arxiv.org/abs/2004.04906) - DPR
- [Attityd är allt du behöver](https://arxiv.org/abs/1706.03762) - Transformatorer ( inbyggd grund )
**Weiterlesen:**
- [Hur Neurola maskinöversättning fungerar](/blog/how-neural-machine-translation-works) - Understanding the AI models behind embeddings
**Nästa i denna serie:**
- [Del 2: RAG arkitektur och inre](/blog/rag-architecture) - Teknikligt djupdykning
- [Del 3: RAG i praktiken](/blog/rag-practical-applications) - Att bygga riktiga system
**[Fortsätt till del 2 →](/blog/rag-architecture)**