Das ist Teil von der DocSummarizer-Serie Teil für die Architektur Teil für das CLI-Werkzeug Teil für den tiefen Tauchgang auf Einbettungen

Der harte Teil der RAG ist das LLM-.. Es ist alles vor dem LLM...

Du hast wahrscheinlich das Muster gesehen ,: , geteilte Dokumente in Stücke , , , erzeugen Embeddings , , , speichern Sie in einer Vektordatenbank , die relevanten Brocken abrufen , , , senden Sie an LLM , und zwar einfach in der Theorie ,. , In der Praxis , ., , schreiben : ,

• Dokumentparser für jedes Format
• Chunking Logik, die semantische Grenzen respektiert
• Tokenisierung, die zu Ihrem Einbettungsmodell passt
• Batching für effiziente Einbettung Generation
• Salience scoring so dass nicht alle Stücke gleich behandelt werden
• Citation-Tracking, damit Sie wissen, woher die Antworten kamen

Das ist eine Menge Infrastruktur, bevor Sie eine einzelne Zeile des Anwendungscodes schreiben.

DocSummarizer-.-Core behandelt alles in einem einzigen Paket Es ist sowohl für . als auch für Node-.«js».« verfügbar.

DocSummarizer-.-Core ist im Wesentlichen ein Dokument-Intelligence-SchichtEs löst die Informationen- engineering-Problem, so dass Sie sich auf das Argumentationsproblem konzentrieren können

Die Verdauungspipeline

Hier ist das, was DocSummarizer tut und kritisch, was es nicht vorhanden INSGESAMT

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

Was DocSummarizer tut Grüner Kasten

• Parses-Dokumente erhalten Struktur
• Teilt sich in semantische Segmente
• Erzeugt lokale Einbettungen mit ONNX
• Berechnet Salience-Scores
• Zuweisen von Zitier-IDs mit Zeichenpositionen

Was du tust

• Segmente in Ihrer Vektordatenbank speichern
• Erstellen Sie Ihre Suchlogik

Was passiert bei der Abfragezeit?

• Die Frage einbetten
• Ähnliche Segmente abrufen
• An LLM zur Synthese senden

Wichtigste Einsichten (MSK) Die LLM-Grenze ) ist nur zum Abfragezeitpunkt beteiligt.....Ingestion ist völlig deterministisch. Das gleiche Dokument produziert immer die gleichen Segmente... Das macht RAG reproduzierbar und debuggbar...

Reproduzierbarkeits-Bonus Deterministische Aufnahme bedeutet, dass du wie jedes andere Bauartefakt wieder --Index - , - diffus, - debuggen und deine RAG Pipeline debugieren kannst.. - Keine prompte Varianz, keine Modelltemperatur, nur reine , - testbare Datentechnik.

Warum kein LLM für die Einnahme?

Für RAG-, , Sie wollen die tatsächliche Sätze aus Ihren Dokumenten . . - , nicht LLM . - . generierte Paraphrasen . wenn ein Benutzer fragt, was sagt der Vertrag über die Kündigung sagen . ?", , müssen Sie den realen Vertragstext abrufen .

Die LLM kommt später zur Abfragezeit, um eine Antwort aus den abgerufenen Brocken zu synthetisieren, aber die Brocken selbst sollten wörtlich Quellmaterial sein, das, was Zitationen sinnvoll macht.

DocSummarizer-' ExtractSegmentsAsync gibt Ihnen genau dieses... die ursprünglichen Textsegmente mit Einbettungen... bereit fürs Retrieval... kein LLM, das an der Aufnahme beteiligt ist....

Die Wertvorlage

Hier ist, was Sie mit einem erhalten dotnet add package:

dotnet add package Mostlylucid.DocSummarizer

• Intelligente Segmentierung Die Spalten auf den Überschriften sind mit semantischen Grenzen zu versehen.
• Einbettungen von ONNX Keine API-Schlüssel, keine API-Tasten, keine ,-Modelle, automatische --Downloads
• Salience-Wertung Vorberechnete Bedeutung für jedes Segment
• Citation-Tracking Jedes Segment hat eine eindeutige ID
• Mehrere Formate -, Markdown, ,, HTML, MKS2, PDF, MSC3, DOCX, mit Docling, MKK5,
• Optionen für Vektorspeicher --Inmemory-,-Ente-DB-,-Qdrant gebaut

Kein Python, kein ., keine externen APIs, kein komplexes Setup, kein ., funktioniert offline nach dem ersten Download des Modells.

Segmente extrahieren Die Kern-API

Die einfachste Anwendungsfall-Extraktsegmente mit Einbettungen bereit für Ihren Vektorspeicher.

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)]}...");
}

Ausgabe„ :"

[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...

Dass es ' ist Keine Orchestrierung... keine Aufforderungen... keine Meinungen... nur Segmente mit Einbettungen und Provenienz... bereit für Ihre Vektordatenbank...

Dokument-IDs

Jedes Segment – ' Id wird aus einem Dokument ID plus Typ und Index aufgebaut {docId}_{type}_{index}.

Sie können Ihr eigenes Dokument ID.,. zur Verfügung stellen oder DocSummarizer eins aus dem Inhalt hash.: berechnen lassen

// 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)

Warum das für RAG-:e wichtig ist

• Mit benutzerdefinierten IDs können Sie Segmente mit Ihrem Dokumentenverwaltungssystem korrelieren
• Content-IDs von -hash sorgen dafür, dass das gleiche Dokument wieder indexiert wird und identische Segment IDs erzeugt
• Beide Ansätze unterstützen stabile Zitate [s42] löst sich immer auf den gleichen Quelltext

Was ist in einem Segment?

Jedes extrahierte Segment enthält alles, was Sie für RAG.: benötigen

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.
}

Das Id ist der Schlüssel für das Zitier-Tracking, wenn Ihre LLM-Ausgänge [s42]Sie können es zurück zum genauen Quellort mit StartChar/EndChar.

Bonus-:- Das ExtractionResult schließt Hilfsmethoden für die Zitierauflösung ein

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()); // **...**

Einstecken in Vector Stores

DocSummarizer gibt Ihnen die Einbettungen.Verwenden Sie, was Vektor-Datenbank Sie mögen.

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)}]"
        });
}

Oder verwenden Sie die Built---Speicher

DocSummarizer enthält drei Backends, die eine separate Datenbank verwalten möchten.

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;
});

Warum Salience zählt

Die meisten RAG-Systeme scheitern nicht, weil Einbettungen schlecht sind, sondern weil alle Brocken als ebenso wichtig behandelt werden.

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

Ein Satz im Abstrakten ist wichtiger als einer im Anhang.

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

Salience-Faktoren

Einfluss des Faktors „|" |--------|--------| Die Sätze der Schlussfolgerungen sind höher als die Sätze der Schlussfolger. Erste Sätze nach Überschriften sind Themensätze. Die Länge der | ist sehr kurz segmentiert. Abschnittstyp |-Abstract-/-Einführung verstärkt ,-Referenzen /-Anlage reduziert |-Einleitung Code-Blocks, Anführungszeichen, Listen, die unterschiedlich gewichtet werden

Dies bedeutet, dass Ihr Abruf kann Gewicht durch (similarity * salience) anstelle von nur Ähnlichkeiten...

Einreihung von Dokumenten

DocSummarizer erkennt den Dokumententyp mit Heuristiken auf dem Inhalt

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

Klassifizierung wirkt sich auf das Abrufen ausWeitere Informationen finden Sie unter: http:europa.eu.int/comm/index_de.html

Die Heuristiken schauen sich an

• Code-Blockfrequenz
• Vortriebsstruktur (-akademisch ,-technisch )
• Dialog-Muster
• Rechtsterminologie
• Listendichte Dokumentation

Wenn die Heuristik unsicher ist, kann DocSummarizer optional auf eine schnelle LLM-Klassifikation zurückfallen, indem er ein kleines Modell wie z.B. tinyllamaAktivieren Sie es über die Konfiguration.

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);

Für die meisten Dokumente sind nur Heuristiken genau genug, um den LLM-Fallback für Kantenfälle zu finden.

Vollständige RAG Pipeline Beispiel

Hier ist ein vollständiger Index, der in drei Schritten gebaut wird.

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

Schritt Die Datenstrukturen

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();

In der Produktion verwenden Sie ein reales Vektordatenbank -( , Qdrant , , , pgvector , , usw., aber dies zeigt das Kernmuster ,. ,

Schritt zur Indexierung von Dokumenten

    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));
        }
    }

Anmerkung: keine LLM-Beteiligten tatsächlich Dokumenttext – ,- keine Zusammenfassungen –.-

Schritt - Abfragen

    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
    }

Der zurückgegebene Kontext enthält die real Dokumenttext mit Segment-IDs... Ihre LLM-Prompt könnte so aussehen.

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

Context:
{context}

Question: {question}

Die mathematische Ähnlichkeit des Standardkosinus

    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 enthält VectorMath.CosineSimilarity() wenn du dieses selbst schreiben möchtest

Der DocSummarizer zeigt auch IEmbeddingService direkt, wenn Sie Abfragen getrennt von der kompletten Summarisierungspipeline einbetten müssen.

Einbetten von Modellen

Standard ist AllMiniLmL6V2 Wählen Sie basierend auf Ihren Bedürfnissen

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

Modelle auto-Download von HuggingFace beim ersten Einsatz ,. , nachfolgende läuft Last aus disk , . ,

OpenTelemetrie

Überwachen Sie Ihre RAG-Pipeline in der Produktion

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());

Schlüsselmetriken

• docsummarizer.summarizations Anzahl der Anfragen
• docsummarizer.summarization.duration Verarbeitungszeit in ms
• docsummarizer.document.size Formate der Dokumente
• docsummarizer.ollama.embed.requests API-Aufrufe einbetten

Format-Unterstützung

DocSummarizer verarbeitet mehrere Dokumentformate mit intelligenter Erkennung und Verarbeitung

Direkte Verarbeitung Keine externen Abhängigkeiten

Diese Formate werden nativ verarbeitet, ohne Docling oder andere Dienstleistungen erforderlich.

Format Format Erweiterung Format Verarbeitung Format |--------|-----------|------------| Markdown-Markierung .md, .markdown Geparstes mit Markdig-,-Struktur konserviert Eindeutiger Text .txt, .text Durch Absätze teilen sich (Doppelte Neulinien)Ausschneiden HTML-Dokumente .html, .htm Umwandelt zu Markdown ZIP-Archive .zip Textdateien extrahiert ,, automatisch-, erkennt Gutenberg-Format

Klarer Text bekommt intelligente HandhabungWenn es keine Markdown-Positionen gibt, schaltet der Chunker auf Absatz um.- Basierendes Splitting... Es erkennt die Dokumentenstruktur heuristisch, wenn Ihr Text klare Absätze bricht.MSC5. Diese werden zu Klumpengrenzen.MSZ6.

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

Reiche Dokumente mit Docling

Für PDF-Dokumente und Bilder

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");

Docling konserviert Dokumentenstruktur Uberschriften Ubergänge Uberlegungen Ubergangstabellen U bergangslisten Ubertrittsliste als korrektes Markdown U übergangszeichen Das bedeutet eine bessere Krümmung als die Rohtextextraktion

Anmerkung zu diesem Dokument: |--------|-----------|-------| PDF-Datei .pdf Text Format erhaltene Tabellen konvertierte Tabellen WETTBEWERB .docx Vollständige Formatierung der Überschriften der MSK-Listen .| . PowerPoint .pptx Folien werden zu Abschnitten ZUSAMMENFASSUNG .xlsx Tabellen, die extrahiert werden Bildmaterial .png, .jpg, .tiff OCR über die Docling-Methode

Siehe Teil für mehr über die Docling-Integration oder Umwandlung von Multi---Format-Dokumenten für einen tiefen Tauchgang

Die harten Teile, die Sie überspringen

Lösung für DocSummarizer |---------|----------------------| An semantischen Grenzen zu würfeln , | , Splits auf Überschriften , , , Gruppen bezogenen Inhalt ,| , Verwendet korrekten Tokenizer für jedes ONNX-Modell Einbetten von Batching-Formaten Konfigurierbare Chargengröße , , Speicher- , effizient ,| , Jedes Segment wird einzigartig SegmentId | Formatkonvertierung Formatumwandlung Formatumstellung Formatumrechnung Formatumsetzung HTMLumwandlung PDFumwandlung Modell herunterladen /caching Auto downloads -cache in ~/.docsummarizer |

Zusammenfassung

RAG-Pipelines benötigen Infrastruktur vor dem interessanten Teil... DocSummarizer...

1. Segmente mit Einbettungen Bereit für jeden Vektorspeicher
2. Salience Punkte Nicht alle Stücke sind gleich
3. Citation-Tracking Wissen, woher Antworten kommen
4. Lokales - zuerst Keine API-Schlüssel, die offline ausgeführt werden
5. Produktionstelemetrie OpenTelemetrie eingebaut in

dotnet add package Mostlylucid.DocSummarizer

Die sanitären ist getan. Build Ihre RAG-App

Verwandte Artikel

Reihe DocSummarizer

• Teil-Architektur Muster Warum der Pipeline-Ansatz funktioniert
• Teil mit dem Werkzeug CLI-Installation modi M, templates
• Teil - Fortgeschrittene Konzepte BERT-Einbettungen ONNX-,
• Teil 5------DoomSummarizer--:-Tiefforschung Mehrsprachiges Abrufen von Datenquellen (MSK),-Entitätsprofile (MSC3) Semantische Graphenentdeckung (MSSK4) und parallele lange --Formsynthese

RAG tiefe Tauchgänge

• RAG-Grundierung Grundkonzepte für die Retrieval-Erzeugung
• RAG-Architektur Systemdesign-Muster für RAG
• Hybride Suche und Indexierung Kombination von dichtem und spärlichem Wiederauffinden
• RAG-Praktische Anwendungen Verwendungsfälle in der Welt

GraphRAG

• GraphRAG-:-Wissensgraphen für RAG Wenn die Vektorsuche ausreichend ist
• GraphRAG Minimale Durchführbarkeit Bau eines funktionierenden GraphRAG-Systems

Verwandte Werkzeuge

• Semantische Suche mit ONNX und Qdrant Die Bausteine
• Selbstbeleuchtete Vektordatenbanken:-Qdrant Qdrant wird lokal ausgeführt
• Analyse großer CSV-Dateien mit lokalen LLMs Gleiches Muster Unterschiedliche Domäne
• Abrufen und Analysieren von Webinhalten mit LLMs Web-Schrottung für RAG
• Dienst für die Konvertierung von Multi---Formatdokumenten Ein Tieftauchgang wird beschrieben.

Verknüpfungen

• NuGet-Paket
• GitHub Kernbibliothek
• GitHub CLI Werkzeug