# DocSummarizer Teil 4-- - Gebäude RAG Pipelines [![NuGet](https://img.shields.io/nuget/v/Mostlylucid.DocSummarizer?label=NuGet)](https://www.nuget.org/packages/Mostlylucid.DocSummarizer) [![npm](https://img.shields.io/npm/v/@mostlylucid/docsummarizer?label=npm)](https://www.npmjs.com/package/@mostlylucid/docsummarizer) [![NIEDERLANDE](https://img.shields.io/badge/.NET-8.0%20%7C%2010.0-512BD4)](https://dotnet.microsoft.com/) [![Knotenpunkt](https://img.shields.io/badge/Node.js-18%2B-339933)](https://nodejs.org/) Das ist **Teil** von der DocSummarizer-Serie [Teil](/blog/building-a-document-summarizer-with-rag) für die Architektur [Teil](/blog/docsummarizer-tool) für das CLI-Werkzeug [Teil](/blog/docsummarizer-advanced-concepts) 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-Schicht**Es 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 ```mermaid 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
(ONNX - Local)"] SCORE["Compute Salience"] CITE["Assign Citation IDs"] PARSE --> SEGMENT SEGMENT --> EMBED EMBED --> SCORE SCORE --> CITE end subgraph OUTPUT["Output (ExtractionResult)"] SEGMENTS[/"Segments[]
• Original text (verbatim)
• float[384] embedding
• Salience score
• StartChar / EndChar
• Section context"/] end subgraph YOURS["Your Code"] STORE[("Vector Store
(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.... [TOC] ## Die Wertvorlage Hier ist, was Sie mit einem erhalten `dotnet add package`: ```bash 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. ```csharp using Microsoft.Extensions.DependencyInjection; using Mostlylucid.DocSummarizer; // Setup DI var services = new ServiceCollection(); services.AddDocSummarizer(); var provider = services.BuildServiceProvider(); var summarizer = provider.GetRequiredService(); // 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 ```csharp // 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 ```csharp 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 ```csharp 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()); // ... Console.WriteLine(highlight.ToMarkdown()); // **...** ``` ## Einstecken in Vector Stores DocSummarizer gibt Ihnen die Einbettungen.Verwenden Sie, was Vektor-Datenbank Sie mögen. ### Qdrant ```csharp 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 ```csharp 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. ```csharp 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. ```mermaid flowchart LR subgraph DOC["Document"] H1["# Title"] P1["First paragraph
(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. ```csharp // 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 ```csharp 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 aus**Weitere 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. `tinyllama`Aktivieren Sie es über die Konfiguration. ```csharp 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. ```mermaid 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 ```csharp public class SimpleRagService { private readonly IDocumentSummarizer _summarizer; // In-memory segment store - maps "docId:segmentId" to the full segment private readonly Dictionary _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 ```csharp 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 ```csharp public async Task 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 ```csharp 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 ```csharp services.AddDocSummarizer(options => { options.Onnx.EmbeddingModel = OnnxEmbeddingModel.BgeBaseEnV15; }); ``` Beschreibung des Modells | Ausprägungen Max-Tokens | Ausprägnierungen | Ausprägen |-------|------|------------|------|-------| | `AllMiniLmL6V2` |-M384-|-MNSK3-MUSK4-MKSK5-MB-MWSK6-Standard-,-Schnell-|- | `BgeSmallEnV15` Weitere Informationen: http://europa.eu.int/comm/index_de.htm | `BgeBaseEnV15` |-768-M|-MNSK3-MUSK4-MKSK5-MB-Qualität | `JinaEmbeddingsV2BaseEn` Lange Dokumente Modelle auto-Download von HuggingFace beim ersten Einsatz ,. , nachfolgende läuft Last aus disk , . , ## OpenTelemetrie Überwachen Sie Ihre RAG-Pipeline in der Produktion ```csharp 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 Handhabung**Wenn 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. ```csharp // 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 ```bash docker run -d -p 5001:5001 quay.io/docling-project/docling-serve ``` ```csharp 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](/blog/building-a-document-summarizer-with-rag) für mehr über die Docling-Integration oder [Umwandlung von Multi---Format-Dokumenten](/blog/building-a-lawyer-gpt-for-your-blog-part9) 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 ```bash dotnet add package Mostlylucid.DocSummarizer ``` Die sanitären ist getan. Build Ihre RAG-App ## Verwandte Artikel ### Reihe DocSummarizer - [Teil-Architektur Muster](/blog/building-a-document-summarizer-with-rag) Warum der Pipeline-Ansatz funktioniert - [Teil mit dem Werkzeug](/blog/docsummarizer-tool) CLI-Installation modi M, templates - [Teil - Fortgeschrittene Konzepte](/blog/docsummarizer-advanced-concepts) BERT-Einbettungen ONNX-, - [Teil 5------DoomSummarizer--:-Tiefforschung](/blog/doomsummarizer-deep-research) Mehrsprachiges Abrufen von Datenquellen (MSK),-Entitätsprofile (MSC3) Semantische Graphenentdeckung (MSSK4) und parallele lange --Formsynthese ### RAG tiefe Tauchgänge - [RAG-Grundierung](/blog/rag-primer) Grundkonzepte für die Retrieval-Erzeugung - [RAG-Architektur](/blog/rag-architecture) Systemdesign-Muster für RAG - [Hybride Suche und Indexierung](/blog/rag-hybrid-search-and-indexing) Kombination von dichtem und spärlichem Wiederauffinden - [RAG-Praktische Anwendungen](/blog/rag-practical-applications) Verwendungsfälle in der Welt ### GraphRAG - [GraphRAG-:-Wissensgraphen für RAG](/blog/graphrag-knowledge-graphs-for-rag) Wenn die Vektorsuche ausreichend ist - [GraphRAG Minimale Durchführbarkeit](/blog/graphrag-minimum-viable-implementation) Bau eines funktionierenden GraphRAG-Systems ### Verwandte Werkzeuge - [Semantische Suche mit ONNX und Qdrant](/blog/semantic-search-with-onnx-and-qdrant) Die Bausteine - [Selbstbeleuchtete Vektordatenbanken:-Qdrant](/blog/self-hosted-vector-databases-qdrant) Qdrant wird lokal ausgeführt - [Analyse großer CSV-Dateien mit lokalen LLMs](/blog/analysing-large-csv-files-with-local-llms) Gleiches Muster Unterschiedliche Domäne - [Abrufen und Analysieren von Webinhalten mit LLMs](/blog/fetching-and-analysing-web-content-with-llms) Web-Schrottung für RAG - [Dienst für die Konvertierung von Multi---Formatdokumenten](/blog/multi-format-document-conversion-service) Ein Tieftauchgang wird beschrieben. ## Verknüpfungen - [NuGet-Paket](https://www.nuget.org/packages/Mostlylucid.DocSummarizer) - [GitHub Kernbibliothek](https://github.com/scottgal/mostlylucidweb/tree/main/Mostlylucid.DocSummarizer.Core) - [GitHub CLI Werkzeug](https://github.com/scottgal/mostlylucidweb/tree/main/Mostlylucid.DocSummarizer)