Back to "Архітектура RAG і інтер 'єри: Як вона дійсно працює"

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

AI AI-Article LLM Machine Learning RAG Semantic Search

Архітектура RAG і інтер 'єри: Як вона дійсно працює

Saturday, 22 November 2025

В Частина 1, ми розглянули RAG, ' про походження, основи, і чому це важливо. Ви розумієте концепцію високого рівня- МSK6 отримати важливу інформацію, потім використати її для генерації відповідей. Зараз ми занурюємось глибоко в технічну архітектуру— точно, як RAG системи працюють під капюшоном, від стратегії групування до інтерфейсів LLM, таких як टोकони та кві-キャッシュи.

Введение

Навігація серії 📖 Це частина 2 серії RAG МSK1

Якщо ви не читали частини ', я рекомендую починати з них, щоб зрозуміти

  • Що таке РАГ і чому він важливий
  • Історія від пошуку ключів до семантичного розуміння
  • 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();

Початкове відтворення швидке, але приблизне. Пере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!
}

Стратегії зниження витрат:

  1. Retrieve fewer, betterM SK1ranked documents
  2. Використовуйте просте шифрування (Антропічний КлодM SK1 МSK2 дешевше для закодованих टोकенів)
  3. Використовуйте дешевші моделі для переробки
  4. Стиснути контекст, використовуючи підсумки

Візуалізація повного потоку РАГ за допомогою टोकенів

Ось як токени, ,, 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

Найголовні ідеї:

  1. Вхідні символи (2,812) оброблені один раз, щоб побудувати первинний квіш
  2. Покоління трапляється один символ в один раз, повторюваність використання кві-キャッシュу
  3. Кожен новий символ додає кэшу KV для майбутніх символів, до яких треба звернутись
  4. Загалом VRAM потрібний = Веси моделей + KV кэш для всіх टोकенів
  5. Довгий контекст = більший 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

Найголовніші технічні ідеї:

  1. Те ж вбудоване моделлю для індексування та відтворення (критикаM SK1
  2. Зробляйте щось більш важливе, ніж ви думаєте - зберігає семантичні послідовності
  3. Переrankування покращує точність за рахунок затримки часу
  4. Керівний менеджмент є вирішальним - підрахунки перед пошуком
  5. KV-キャッシュ робить RAG можливим - повторні обчислення про prompt
  6. Окна контексту швидко заповнюються М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 в практиці →

Ресурс

Фундаментальні матеріали:

Наrzędziа та ланцюги:

Дальне читання:

Навігація серії:

Пройти до частини 3 МSK1

logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.