Il s'agit de Partie 4 de la série DocSummarizer. Voir Partie 1 pour l’architecture, Partie 2 pour l'outil CLI, ou Partie 3 pour la plongée profonde sur les emplacements.

La partie dure du RAG n’est pas le LLM, mais c’est tout ce qui précède celui-ci.

Vous ' avez probablement vu le modèle: diviser les documents en chunks , générer des embeddings M SK3 stocker dans une base de données vectorielle , récupérer les chunks pertinents

• Parseurs de documents pour chaque format
• Logique de fusion qui respecte les limites sémantiques
• Tokenisation qui correspond à votre modèle d'implantation
• Battage pour une génération embedding efficace
• Évaluation de la salinité afin que tous les morceaux ne soient pas considérés comme égaux
• Traçage de la citation pour que vous sachiez où les réponses sont venues

Il faut beaucoup d’infrastructure avant de pouvoir écrire une seule ligne de code d’application.

DocSummarizer.Core gère tout dans un seul paquet - disponible pour les deux .NET et Node

DocSummarizer.Core est essentiellement un La couche d'intelligence du document: structure déterministe première , récupération probabiliste secondeM SK2 Il permet de résoudre l’information- problème d’ingénierie afin que vous puissiez vous concentrer sur le problème de raisonnementMSC4

Le pipeline d'ingestion

Voici ce que fait DocSummarizer : doesn't Do:

flowchart TB
    subgraph INPUT["Input (Your Document)"]
        DOC[/"PDF / DOCX / Markdown / HTML / URL"/]
    end
    
    subgraph DOCSUMMARIZER["DocSummarizer.Core (Deterministic)"]
        direction TB
        PARSE["Parse & Structure"]
        SEGMENT["Segment by Semantics"]
        EMBED["Generate Embeddings<br/>(ONNX - Local)"]
        SCORE["Compute Salience"]
        CITE["Assign Citation IDs"]
        
        PARSE --> SEGMENT
        SEGMENT --> EMBED
        EMBED --> SCORE
        SCORE --> CITE
    end
    
    subgraph OUTPUT["Output (ExtractionResult)"]
        SEGMENTS[/"Segments[]<br/>• Original text (verbatim)<br/>• float[384] embedding<br/>• Salience score<br/>• StartChar / EndChar<br/>• Section context"/]
    end
    
    subgraph YOURS["Your Code"]
        STORE[("Vector Store<br/>(Qdrant / pgvector / etc)")]
    end
    
    subgraph QUERY["Query Time (Later)"]
        Q["User Question"]
        RETRIEVE["Retrieve Top-K"]
        LLM["LLM Synthesis"]
        ANS["Answer + Citations"]
        
        Q --> RETRIEVE
        RETRIEVE --> LLM
        LLM --> ANS
    end
    
    DOC --> PARSE
    CITE --> SEGMENTS
    SEGMENTS --> STORE
    STORE --> RETRIEVE
    
    style DOCSUMMARIZER stroke:#27ae60,stroke-width:3px
    style YOURS stroke:#3498db,stroke-width:2px
    style QUERY stroke:#9b59b6,stroke-width:2px
    style LLM stroke:#e74c3c,stroke-width:2px

Ce que fait DocSummarizer (box verteM SK1

• Parse les documents préservant la structure
• Splits into semantic segments (not arbitrary chunks)
• Gérer des embeddings locaux avec ONNX
• Compte des notes de salience
• Assigner des ID de citation avec les positions du caractère

Ce que vous faites (box bleue):

• Entreposer les segments dans votre base de données vectorielle
• Élaborer votre logique de recherche

Que se passe-t-il au moment de la demande (encadré purpleM SK1

• Insérer la question (le même modèle)
• Récupérer des segments similaires
• Envoyer à LLM pour la synthèse

Perspectives clés: Le LLM (bord rouge) n'est impliqué qu'au moment de la demandeM SK2 l'ingestion est entièrement déterministe - le même document produit toujours les mêmes segmentsMNK4 C'est ce qui rend RAG reproduisable et débuggableMSC5

Bons de reproduction: L’ingestion déterministe signifie que vous pouvez modifier votre pipeline RAG comme tout autre artefact de construction.

Pourquoi aucun LLM pour l'ingestion?

Pour RAG, vous voulez le les sentences réelles à partir de vos documents - non LLM-paraphrases généréesM SK2 Lorsque l'utilisateur demande "que le contrat dit-il au sujet de la résiliation?

Le LLM arrive plus tard, au moment de la demande, pour synthétiser une réponse à partir des morceaux reprisM SK2 Mais les morceaux eux-mêmes devraient être du matériel source verbatim . C’est ce qui fait que les citations ont un sens

DocSummarizer's ExtractSegmentsAsync vous donne exactement ce qui suit:: les segments de texte originaux avec embeddings;

La proposition de valeur

Voici ce que vous obtiendrez avec un dotnet add package:

dotnet add package Mostlylucid.DocSummarizer

• Segmentation intelligente - Parties sur les titres, respecte les limites sémantiques
• Emplacements de l'ONNX - Local, sans clés APIM SK2 modèles automatiques - téléchargement
• Évaluation de la culpabilité - PréM SK1importance calculée pour chaque segment
• Traçage des citations - Chaque segment a une ID unique
• Formats multiples - Markdown , HTMLM SK2 PDF, DOCX MSC4avec la présentation de documentsMSC5
• Options de stockage des vecteurs - InMemoryM SK1 DuckDB , Qdrant construit-in

Pas de Python. Pas d’API externes. Aucune configuration complexeM SK2 Fonctionne en mode offline après le premier téléchargement du modèle .

Extraire les segments: L'API de base

Le cas d’utilisation le plus simple - extrait des segments avec les embeddings prêts pour votre magasin de vecteurs:

using Microsoft.Extensions.DependencyInjection;
using Mostlylucid.DocSummarizer;

// Setup DI
var services = new ServiceCollection();
services.AddDocSummarizer();
var provider = services.BuildServiceProvider();

var summarizer = provider.GetRequiredService<IDocumentSummarizer>();

// Extract segments with embeddings
string markdown = File.ReadAllText("document.md");
var extraction = await summarizer.ExtractSegmentsAsync(markdown);

foreach (var segment in extraction.AllSegments)
{
    Console.WriteLine($"[{segment.Type}] {segment.SectionTitle}");
    Console.WriteLine($"  ID: {segment.Id}");
    Console.WriteLine($"  Salience: {segment.SalienceScore:F2}");
    Console.WriteLine($"  Embedding: float[{segment.Embedding?.Length}]");
    Console.WriteLine($"  Text: {segment.Text[..Math.Min(80, segment.Text.Length)]}...");
}

Output:

[Heading] Introduction
  ID: a1b2c3d4e5f6g7h8_h_0
  Salience: 0.85
  Embedding: float[384]
  Text: This document describes the architecture of our new microservices platform...

[Sentence] Introduction  
  ID: a1b2c3d4e5f6g7h8_s_1
  Salience: 0.72
  Embedding: float[384]
  Text: The system is designed to handle 10,000 requests per second with sub-100ms...

Que'c'est-ce . Aucune orchestration, aucun promptsM SK3 aucune opinion MSC4 simplement des segments avec embeddings et provenanceMNK5 prêt pour votre base de données vectorielleMRK6

ID du document

Chaque segment's Id est construit à partir d’un document ID plus type et index: {docId}_{type}_{index}.

Vous pouvez fournir votre propre ID de document, ou laisser DocSummarizer calculer un à partir du contenu hash:

// Option 1: Provide your own ID (useful for tracking documents in your system)
var extraction = await summarizer.ExtractSegmentsAsync(markdown, documentId: "contract-2024-001");
// Segments get IDs like: contract_2024_001_s_0, contract_2024_001_h_1, ...

// Option 2: Auto-generated from content hash (default)
var extraction = await summarizer.ExtractSegmentsAsync(markdown);
// Segments get IDs like: a1b2c3d4e5f6g7h8_s_0, a1b2c3d4e5f6g7h8_h_1, ...
// Same document = same hash = same IDs (deterministic)

Pourquoi cela est important pour RAG:

• Des ID personnalisés vous permettent de corréler les segments avec votre système de gestion des documents.
• Content-hash IDs assurent que la réindexation du même document par l’indexation de - produce des ID identiques pour les segments
• Les deux approches appuient des citations stables - [s42] réglemente toujours le même texte source

Qu’est-ce que le SMC0 dans un segment?

Chaque segment extrait contient tout ce dont vous avez besoin pour RAG:

public class Segment
{
    string Id;              // Unique ID: "mydoc_s_42" (for citations)
    string Text;            // The actual content
    SegmentType Type;       // Sentence, Heading, ListItem, CodeBlock, Quote, TableRow
    int Index;              // 0-based order in document
    
    // Source location tracking
    int StartChar;          // Character offset where segment starts
    int EndChar;            // Character offset where segment ends
    int? PageNumber;        // Page number (for PDFs)
    int? LineNumber;        // Line number (for text/markdown)
    
    // Section context
    string SectionTitle;    // "Introduction" - immediate heading
    string HeadingPath;     // "Chapter 1 > Introduction > Overview"
    int HeadingLevel;       // 1-6 (heading depth)
    
    // Computed during extraction
    float[] Embedding;      // 384-dim vector (default model)
    double SalienceScore;   // 0-1 importance score
    string ContentHash;     // Stable hash for citation tracking across re-indexing
    
    // For retrieval (set during query)
    double QuerySimilarity; // Similarity to the query
    double RetrievalScore;  // Combined score: similarity + salience
    
    string Citation { get; } // Auto-generated: "[s42]", "[h3]", etc.
}

L'article 5 de la Loi sur l'immigration et le statut des réfugiés Id est la clé de suivi des citations. Lorsque votre LLM produit [s42], vous pouvez le résoudre à l'endroit exact de la source en utilisant StartChar/EndChar.

Bonus: L'article 5 de la Loi sur l'immigration et le statut des réfugiés ExtractionResult inclut les méthodes d'aide pour la résolution des citations:

var extraction = await summarizer.ExtractSegmentsAsync(markdown);

// Fast O(1) lookups
var segment = extraction.GetSegment("mydoc_s_42");
var segmentByIdx = extraction.GetSegmentByIndex(42);

// Find segment at a character position
var segmentAtPos = extraction.GetSegmentAtPosition(5432);

// Get all segments on page 5 (for PDFs)
var pageSegments = extraction.GetSegmentsOnPage(5);

// Get source location for highlighting
var location = extraction.GetSourceLocation("mydoc_s_42");
// Returns: StartChar, EndChar, LineNumber, PageNumber, SectionTitle, HeadingPath

// Extract highlighted text with context
var highlight = extraction.GetHighlightedText(originalMarkdown, "mydoc_s_42", contextChars: 50);
Console.WriteLine(highlight.ToHtml());  // <span class="highlight">...</span>
Console.WriteLine(highlight.ToMarkdown()); // **...**

Plugging Into Vector Stores

DocSummarizer vous donne les embeddings. Utiliser n’importe quelle base de données vectorielle que vous voulez.

Qdrant

var points = extraction.AllSegments.Select((s, i) => new PointStruct
{
    Id = (ulong)i,
    Vectors = s.Embedding,
    Payload = 
    {
        ["text"] = s.Text,
        ["section"] = s.SectionTitle,
        ["salience"] = s.SalienceScore,
        ["segment_id"] = s.Id,
        ["start_char"] = s.StartChar,
        ["end_char"] = s.EndChar
    }
}).ToList();

await qdrantClient.UpsertAsync("documents", points);

PostgreSQL + pgvector

foreach (var segment in extraction.Segments)
{
    await connection.ExecuteAsync(
        @"INSERT INTO documents (segment_id, text, heading, salience, embedding) 
          VALUES (@id, @text, @heading, @salience, @embedding::vector)",
        new { 
            id = segment.Id,
            text = segment.Text, 
            heading = segment.SectionTitle,
            salience = segment.SalienceScore,
            // NOTE: String interpolation is for demo simplicity only.
            // For production, use NpgsqlParameter with Vector type for better
            // performance and to avoid culture-dependent decimal separators.
            embedding = $"[{string.Join(",", segment.Embedding)}]"
        });
}

Ou utiliser les magasins structurés-

Don' ne veut pas gérer une base de données distincte ? DocSummarizer comprend trois backends:

services.AddDocSummarizer(options =>
{
    // In-memory (fastest, no persistence)
    options.BertRag.VectorStore = VectorStoreBackend.InMemory;
    
    // DuckDB (embedded file-based, default)
    options.BertRag.VectorStore = VectorStoreBackend.DuckDB;
    
    // Qdrant (external server)
    options.BertRag.VectorStore = VectorStoreBackend.Qdrant;
    options.Qdrant.Host = "localhost";
    options.Qdrant.Port = 6334;
});

Why Salience Matters

La plupart des systèmes RAG échouent non pas parce que les embeddings sont mauvais, mais parce que tous les chunks sont traités comme étant tout aussi importants.

flowchart LR
    subgraph DOC["Document"]
        H1["# Title"]
        P1["First paragraph<br/>(intro)"]
        H2["## Methods"]
        P2["Technical details..."]
        P3["More details..."]
        H3["## Results"]
        P4["Key findings here"]
        H4["## Appendix"]
        P5["Reference data..."]
    end
    
    subgraph SCORES["Salience Scores"]
        S1["0.95"]
        S2["0.85"]
        S3["0.70"]
        S4["0.65"]
        S5["0.60"]
        S6["0.80"]
        S7["0.30"]
    end
    
    H1 --> S1
    P1 --> S2
    H2 --> S3
    P2 --> S4
    P3 --> S5
    P4 --> S6
    P5 --> S7
    
    style S1 stroke:#27ae60,stroke-width:3px
    style S2 stroke:#27ae60,stroke-width:2px
    style S6 stroke:#27ae60,stroke-width:2px
    style S7 stroke:#e74c3c,stroke-width:2px

Une phrase dans l’abrégé est plus importante que celle de l’annexe.

// Get the top 20% most salient segments
var topSegments = extraction.Segments
    .OrderByDescending(s => s.SalienceScore)
    .Take((int)(extraction.Segments.Count * 0.2));

Facteurs de salience:

Cela signifie que votre recherche peut avoir un poids de (similarity * salience) instead of just similarity.

Classification des documents

DocSummarizer auto-détecte le type de document à l'aide d'une héuristique sur le contenu

var extraction = await summarizer.ExtractSegmentsAsync(markdown);

// Document type detected from content
Console.WriteLine($"Type: {extraction.DocumentType}");     // Technical, Narrative, Legal, etc.
Console.WriteLine($"Confidence: {extraction.Confidence}"); // High, Medium, Low

Classification affecte la récupération: Les échelles de profondeur de récupération avec l'entropie du document, ne sont pas hardcodeées TopKM SK2 Documents narratifs ( FictionMNK4 histoiresMMK5 reçoivent une 1.5x accroissement pour le nombre de recherche parce qu'ils ont besoin d'un plus grand contexteMRK7 Les documents techniques dont la structure est claire ont besoin de moins de textes

L’héuristique :

• Fréquence de blocage du code (techniqueM SK1
• Structure de la position (académique,techniqueM SK2
• Patterns de dialogue (narrative)
• Terminologie juridique (contratsM SK1
• Densité de la liste (documentationM SK1

Si l'héuristique est incertaine, DocSummarizer peut optionnellement revenir à une classification rapide de LLM en utilisant un modèle M SK1sentinel" . Cela exige que Ollama fonctionne localement avec un petit modèle comme tinyllama. Enablez-le par la configuration:

services.AddDocSummarizer(options =>
{
    options.Ollama.BaseUrl = "http://localhost:11434";
    options.Ollama.Model = "tinyllama";
});

// Then use with LLM fallback enabled
var extraction = await summarizer.ExtractSegmentsAsync(markdown, useLlmFallback: true);

Pour la plupart des documents, l’héuristique seule est suffisamment précise - le retrait de LLM existe pour les cas à bord

Exemple du pipeline RAG complet

Voici un index complet de ', - et - du pipeline de demandes.

sequenceDiagram
    participant User
    participant App as Your App
    participant DS as DocSummarizer
    participant VS as Vector Store
    participant LLM
    
    Note over DS: INGESTION (No LLM)
    App->>DS: ExtractSegmentsAsync(markdown)
    DS->>DS: Parse structure
    DS->>DS: Split into segments
    DS->>DS: Generate embeddings (ONNX)
    DS->>DS: Compute salience
    DS-->>App: ExtractionResult
    App->>VS: Store segments + vectors
    
    Note over LLM: QUERY TIME (LLM involved)
    User->>App: "What about X?"
    App->>DS: EmbedAsync(question)
    DS-->>App: float[384]
    App->>VS: Search(vector, topK=5)
    VS-->>App: Top segments
    App->>LLM: Question + Context
    LLM-->>App: Answer with [citations]
    App-->>User: Answer

Étape 1: Structures des données

public class SimpleRagService
{
    private readonly IDocumentSummarizer _summarizer;
    
    // In-memory segment store - maps "docId:segmentId" to the full segment
    private readonly Dictionary<string, ExtractedSegment> _segments = new();
    
    // In-memory vector index - pairs of (id, embedding vector)
    private readonly List<(string Id, float[] Vector)> _index = new();

Dans la production, vous utilisez une base de données sur les vecteurs réels :

Étape 2: Documents d'indexation

    public async Task IndexAsync(string markdown, string docId)
    {
        // Extract segments with embeddings - this is where DocSummarizer does the work
        var extraction = await _summarizer.ExtractSegmentsAsync(markdown);
        
        // Store each segment and its vector
        foreach (var segment in extraction.Segments)
        {
            // Composite key: document + segment for citation tracking
            var id = $"{docId}:{segment.SegmentId}";
            
            // Keep the full segment for retrieval
            _segments[id] = segment;
            
            // Add to vector index for similarity search
            _index.Add((id, segment.Embedding));
        }
    }

Note: Aucune LLM n’est impliquéeM SK1 Nous Actualités Texte du document, non sommaires.

Étape 3: Demande

    public async Task<string> QueryAsync(string question, int topK = 5)
    {
        // Embed the question using the same model as documents
        // This ensures vectors are in the same space
        var embedding = await _summarizer.EmbedAsync(question);
        
        // Find top-K most similar segments
        var results = _index
            .Select(x => (x.Id, Similarity: CosineSimilarity(embedding, x.Vector)))
            .OrderByDescending(x => x.Similarity)
            .Take(topK)
            .Select(x => _segments[x.Id])
            .ToList();
        
        // Build context with citation markers
        // The LLM can reference [chunk-3] and we can trace it back
        var context = string.Join("\n\n", results.Select(s => 
            $"[{s.SegmentId}] {s.Text}"));
        
        return context; // Send this + the question to your LLM
    }

Le contexte retourné contient le Actualités Texte du document avec les ID de segments. Votre prompt LLM pourrait ressembler à:

Answer the question based on the following context.
Cite sources using the [chunk-N] markers.

Context:
{context}

Question: {question}

La mathématique (Similarité cosine standard)

    private static float CosineSimilarity(float[] a, float[] b)
    {
        float dot = 0, normA = 0, normB = 0;
        for (int i = 0; i < a.Length; i++)
        {
            dot += a[i] * b[i];
            normA += a[i] * a[i];
            normB += b[i] * b[i];
        }
        return dot / (MathF.Sqrt(normA) * MathF.Sqrt(normB));
    }
}

DocSummarizer inclut VectorMath.CosineSimilarity() si vous ne voulez pas écrire ce document par vous-mêmes'

Le DocSummarizer expose également IEmbeddingService directement si vous avez besoin d’incorporer les demandes séparément du pipeline de résumation intégrale.

Modèles d'intégration

Défault est AllMiniLmL6V2 - rapide , petit, bonne qualitéM SK3 Choisissez en fonction de vos besoins

services.AddDocSummarizer(options =>
{
    options.Onnx.EmbeddingModel = OnnxEmbeddingModel.BgeBaseEnV15;
});

Modèles automatiques-download à partir de HuggingFace lors de la première utilisation. Subséquent runs load from diskM SK2

OpenTelemetry

Surveiller votre pipeline RAG en production:

services.AddOpenTelemetry()
    .WithTracing(tracing => tracing
        .AddSource("Mostlylucid.DocSummarizer")
        .AddSource("Mostlylucid.DocSummarizer.Ollama")
        .AddSource("Mostlylucid.DocSummarizer.WebFetcher")
        .AddOtlpExporter())
    .WithMetrics(metrics => metrics
        .AddMeter("Mostlylucid.DocSummarizer")
        .AddMeter("Mostlylucid.DocSummarizer.Ollama")
        .AddMeter("Mostlylucid.DocSummarizer.WebFetcher")
        .AddPrometheusExporter());

Mesures clés:

• docsummarizer.summarizations - Compte des demandes
• docsummarizer.summarization.duration - Temps de traitement en ms
• docsummarizer.document.size - Taille du document
• docsummarizer.ollama.embed.requests - Intégration des appels API

Soutien au format

DocSummarizer gère plusieurs formats de documents avec une détection et un traitement intelligents.

Traitement direct (Sans dépendance externe)

Ces formats sont traités à l'origine - aucun documentage ou autres services requis:

Texte simple obtient une manipulation intelligente: Lorsqu'il n'y a pas de rubriques de marquage à descendre, le chunker change vers un paragraphe - par séparation fondée M SK3 Il détecte la structure du document d'une manière hiérarchique.

// Plain text works the same way
var plainText = File.ReadAllText("notes.txt");
var extraction = await summarizer.ExtractSegmentsAsync(plainText);
// Chunks split by paragraphs, embeddings generated

Documents riches avec Docling

Pour le format PDF, DOCXM SK1 PPTX, XLSXMSC3 et les images (OCRMST5 Mst6 ajouter DoclingM st7

docker run -d -p 5001:5001 quay.io/docling-project/docling-serve

services.AddDocSummarizer(options =>
{
    options.Docling.BaseUrl = "http://localhost:5001";
});

// PDF, DOCX, PPTX, images all work
var pdfBytes = await File.ReadAllBytesAsync("document.pdf");
var extraction = await summarizer.ExtractSegmentsAsync(pdfBytes, "document.pdf");

Le document de travail préserve la structure du document - les titres , les tableaux, les listes sont traduites comme un marquage appropriéM SK3 Cela signifie qu'il est préférable d'extraire le texte en bloc plutôt que d'en extraire l'extraction brute.

Voir Partie 1 Pour en savoir plus sur l’intégration de Docling, ou Multi-Format Conversion de document pour une plongée profonde.

Les parties difficiles que vous faites passer

Résumé

Les pipelines RAG ont besoin d’infrastructure avant la partie intéressante. DocSummarizerM SK1Core vous donne:

1. Segments avec embeddings - prêt pour tout magasin de vecteurs
2. Notes de Salience - Tous les chunks ne sont pas égaux
3. Traçage des citations - Connaissance de l’origine des réponses
4. Local-première - Aucune clé API, fonctionne en mode offline
5. Telemétrie de production - OpenTelemetry intégré

dotnet add package Mostlylucid.DocSummarizer

La plomberie est terminée. Construisez votre app RAG.

Articles connexes

La série DocSummarizer

• Partie 1 - Architecture & Patterns - Pourquoi l’approche du pipeline fonctionne
• Partie 2 - Utilisation de l'outil - Installation du CLI, modesM SK2 modèles
• Partie 3 - Concepts avancés - Emplacements BERTM SK1 ONNX, recherche hybride
• Partie 5 - DoomSummarizer: Recherche approfondie - MultiM SK1Récupération des sources , Profils d'entités, découverte de graphes sémantiquesMSC4 et synthèse de formes parallèles longuesMST5

Les plongées profondes du RAG

• Première étape du RAG - Concepts fondamentaux pour la récupération-génération améliorée
• Architecture du RAG - Modèles de conception du système pour RAG
• Recherche et indexation hybrides - Combinaison de la recherche dense et sparse
• Applications pratiques de RAG - Real-world usage cases

GraphRAG

• GraphRAG: Graphiques de connaissances pour RAG - Lorsque la recherche par vecteur n’est pas suffisante
• GraphRAG Minimum de mise en œuvre viable - Établissement d'un système GraphRAG fonctionnel

Outils connexes

• Recherche sémantique avec ONNX et Qdrant - Les blocs de construction
• Self-Databases de vecteurs hébergées: Qdrant - Qdrant exploité localement
• Analyse des grands fichiers CSV avec les LLM locaux - Le même modèle, domaine différent
• Extraire et analyser le contenu Web avec les LLM - Écrapage Web pour RAG
• Multi-Format Document Conversion Service - La plongée profonde de Docling

Liens

• NuGet Package
• GitHub - Bibliothèque de base
• Outil CLI de GitHub -