This is a viewer only at the moment see the article on how this works.
To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk
This is a preview from the server running through my markdig pipeline
Архітектура RAG і інтер 'єри: Як вона дійсно працює
Saturday, 22 November 2025
В Частина 1, ми розглянули RAG, ' про походження, основи, і чому це важливо. Ви розумієте концепцію високого рівня- МSK6 отримати важливу інформацію, потім використати її для генерації відповідей. Зараз ми занурюємось глибоко в технічну архітектуру— точно, як RAG системи працюють під капюшоном, від стратегії групування до інтерфейсів LLM, таких як टोकони та кві-キャッシュи.
Введение
Навігація серії 📖 Це частина 2 серії RAG МSK1
- Частина 1: Походження та основи - ІсторіяM SK1 мотивація, та основні концепції
- Частина 2: Архітектура та внутрішні ( цей artykułM SK1 - Технический глибокий подив на те, як працює RAG
- Частина 3: RAG в практиці - Збудування реальних систем , виклики МSK2 та передові технології
- Частина 4aM SK1 ONNX & Гарантійне вdrożenie - Процесор - приємна база семантичного пошуку
- Частина 4bM SK1 Семантичний пошук в дії - Типова головка , гібридні пошуки МSK2 і інтерфейс
- Частина 5: Гібридне пошук МSK1 АвтоM SK2 Індексування - Моделі інтеграції виробництва
- Частина 6: GraphRAG - Графи знань для корису -зрозуміння рівня
Якщо ви не читали частини ', я рекомендую починати з них, щоб зрозуміти
- Що таке РАГ і чому він важливий
- Історія від пошуку ключів до семантичного розуміння
- RAG проти fine-tuning та інших підходів
Ця стаття передбачає, що ви розумієте ці основи і зосереджуєтесь на технічна архітектура, деталі розробкиM SK1 і інтерфейси LLM.
Як працює RAG: Це повне зображення
Дозвольте розібратися, що відбувається в РАГ-системі з того моменту, коли ви додаєте до нього документ і отримуєте відповідь
Фаза МСК0 Індексування МСК1 Подготовка бази знань )
Перед тим, як RAG зможе отримати будь-що, вам потрібно indeksувати свою базу знаньM SK1 Це одинMSC2часовий процес ( хоча ви можете додавати нові документи пізніше ).
flowchart TB
A[Source Documents] -->|1. Extract Text| B[Text Extraction]
B -->|2. Split into Chunks| C[Chunking Service]
C -->|3. Generate Embeddings| D[Embedding Model]
D -->|4. Store Vectors| E[Vector Database]
B -.Metadata.-> E
subgraph "Example: Blog Post"
F["Understanding Docker: A containerization platform..."]
end
subgraph "Chunks"
G["Chunk 1: Title + Intro"]
H["Chunk 2: Benefits Section"]
end
subgraph "Embeddings"
I["0.234, 0.891, 0.567, ..."]
J["0.445, 0.123, 0.789, ..."]
end
F --> G
F --> H
G --> I
H --> J
style D stroke:#f9f,stroke-width:2px
style E stroke:#bbf,stroke-width:2px
Шаг 1: Видобуток tekstu
Візьміть простий текст з ваших джерельних документів. Це могло б бути
- Файлі відмітки (подібні до моїх блогових постів
- PDF (для документаціїM SK1
- HTML ( для веб-шкрапування)
- Дані з бази даних
- E-mailи, журнали чатівM SK1 і т.д.
Ось приклад з мого блогу:
// From MarkdownRenderingService
public string ExtractPlainText(string markdown)
{
// Remove code blocks
var withoutCode = Regex.Replace(markdown, @"```[\s\S]*?```", "");
// Convert markdown to plain text
var document = Markdown.Parse(withoutCode);
var plainText = document.ToPlainText();
return plainText.Trim();
}
Шаг 2:
Це місце, де більшість RAG-implementацій провалюються. Ви можете' не розділятися лише на кордони абзаців M SK2 вам потрібні семантично послідовні фрагментиMSC3
Чому відокремлення має значення:
- LLM мають обмеження символів (контекстні вікнаM SK1
- Менькі шматочки = більш точне відтворення
- Але шматки повинні мати достатньо контексту, щоб бути змістовними
Погане відрізання:
Chunk 1: "Docker is a containerization platform. It allows you"
Chunk 2: "to package applications with their dependencies. This"
Chunk 3: "ensures consistency across environments."
Хороший шматок:
Chunk 1: "Docker is a containerization platform. It allows you to package applications with their dependencies. This ensures consistency across environments."
Chunk 2: "Benefits of Docker:
- Isolation: Each container runs in its own environment
- Portability: Containers run anywhere Docker is installed
- Efficiency: Lightweight compared to virtual machines"
Ось приклад із моєї семантичного пошуку:
public class TextChunker
{
private const int TargetChunkSize = 500; // ~500 words
private const int ChunkOverlap = 50; // 50 words overlap
public List<Chunk> ChunkDocument(string text, string sourceId)
{
var chunks = new List<Chunk>();
// Split on section boundaries first (## headers in markdown)
var sections = SplitOnHeaders(text);
foreach (var section in sections)
{
// If section is small enough, keep it whole
if (section.WordCount < TargetChunkSize)
{
chunks.Add(new Chunk
{
Text = section.Text,
SourceId = sourceId,
SectionHeader = section.Header
});
}
else
{
// Split large sections on sentence boundaries
var subChunks = SplitOnSentences(section.Text, TargetChunkSize, ChunkOverlap);
chunks.AddRange(subChunks.Select(c => new Chunk
{
Text = c,
SourceId = sourceId,
SectionHeader = section.Header
}));
}
}
return chunks;
}
}
Bendrі стратегії відокремлення:
- Фиксований- розмір: Просте, але руйнує семантичні межі
- Sentence-based: Поважає граматику, але може бути надто малим
- Paragraph-based: Природний, але змінний розмір
- Розділ-на основі: Найкраще для структурованого контенту ( моя перевага
- Sliding window with overlap: Обіцяє, що на кордонах не втрачається жодний контекст
Шаг 3: генерувати додатки
Вбудова - це магія, яка робить можливим семантичний пошук.
Ключева концепція: Схожі значення → подібні вектори
"Docker container" → [0.234, -0.891, 0.567, ..., 0.123]
"containerization platform" → [0.221, -0.903, 0.534, ..., 0.119]
"apple fruit" → [0.891, 0.234, -0.567, ..., -0.789]
Перші два вектори будуть: "закритий " у векторному просторі МSK2велика схожість косину МSK3, тоді як третій дуже далекий
Як генерується вбудова: Нові вбудовані моделі - це нейронні мережі, навчені вивчати семантичні відносини на масивних текстових наборах даних.
- всіМSK0MiniLM-LM SK2v2МСК0 384 виміри МSK2 швидке , хороша якість МСК4 те, що я використовую на цьому блогі
- текст-введення-3-маленький (OpenAI): 1536 виміриM SK3 дуже висока якість
- БазаМSK0 768 виміриM SK2 стан-зMSC4з-арт відкритий вихідний код
До прикладу з моєї OnNX вбудованої usługi:
public async Task<float[]> GenerateEmbeddingAsync(string text)
{
// Tokenize the input text
var tokens = Tokenize(text);
// Create input tensors for ONNX model
var inputIds = CreateInputTensor(tokens);
var attentionMask = CreateAttentionMaskTensor(tokens.Length);
var tokenTypeIds = CreateTokenTypeIdsTensor(tokens.Length);
// Run ONNX inference
var inputs = new List<NamedOnnxValue>
{
NamedOnnxValue.CreateFromTensor("input_ids", inputIds),
NamedOnnxValue.CreateFromTensor("attention_mask", attentionMask),
NamedOnnxValue.CreateFromTensor("token_type_ids", tokenTypeIds)
};
using var results = _session.Run(inputs);
// Extract the output (sentence embedding)
var output = results.First().AsTensor<float>();
var embedding = output.ToArray();
// L2 normalize the vector for cosine similarity
return NormalizeVector(embedding);
}
Чому нормальність важлива: Після об 'єднання L2 звичайності , схожість косину перетворюється на простий дотиковий продукт МSK2, що робить пошук набагато швидшим
Шаг 4: Поміщати в векторній базі даних
Вektorні бази даних оптимізовані для зберігання та пошуку високого рівня векторів.
Ключові операції:
- Помістити: Додайте або оновлюйте вектор з метаданками
- Поиск: Найти вektorи K, що найбільш подібні до вектора запиту
- Фильтр: Об 'єднати векторний пошук з метаданними
Наприклад, Implementation Qdrant:
public async Task IndexDocumentAsync(
string id,
float[] embedding,
Dictionary<string, object> metadata)
{
var point = new PointStruct
{
Id = new PointId { Uuid = id },
Vectors = embedding,
Payload =
{
["title"] = metadata["title"],
["source"] = metadata["source"],
["chunk_index"] = metadata["chunk_index"],
["created_at"] = DateTime.UtcNow.ToString("O")
}
};
await _client.UpsertAsync(
collectionName: "blog_posts",
points: new[] { point }
);
}
Найпопулярніші векторні бази даних:
- Кдрант: швидкий , самодостатній МSK2 приватний МSK3 чудовий C мSK4 підтримка M( мій вибір МСК6
- pgvector: Расширення PostgreSQL
- Pinecone: Управляемая служба МSK1 дорогі, але хорошіM SK2
- Вов 'язати: ФункціяM SK1багато, добре для складних схем
- ХromaDB: Python-фокусованийM SK2 легкий
Ми ' дослідимо створення цих баз даних у майбутніх статтях .
Фаза 2: Діагностика МSK1Винайти важливу інформаціюM SK2
Коли пользователь задає питання, система RAG має знайти найсучаснішу інформацію з бази знань.
flowchart LR
A["User Query:<br/>'How do I use Docker Compose?'"] --> B[Generate Query Embedding]
B --> C["Query Vector:<br/>[0.445, -0.123, ...]"]
C --> D[Vector Search]
D --> E[Vector Database]
E --> F[Top K Similar Chunks]
F --> G["Results:<br/>1. Docker Compose Basics 0.92<br/>2. Multi-Container Setup 0.87<br/>3. Service Configuration 0.83"]
style B stroke:#f9f,stroke-width:3px
style D stroke:#bbf,stroke-width:3px
Шаг 1: генерувати вбудова питання
Питання користувача' конвертується в вектор, використовуючи одна і та сама модель вмонтування використовується для індексування. Це критично M SK1 різні моделі виробляють неповносправні вектори.
public async Task<List<SearchResult>> SearchAsync(string query, int limit = 10)
{
// Same embedding model used for indexing
var queryEmbedding = await _embeddingService.GenerateEmbeddingAsync(query);
// Search in vector store
var results = await _vectorStoreService.SearchAsync(
queryEmbedding,
limit
);
return results;
}
Шаг 2: Поиск схожості
Вektorна база даних обчислює схожість між вектором запиту та усіми збереженими векторами.
Схожість косину (самій популярний для стандартизованих векторівM SK1
similarity = (A · B) / (||A|| × ||B||)
Різниця: : -1 до МSK2 МSK3
Евклидська відстань ( для ненормальних векторів
distance = sqrt(Σ(Ai - Bi)²)
Різниця: M SK1 до ∞ ♫ ♫ МSK3 ♫ нижче ♫ = ♫ більш схожа ♫) ♫
Продукт крапки ( коли вектори є передідущими МSK1нормалізовані МSK2
similarity = A · B
Різниця: : -1 до МSK2 МSK3
Ось приклад мого сервісу Qdrant.
var searchResults = await _client.SearchAsync(
collectionName: "blog_posts",
vector: queryEmbedding,
limit: (ulong)limit,
scoreThreshold: 0.7f, // Only return results with >70% similarity
payloadSelector: true // Include all metadata
);
return searchResults.Select(hit => new SearchResult
{
Text = hit.Payload["text"].StringValue,
Title = hit.Payload["title"].StringValue,
Score = hit.Score,
Source = hit.Payload["source"].StringValue
}).ToList();
Шаг 3: Перетягування (Optional but Recommended)
Початкове відтворення швидке, але приблизне. Переrankування використовує більш складну модель, щоб оцінити верхні результати KM SK1
flowchart LR
A[Vector Search:<br/>Top 50 Results] --> B[Reranking Model]
B --> C[Reranked:<br/>Top 10 Results]
style B stroke:#f9f,stroke-width:3px
Чому переоцінювання допомагає:
- Швидкі моделі вмонтування оптимізуються для швидкості,, при цьому втрачаючи певну точність
- Моделі переrankування повільніші, але більш точні
- Двоє кроків на рівні - збалансують швидкість та якість
До прикладу - переоцінювання.
public async Task<List<SearchResult>> SearchWithRerankAsync(
string query,
int initialLimit = 50,
int finalLimit = 10)
{
// Stage 1: Fast vector search
var candidates = await SearchAsync(query, initialLimit);
// Stage 2: Precise reranking
var rerankedResults = await _rerankingService.RerankAsync(
query,
candidates
);
return rerankedResults.Take(finalLimit).ToList();
}
Фаза 3: генерація МSK1 створення відповіді МSK2
Тепер, коли ми маємо важливу інформацію, ми додаємо її до LLM разом з питанням користувача
flowchart TB
A[User Query] --> B[Retrieved Context 1]
A --> C[Retrieved Context 2]
A --> D[Retrieved Context 3]
B --> E[Construct Prompt]
C --> E
D --> E
A --> E
E --> F["System: You are a helpful assistant...\n\nContext:\n1. Docker Compose allows...\n2. Services are defined...\n3. Volumes persist data...\n\nQuestion: How do I use Docker Compose?\n\nAnswer:"]
F --> G[LLM]
G --> H[Generated Answer with Citations]
style E stroke:#f9f,stroke-width:2px
style G stroke:#bbf,stroke-width:2px
Шаг 1: Проста конструкція
Тут RAG стає артом. Потрібно структурувати про prompt так, щоб LLM
- Використовує наданий контекст (не його внутрішні знанняM SK1
- Виражає джерела, коли це можливо
- Визначає, коли контекст не містить відповіді
- Утримує послідовний тон
Наприклад, шаблон прохання від моєї адвокатської системи GPT:
public string BuildRAGPrompt(string query, List<SearchResult> context)
{
var sb = new StringBuilder();
sb.AppendLine("You are a technical writing assistant. Your task is to answer the user's question using ONLY the provided context from past blog posts.");
sb.AppendLine();
sb.AppendLine("CONTEXT:");
sb.AppendLine("========");
for (int i = 0; i < context.Count; i++)
{
sb.AppendLine($"[{i + 1}] {context[i].Title}");
sb.AppendLine($"Source: {context[i].Source}");
sb.AppendLine($"Content: {context[i].Text}");
sb.AppendLine($"Relevance: {context[i].Score:P0}");
sb.AppendLine();
}
sb.AppendLine("========");
sb.AppendLine();
sb.AppendLine("INSTRUCTIONS:");
sb.AppendLine("- Answer the question using the provided context");
sb.AppendLine("- Cite sources using [1], [2], etc.");
sb.AppendLine("- If the context doesn't contain enough information, say so");
sb.AppendLine("- Maintain the technical, practical tone of the blog");
sb.AppendLine();
sb.AppendLine($"QUESTION: {query}");
sb.AppendLine();
sb.AppendLine("ANSWER:");
return sb.ToString();
}
Шаг 2: LLM Інференція
Сконструйований про prompt переходить до LLM для генерації. Це може бути
- Хмарний API: OpenAI, Anthropic ClaudeM SK2 Google PaLM
- Локальна модель: Використовуючи ламу
Наприклад, локальний LLM:
public async Task<string> GenerateResponseAsync(string prompt)
{
var result = await _llamaSharp.InferAsync(prompt, new InferenceParams
{
Temperature = 0.7f, // Creativity (0 = deterministic, 1 = creative)
TopP = 0.9f, // Nucleus sampling
MaxTokens = 500, // Response length limit
StopSequences = new[] { "\n\n", "User:", "Question:" }
});
return result.Text.Trim();
}
Пояснення ключових параметрів:
- Температура: Kontrolує випадковість МSK1 МSK2 завжди вибирає найбільш ймовірнісіньку вибірку
- Верхня П: Зразок နлюсу - розглядає лише символи, що складають верхню масу ймовірності P
- Максимальні символи: Длина реагування
- Запинити послідовності: Коли припинити генерувати
Шаг 3: Пост МSK1 Процедура
Після того, як LLM генерує відповідь, нам часто потрібноM SK1
- Витягніть цитати і перетворіть їх на посилання
- Блоки коду
- Додайте метадані (источникиM SK1 показники довіриМSK2
- Зареєструвати взаємодію для виправлення
Наприклад, пост-обробкаM SK1
public RAGResponse PostProcess(string llmOutput, List<SearchResult> sources)
{
var response = new RAGResponse
{
Answer = llmOutput,
Sources = new List<Source>()
};
// Extract citations like [1], [2]
var citations = Regex.Matches(llmOutput, @"\[(\d+)\]");
foreach (Match match in citations)
{
int index = int.Parse(match.Groups[1].Value) - 1;
if (index >= 0 && index < sources.Count)
{
var source = sources[index];
response.Sources.Add(new Source
{
Title = source.Title,
Url = GenerateUrl(source.Source),
RelevanceScore = source.Score
});
}
}
// Convert markdown citations to hyperlinks
response.FormattedAnswer = Regex.Replace(
llmOutput,
@"\[(\d+)\]",
m => {
int index = int.Parse(m.Groups[1].Value) - 1;
if (index >= 0 && index < sources.Count)
{
var url = GenerateUrl(sources[index].Source);
return $"[[{m.Groups[1].Value}]]({url})";
}
return m.Value;
}
);
return response;
}
Усвідомлення інтерфейсу LLM: Tokens, KV CacheM SK2 і контексту Windows
Перед тим, як перейти до практичних застосувань, це ' важливе зрозуміти, як LLM працюють всередині
Що таке टोकони?
Торки - це фундаментальні одиниці, які обробляють LLMs.
Наприклад, символізація:
Input: "Understanding Docker containers"
Tokens: ["Under", "standing", " Docker", " containers"]
Різні моделі використовують різні стратегії маркування:
- Моделі GPT: Використовуйте ByteM SK1Encoding pair (BPE) з словником МSK4K
- Клойд: Схожий підхід BPE
- Леламські моделі: Значення SentencePiece
Чому символізація важлива для RAG:
public class TokenCounter
{
// Rough approximation: 1 token ≈ 0.75 words (English)
public int EstimateTokens(string text)
{
var wordCount = text.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length;
return (int)(wordCount / 0.75);
}
public int EstimateTokensAccurate(string text, ITokenizer tokenizer)
{
// Use actual tokenizer for precision
return tokenizer.Encode(text).Count;
}
}
Контекстові обмеження вікна:
- Торки GPT-3.5: M SK1K
- ГПЗМСК0 МSK1КМСК2К टोकенів (в залежності від варіації МСК4
- Клойд 3.5 Сонет МSK1 МSK2 К-токени
- Ллама 3: МSK1 К-токени МSK2 хоча їх можна розширити )
В РАG системах, ви повинні підлаштуватисяM SK1
Total tokens = System prompt + Retrieved context + User query + Response buffer
Якщо ваш RAG відібрає 10 документи 500 символів кожен МSK2 то МSK3 символи лише для контексту \ - перед запитом та відповіддю
Практичне управління символами РАG:
public class ContextWindowManager
{
private readonly int _maxContextTokens;
private readonly int _systemPromptTokens;
private readonly int _responseBufferTokens;
public ContextWindowManager(
int totalContextWindow = 4096,
int systemPromptTokens = 300,
int responseBufferTokens = 500)
{
_maxContextTokens = totalContextWindow;
_systemPromptTokens = systemPromptTokens;
_responseBufferTokens = responseBufferTokens;
}
public List<SearchResult> FitContextInWindow(
List<SearchResult> retrievedDocs,
string query)
{
var queryTokens = EstimateTokens(query);
// Available tokens for retrieved context
var availableForContext = _maxContextTokens
- _systemPromptTokens
- queryTokens
- _responseBufferTokens;
var selectedDocs = new List<SearchResult>();
var currentTokens = 0;
foreach (var doc in retrievedDocs.OrderByDescending(d => d.Score))
{
var docTokens = EstimateTokens(doc.Text);
if (currentTokens + docTokens <= availableForContext)
{
selectedDocs.Add(doc);
currentTokens += docTokens;
}
else
{
break; // Context window full
}
}
return selectedDocs;
}
private int EstimateTokens(string text)
{
// Rule of thumb: 1 token ≈ 4 characters
return text.Length / 4;
}
}
Таємна зброя KV Cache
Коли LLM генерує текст, він не переробляє все з нуля для кожного символу. Key-Value (KVM SK2 Cache щоб пам 'ятати, що він вже обчислив.
Як працюють трансформатори (СпрощеноM SK1
Перетворники використовують механізм "attention", де кожен символ "спостерігає за
flowchart TB
subgraph "Generation Step 1: 'Docker'"
A1[Input: 'Docker'] --> B1[Compute K,V for 'Docker']
B1 --> C1[Store in KV Cache]
C1 --> D1[Generate: 'is']
end
subgraph "Generation Step 2: 'is'"
A2[Input: 'is'] --> B2[Compute K,V for 'is']
B2 --> C2[Store in KV Cache]
C2 --> E2[Retrieve KV for 'Docker']
E2 --> F2[Attend: 'is' to 'Docker']
F2 --> D2[Generate: 'a']
end
subgraph "Generation Step 3: 'a'"
A3[Input: 'a'] --> B3[Compute K,V for 'a']
B3 --> C3[Store in KV Cache]
C3 --> E3[Retrieve KV for 'Docker', 'is']
E3 --> F3[Attend: 'a' to all previous]
F3 --> D3[Generate: 'container']
end
D1 --> A2
D2 --> A3
style C1 stroke:#f9f,stroke-width:3px
style C2 stroke:#f9f,stroke-width:3px
style C3 stroke:#f9f,stroke-width:3px
Без кві-касу:
- Шаг 1: Процедура МSK1 символ МSK2 OM SK3
- Шаг 2: Процес МSK1 टोकони з нуля → OM SK3
- Шаг 3: Процес МSK1 टोकони з нуля → OM SK3
- Загалом МСК0 ОМСК1 МSK2 2 МSK4 3
З квіталізатором KV:
- Шаг 1: Процес МSK1 символ МSK2 кэш KM SK3V → O(1)
- Шаг 2: Процедура МSK1 новий символ МSK2 повторне використання вキャッシュі KM SK3V → O(1)
- Шаг 3: Процедура МSK1 новий символ МSK2 повторне використання вキャッシュі KM SK3V → O(1)
- ЗагаломМСК0 ОМSK1N)
Це робить покоління значно швидше - різниця між МSK1 टोकенамиМСК2секундом та МСК3 टोकентамиMСК4секундиМ СК5
Структура KV Cache Tree
KV-каш утворює "деревоM SK1 через те, як працює навага в трансформаторах . Кожна поверхня у моделі має свою власну матрицю K
graph TB
A[Input Tokens:<br/>'What is Docker?'] --> B[Layer 1 Attention]
B --> C[Layer 1 KV Cache]
B --> D[Layer 2 Attention]
D --> E[Layer 2 KV Cache]
D --> F[Layer 3 Attention]
F --> G[Layer 3 KV Cache]
F --> H[... up to Layer N]
H --> I[Output: 'Docker is']
C -.Key-Value pairs<br/>for all input tokens.-> C
E -.Key-Value pairs<br/>for all input tokens.-> E
G -.Key-Value pairs<br/>for all input tokens.-> G
style C stroke:#bbf,stroke-width:2px
style E stroke:#bbf,stroke-width:2px
style G stroke:#bbf,stroke-width:2px
Кожен шар зберігає:
- Ключи (KM SK1: Відображання, що використовують для обчислення балів уваги
- Ціни (VM SK1: Виступи, які змішуються на основі уваги
Для моделі з:
- 32 шари
- 4096 приховані виміри
- 32 головки уваги
- 8K context window
Кіш KV для однієї послідовності це:
2 (K and V) × 32 layers × 4096 dimensions × 8192 tokens × 2 bytes (FP16)
≈ 4.3 GB of VRAM!
Ось чому довгі контекстні вікна - це пам 'ять
KV Cache в системах RAG
Системи RAG можуть використати оптимізацію квіталізованої пам 'яті в розумних способах:
Про prompt Caching (Prompt caching) ( підтримують деякі API, такі як Anthropic Claude
public class CachedRAGService
{
// System prompt and retrieved context can be cached!
public async Task<string> GenerateWithCachedContextAsync(
string systemPrompt, // Cached
List<SearchResult> context, // Cached
string userQuery) // Not cached, changes each time
{
var contextText = FormatContext(context);
// The KV cache for systemPrompt + contextText is reused across queries
var prompt = $@"
{systemPrompt}
CONTEXT:
{contextText}
QUERY: {userQuery}
ANSWER:";
return await _llm.GenerateAsync(prompt, useCaching: true);
}
}
Чому це потужне:
- Перше запитання: Вираховує KV-каш для системного прохання M SK1 контекст (повільний)
- Наступні питання з таким же контекстом: Повторює заキャッシュованим KV M SK1x швидше!)
- Лише частина питання користувача потребує свіжого обчислення
Практичний приклад:
Query 1: "How do I use Docker?" → 2 seconds (no cache)
Query 2: "What are Docker benefits?" → 0.2 seconds (cache hit!)
Query 3: "Docker vs VMs?" → 0.2 seconds (cache hit!)
Усі три питання використовують той самий отриманий контекст, таким чином, квітаційний кэш для цього контексту повторюється.
Ограничення символів та стратегія RAG
Усвідомлення токенів та квішового ховища допомагає вам прийняти рішення щодо архітектури RAG:
1. розміри
Менькі шматочки = точніше відтворення , але більший об 'єм МSK2
// Option A: Small chunks (200 tokens each)
// Retrieve 20 chunks = 4,000 tokens
// Pro: Very precise, only relevant info
// Con: More KV cache entries, slower attention
// Option B: Larger chunks (500 tokens each)
// Retrieve 8 chunks = 4,000 tokens
// Pro: Better context coherence, fewer KV entries
// Con: More noise, less precise
public class AdaptiveChunker
{
public int DetermineChunkSize(int contextWindowSize)
{
if (contextWindowSize <= 4096)
return 200; // Small chunks for limited windows
if (contextWindowSize <= 16384)
return 500; // Medium chunks
return 1000; // Large chunks for big windows
}
}
2. Застосування контекстного вікна
Don't max out the context window M SK1 leave room for generation
public class SafeContextManager
{
public int GetSafeContextLimit(int totalContextWindow)
{
// Use only 75% for input, reserve 25% for output
return (int)(totalContextWindow * 0.75);
}
// Example: 4K model
// Total: 4096 tokens
// Safe input: 3072 tokens
// Reserved for output: 1024 tokens
}
3. МультифріальнийM SK1Ввімкніть RAG Обговорення
В чатботах, історія розмов зростає з кожним поворотомM SK1
Turn 1:
System + Context + Query1 = 3000 tokens
Response1 = 300 tokens
Total: 3300 tokens
Turn 2:
System + Context + Query1 + Response1 + Query2 = 3650 tokens
Response2 = 300 tokens
Total: 3950 tokens
Turn 3:
System + Context + Query1 + Response1 + Query2 + Response2 + Query3 = 4250 tokens
ERROR: Context window exceeded!
Рішення: Sliding window with reM SK1retrieval
public class ConversationalRAG
{
private readonly int _maxHistoryTokens = 1000;
public async Task<string> ChatAsync(
List<ConversationTurn> history,
string newQuery)
{
// Re-retrieve context based on current query
var context = await RetrieveContextAsync(newQuery);
// Keep only recent conversation history
var relevantHistory = TrimHistory(history, _maxHistoryTokens);
var prompt = BuildPrompt(context, relevantHistory, newQuery);
return await _llm.GenerateAsync(prompt);
}
private List<ConversationTurn> TrimHistory(
List<ConversationTurn> history,
int maxTokens)
{
var trimmed = new List<ConversationTurn>();
var currentTokens = 0;
// Keep most recent turns
foreach (var turn in history.Reverse())
{
var turnTokens = EstimateTokens(turn.Query) + EstimateTokens(turn.Response);
if (currentTokens + turnTokens <= maxTokens)
{
trimmed.Insert(0, turn);
currentTokens += turnTokens;
}
else
{
break;
}
}
return trimmed;
}
}
4. Оптимізація вартості टोकена
API-засадові LLM платять за один токенM SK1 RAG може вибухнути, якщо не бути обережним:
public class CostAwareRAG
{
// OpenAI GPT-4 pricing (example):
// Input: $0.03 per 1K tokens
// Output: $0.06 per 1K tokens
public decimal EstimateQueryCost(
int systemPromptTokens,
int retrievedContextTokens,
int queryTokens,
int expectedResponseTokens)
{
var inputTokens = systemPromptTokens + retrievedContextTokens + queryTokens;
var outputTokens = expectedResponseTokens;
var inputCost = (inputTokens / 1000m) * 0.03m;
var outputCost = (outputTokens / 1000m) * 0.06m;
return inputCost + outputCost;
}
// Example:
// System: 300 tokens
// Context: 3000 tokens (10 retrieved docs)
// Query: 50 tokens
// Response: 500 tokens
//
// Cost = ((300 + 3000 + 50) / 1000 * 0.03) + (500 / 1000 * 0.06)
// = (3350 / 1000 * 0.03) + (500 / 1000 * 0.06)
// = $0.1005 + $0.03
// = $0.1305 per query
//
// At 1000 queries/day = $130/day = $3,900/month!
}
Стратегії зниження витрат:
- Retrieve fewer, betterM SK1ranked documents
- Використовуйте просте шифрування (Антропічний КлодM SK1 МSK2 дешевше для закодованих टोकенів)
- Використовуйте дешевші моделі для переробки
- Стиснути контекст, використовуючи підсумки
Візуалізація повного потоку РАГ за допомогою टोकенів
Ось як токени, ,, KV-каш, МSK2 та RAG вміщаються разом.
flowchart TB
A[User Query:<br/>'How does Docker work?'<br/>≈ 12 tokens] --> B[Generate Query Embedding]
B --> C[Vector Search]
C --> D[Retrieved Docs:<br/>5 docs × 500 tokens<br/>= 2,500 tokens]
D --> E[Construct Prompt]
A --> E
E --> F["Complete Prompt:<br/>System: 300 tokens<br/>Context: 2,500 tokens<br/>Query: 12 tokens<br/>Total: 2,812 tokens"]
F --> G[Tokenize Prompt]
G --> H["Token IDs:<br/>[245, 1034, 8829, ...]<br/>2,812 token IDs"]
H --> I[LLM Layer 1]
I --> J[Compute K,V]
J --> K[KV Cache Layer 1:<br/>2,812 K,V pairs]
I --> L[LLM Layer 2]
L --> M[Compute K,V]
M --> N[KV Cache Layer 2:<br/>2,812 K,V pairs]
L --> O[... Layers 3-32]
O --> P[Generate Token 1: 'Docker']
P --> Q[Add to KV Cache]
Q --> R[Generate Token 2: 'is']
R --> S[Add to KV Cache]
S --> T[... until completion]
T --> U["Response: 'Docker is a containerization platform...'<br/>≈ 400 tokens"]
style K stroke:#f9f,stroke-width:2px
style N stroke:#f9f,stroke-width:2px
style Q stroke:#bbf,stroke-width:2px
style S stroke:#bbf,stroke-width:2px
Найголовні ідеї:
- Вхідні символи (2,812) оброблені один раз, щоб побудувати первинний квіш
- Покоління трапляється один символ в один раз, повторюваність використання кві-キャッシュу
- Кожен новий символ додає кэшу KV для майбутніх символів, до яких треба звернутись
- Загалом VRAM потрібний = Веси моделей + KV кэш для всіх टोकенів
- Довгий контекст = більший KV-каш = більше VRAM
Практичні наслідки RAG
Усвідомлення токенів та кві-キャッシュ веде до кращого дизайну RAG:
1. Предідущий -засоби комп 'ютера та кэшуM SK2
// Cache KV for frequently used system prompts + static context
var cachedSystemContext = await _llm.PrecomputeKVCache(systemPrompt + staticContext);
// Reuse for each query (much faster)
foreach (var query in userQueries)
{
var response = await _llm.GenerateAsync(query, reuseKVCache: cachedSystemContext);
}
2. Оптимизувати обмеження блокуM SK1
// Bad: Arbitrary 500-character chunks
var chunks = text.Chunk(500);
// Good: Chunk on sentence boundaries, measure in tokens
public List<string> ChunkByTokens(string text, int maxTokensPerChunk)
{
var sentences = SplitIntoSentences(text);
var chunks = new List<string>();
var currentChunk = new StringBuilder();
var currentTokens = 0;
foreach (var sentence in sentences)
{
var sentenceTokens = EstimateTokens(sentence);
if (currentTokens + sentenceTokens > maxTokensPerChunk && currentTokens > 0)
{
chunks.Add(currentChunk.ToString());
currentChunk.Clear();
currentTokens = 0;
}
currentChunk.Append(sentence).Append(" ");
currentTokens += sentenceTokens;
}
if (currentTokens > 0)
chunks.Add(currentChunk.ToString());
return chunks;
}
3. Навігація використання символів в процесі виробництва
public class RAGTelemetry
{
public void LogRAGQuery(
string query,
List<SearchResult> retrievedDocs,
string response)
{
var queryTokens = EstimateTokens(query);
var contextTokens = retrievedDocs.Sum(d => EstimateTokens(d.Text));
var responseTokens = EstimateTokens(response);
var totalTokens = queryTokens + contextTokens + responseTokens;
_logger.LogInformation(
"RAG Query: {Query} | Context: {ContextTokens} tokens from {DocCount} docs | " +
"Response: {ResponseTokens} tokens | Total: {TotalTokens} tokens",
query, contextTokens, retrievedDocs.Count, responseTokens, totalTokens
);
// Alert if approaching context limit
if (totalTokens > _maxTokens * 0.9)
{
_logger.LogWarning("Approaching token limit: {TotalTokens}/{MaxTokens}",
totalTokens, _maxTokens);
}
}
}
Завершення: Майстерство з архітектури
Ми застосували всю технічну архітектуру систем RAG.
Фаза 1: Індексування
- Видобуток тексту з різних джерел
- Strategiи відокремлення (секціюM SK1на основі, реченняMSC3на podstawieMST4 з перетинкоюMSL5
- генерація вбудованого коду (ONNXM SK1 API-сервіси)
- Поміщання векторів (QdrantM SK1 pgvector, PineconeMSC3
Фаза отримання 2:
- Вбудова питання (та сама модель, як і індексуванняM SK1
- Поиск схожості ( косину , еуklidськийM SK2 точка produktu)
- Опційне переоцінювання для кращої точності
- Фильтрація метаданів для витончених результатів
Fazа генерації 3:
- Проста конструкція (контекст МSK1 інструкції МSK2 питання
- Дослідження LLM (temperaturM SK1 верхній -p, maksymальні टोकониMSC4
- Далі-розробка M SK1видобуток цитаційМSK2форматування МSK3
Внутрішні LLM
- Торки: Фундаментальні одиниці M SK1не символи!)
- KV Cache: Чому генерація швидка? M SK1лінейнаМSK2 не квадратна)
- Окна контексту: Керування обмеженнями символів в РАG
- Оптимізація витрат : Caching, compressionM SK2 smart retrieval
Найголовніші технічні ідеї:
- Те ж вбудоване моделлю для індексування та відтворення (критикаM SK1
- Зробляйте щось більш важливе, ніж ви думаєте - зберігає семантичні послідовності
- Переrankування покращує точність за рахунок затримки часу
- Керівний менеджмент є вирішальним - підрахунки перед пошуком
- KV-キャッシュ робить RAG можливим - повторні обчислення про prompt
- Окна контексту швидко заповнюються МSK0 10 доки МSK2 ♫ ♫ МSK3 ♫ टोकони ♫ = ♫
По continue to Part 3: RAG in Practice
Тепер ви розумієте, як працює РАГ на технічному рівні
В Частина 3: RAG в практиці, ми переходимо від архітектури до втілення :
Реальний-приложения світуM SK1
- Подібні пости Рекомендація на цьому блогі
- Семантичний пошук блогів
- Збудувати "Advocate GPT" писемного асистента
Bendrі проблеми та рішення:
- Strategiи, що зберігають контекст
- Поліпшувати якість введення для вашої домени
- Рухування контекстними вікнами динамічно
- Preventing hallucination despite having context
- Тривожність вашого індексу до data
Заawansовані технології:
- Гіпотетичне вбудова Dokumentу (HyDEM SK1
- Самий-застосування LLM-розшифрованих фільтрів
- Multi-запроси РАG для комплексних результатів
- Контекстове стиснення, щоб зменшити використання токенів
- Multi-hop RAG для складних запитів
- Довгий-тривалість розмовної пам 'яті
Початок:
- Щотижня
- Практичні приклади коду
- Оптимізації
- Коли НЕ використовувати RAG
Далі переходимо до частини 3: RAG в практиці →
Ресурс
Фундаментальні матеріали:
- Видобуток МСК0 Поширене генерування знань МSK1Мовні завдання НЛП - Оригинальний RAG папір
- Дослідження щільного проходу для Open-Домена Відповідь на запитання - фонд DPR
- Увага - це все, що вам потрібно - Перетворники
Наrzędziа та ланцюги:
- Кдрант База даних вектора -
- Пропускний час на NX - локальні вбудова
- Лалам-Шарп - локальний висновок LLM
- Перетворники речей - Моделі вмонтування
Дальне читання:
- Антропічне: Контекстове відтворення - Заawansовані технології
Навігація серії:
- Частина 1: Походження та основи - Історія та мотивація
- Частина 2: Архітектура та внутрішні (таков artykułM SK1 МSK2 технічне глибоке занурення
- Частина 3: RAG в практиці - Збудувати реальні системи