# DocSummarizer 部件 @ 4 @ @ MPK1_ 大楼RAG管道

<!--category-- AI, LLM, RAG, C#, Embeddings, ONNX, Semantic Search -->
<datetime class="hidden">2025-12-30T17:00</datetime>

[![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)
[![“.NET”](https://img.shields.io/badge/.NET-8.0%20%7C%2010.0-512BD4)](https://dotnet.microsoft.com/)
[![节点@. @js](https://img.shields.io/badge/Node.js-18%2B-339933)](https://nodejs.org/)

这是 **部分#4** 文档缩写器序列中的“.”和“DocSummerizer” [部分#1](/blog/building-a-document-summarizer-with-rag) 用于构建“,”的架构 [部分#2](/blog/docsummarizer-tool) 用于 CLI 工具@,}或 [部分#3](/blog/docsummarizer-advanced-concepts) 深潜在嵌入器上... .......

> **RAG的硬部分是'}(LLM) □.} 它在LLMA.之前的一切**

您可能看到过将文档分割成块的图案@ :} 在矢量数据库中生成嵌入@ I, @ 获取相关块\ MS K5 在理论上发送到 LLM @ .{ 简单

- 每个格式的文档解析器
- 尊重语义边界的推论
- 与您的嵌入模型匹配的名声化
- 高效嵌入生成的分隔
- 萨利得分,所以不是所有块都一样
- 引用追踪 这样你就能知道答案来自何方

在您写出单行应用代码前, '#% 有很多基础设施。

**DocSummarizer.Core 在一个单一的软件包中处理全部** @- 既可用於@.NET, 也可用于Node}.js.

DocSummarizer .Core 本质上是 a **文件文件情报层**“:”确定性结构首先“,”概率检索第二“MS K2” 它解决了信息问题,以便您能够专注于推理问题 ‘.’

### 摄取管道

在这里,' @%s DocSummarizer 所做的@-}和批判的, @ what it *{\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}真的* :

```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<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
```

**DocSummarizer 所做的 @ ( @ green box@ MS K1 @**

- 保存结构的文件
- 分割成语义区段@ ( @ non 任意区块\ )}
- 与ONNX 生成本地嵌入
- 计算突出分数
- 指定带有字符位置的引用标识符

**你做什么? (蓝色盒子吗?**

- 在矢量数据库中存储片段
- 构建您的检索逻辑

**查询时间发生什么?**

- 嵌入了问题@( @same model_)
- 获取相似的区段
- 发送到LLM 合成

**关键洞察力:** LLM {(} 红边框)} 只在查询时间才参与 <%.> 摄入是完全决定性的\ -} 同一文档总是产生相同的部分*.} 这就是为什么RAG可以复制和调试@.}

**可复制性奖金:** 确定性摄取度意味着您可以像任何其他建筑工序一样,重做-index , diff, 并调试您的RAG管道@. 没有即时差异\,没有模式温度 @-只是纯净}, 可测试的数据工程_.

### 为什么没有接收者LLM ?

对于 RAG,}您想要的 *实际实际数* 您的文档中的“ -” 不是 LLM @ -} 生成了副句子@ MS K2} 当用户询问“ MPK3” 时, 合同对终止Q?", 表示什么? 您需要检索真实的合同文本\,} 而不是它的摘要=.}

LLM后来在查询时间 , 以合成从回收块中找到的回答@.\ 但它本身应该是逐字源材料 @.}这让引用有意义

DocSummerizer ' `ExtractSegmentsAsync` 为您提供正確的此@ : @ 包含嵌入内容的原始文本区段, 已准备用于检索 @ MS K2} no LLM 涉及摄入@ MPK3}

[TOC]

## 价值提案

在这里,'你得到什么与一个 `dotnet add package`:

```bash
dotnet add package Mostlylucid.DocSummarizer
```

- **智能分割** - 标题上的分割@, 尊重语义边界
- **ONNX 嵌入器** -}本地端 @,}无 API 键,}型号自动=-}下载 *(~23#MB})}*
- **色素评分** -pre- 认为每个部分都很重要
- **引用跟踪** 每个区段都有独一无二的ID
- **多种格式** - @ Markdown@,} HTML #,# PDF_ , DOCX @(}与 Docling+)
- **矢量存储选项** @ -_ 在Memory,} DuckDBMS K2} Qdrant building *-} 在MeyoryMSK1 duckD&Z,} * 建造的 Qdrant buding * MSC3}

无 Python.无外部 APIs.没有复杂的设置@.在第一个模型下载后脱机工作 @.

## 提取线段@: @% the Core API

最简单的使用大小写 @ - @ 提取部分, 有嵌入为您的矢量仓库准备@ MS K1} {

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

**产出=:**

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

@ -} 只要有嵌入和源代码的片段@.# 准备进入您的矢量数据库 @. @

### 文件编号

每个区段@' @%s `Id` 由文档 ID 加类型和索引\:}构建 `{docId}_{type}_{index}`.

您可以提供您自己的文档 ID @ ,} 或者让 DocSummarizer 从内容 hash@ MS K1 中计算一个文件 。

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

**为什么这对RAG:很重要?**

- 自定义 ID 让您将部分与文档管理系统相连接
- 内容@ - @ hash ID 确保重新 MS K1} 索引化同一文档时产生相同的片段 ID
- 两种方法都支持稳定引用“-” `[s42]` 总是对同一源文本下定决心

## 线段中什么是's

每个提取的段段包含您需要的所有 RAG: @ {}

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

缩略 `Id` 当您的 LLM 输出时, 是引用跟踪\ .}% 1 的关键值 `[s42]`, 您可以用它返回到源的确切位置 `StartChar`/`EndChar`.

**Bonus:** 缩略 `ExtractionResult` 包括引用解析的帮助方法@: @%

```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());  // <span class="highlight">...</span>
Console.WriteLine(highlight.ToMarkdown()); // **...**
```

## 插入矢量仓库

DocSummarizer 向您提供嵌入式@ . @ 使用任何您喜欢的矢量数据库 .} @

### 解冻

```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 + pgvictor

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

### 或使用内建的MSKO在商店

DocSummarizer 包括三个后端@: @%

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

## 为何素益重要

大多数RAG系统之所以失败,不是因为嵌入是坏的 @,,而是因为所有块都被视为同等重要的@.。

```mermaid
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
```

抽象的句子比附录中的单词更重要 .\ docSummarizer pre-}计算此\ MPK2\ {

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

**盐度系数**

@|因子 @ |}效果 @MS K2
|--------|--------|
“|”位置“|”内插“/”结论性判决得分高于“MSC3”
标题后面的第一句是主题句子
-=YTET -伊甸园字幕组=- 翻译:
| 片段类型 @|_#摘要@/Introducteed\ ,}參考 •/Appendix 降为%|{
|内容类型 @|代码块@,引号#,列表有不同加权的Q|

这意味着您的检索可按 `(similarity * salience)` 而不是单纯的相似性 @.

## 文件分类

DocSummarizer 自动\ -\ 检测文档类型,在内容上使用超光度@:\

```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
```

**分类影响检索**: retreatval 深度比例尺, 带有文档 entropy, 不是一个硬码的顶端 K}. 叙述性文件 {(fiction, 故事_ ) 得到一个“1.5x” 推进来进行检索计数, 因为他们需要更多的上下文@. 具有明确结构的技术文档需要更少\.}

超自然学看:

- 代码区块频率 @ ( @ technology@ MS K1#
- 标题结构 @(_academicial_,}技术_)
- 对话框模式 @(_nartalation@)}%
- 法律术语 “(”合同“)”
- 列出密度 * @(_ documentation\% )}

如果超常性不确定的话 , docSummarizer 可以选择返回快速 LLM 分类, 使用 MS K1 @ sentinel}" model@. 这需要 Ollama 用小模型在本地运行 `tinyllama`@ . 通过配置启用@ MS K1#

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

对于大多数文档来说 , 光是超自然论就足够准确了

## RAG 完整管道插管示例

这里的'是完整的索引-和MS K2Qquery 管道.WeMSKO4将它以三步制成

```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
```

### 步骤 @1:}数据结构

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

在生产过程中,'d 使用一个真实的矢量数据库@(drant,pgvector,}等{.),},但这显示了核心模式_.

### 2: 索引文档

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

注::没有涉及的LLM .We'储存 *实际数* 文档中的文本@,不是摘要 @.

### 步骤 @3:查询

```csharp
    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
    }
```

返回的上下文包含 *实实际* 您的 LLM 提示可能看起来像@ :}

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

Context:
{context}

Question: {question}
```

### 数学: (+Standard Consine 相似性=)

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

DocSummamer 包括 `VectorMath.CosineSimilarity()` 如果您不想自己写这个... ... ....

DocSummarizer 也暴露了 `IEmbeddingService` 如果您需要将查询与完整汇总管道分别嵌入\ .

## 嵌入模型

默认为 `AllMiniLmL6V2` @ - @ fast@ , @ small @ ,} 基于您的需要选择@ MS K4 @ title

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

|Q 型号@|QDims @|}马克思·托肯斯 *|Q大小 @MS K4QNT Notes #|#
|-------|------|------------|------|-------|
| `AllMiniLmL6V2` @| 384 | @ @MS K3 @#| @%~23MB _|默认□,}快速{|
| `BgeSmallEnV15` -=YTET -伊甸园字幕组=- 翻译:
| `BgeBaseEnV15` @| 768 @#| 512 #|~110#MB @MS K6生产质量 @MSC7#
| `JinaEmbeddingsV2BaseEn` |+#768+ @| _8192}(|+%) *~137+MB #|+长篇文件*|+

模型自 Hugging Face 首次使用后自动下传@. @随后从磁盘中运行负载=%.}

## 开放遥测

监控您正在生产的RAG输油管 @:

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

**密钥 mitus:**

- `docsummarizer.summarizations` 请求数
- `docsummarizer.summarization.duration` - 处理时间( ms)
- `docsummarizer.document.size` -文档大小
- `docsummarizer.ollama.embed.requests` “- 嵌入的API电话

## 格式支持

DocSummarizer 使用智能检测和处理来处理多个文档格式@. @%

### 直接处理 无外部依赖 **

这些格式按本地处理 * @-}没有文件或其他所需服务* :

|格式 @|扩展 *|}处理@|
|--------|-----------|------------|
| 马克唐 MS K1 * `.md`, `.markdown` | 与Markdig, 结构保存 *|
@ | @ 纯文本 @ I| @ `.txt`, `.text` @|_ 依段落拆分@(}双行新线{)}|}
|+HTML#|+ `.html`, `.htm` | 保护, 转换为 Markdown @|
|ZIP档案 `.zip` | 提取文本文件@, Outo @-detects Gutenberg 格式 _|

**普通文本获得智能处理**: 当没有标记标题\ , 段落的块切开器 MS K2 以分裂为主\ I. 它检测文档结构是否超常 {- 如果您的文本有明确的段落折断@,} 它们成为块边框 @.

```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
```

### 带文档的丰富文件

对于 PDF, DOCXMS K1 PPTXMPK2 XLSX ,和图像 < mSPK4OCR)\ @ @ -添加 docling}:

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

文档保存文档结构@-}标题 @,}表格_,}列表以正确的 Markdown=%.}通过, 这意味着比原始文本提取更好的块子\.

|格式 @|扩展 *|注@|
|--------|-----------|-------|
-=YTET -伊甸园字幕组=- 翻译: `.pdf` |Text @+布局保存@,}表格转换为#|
# M| 单词 * | * `.docx` @ |_ 完整格式化@ MS K1}标题 @ MPK2} 列表 *|
@|_Powerpoint\ |# `.pptx` “|”幻灯片变为“|”部分。
-=YTET -伊甸园字幕组=- 翻译: `.xlsx` @| 抽取的表格@|
@| 图像@| `.png`, `.jpg`, `.tiff` @| OCR通过 docling #|#

见见 [部分#1](/blog/building-a-document-summarizer-with-rag) 文档整合上的更多信息@, @% 或 [多@ -_ @ format 文档转换](/blog/building-a-lawyer-gpt-for-your-blog-part9) 深沉潜水时的

## 您跳过的硬部件

@|}问题 @ |# DocSummerizer Solution@|
|---------|----------------------|
@|_在语义边界的 |_BARBAR_在标题上的分割,\Q}组相关内容@|}
| 每个型号 | 使用正确的印记器 对每个ONNX 型号 < MS K2 >
| 嵌入批量 * MS K1 可配置批量大小 * , 内存 *- 高效 * @|
“| ” 追踪“| ” 每个区段都有独特之处。 `SegmentId` |
|格式转换@|Markdown @,HTML,PDF,DOCX 通过单一API\|
| 模式下载@/ @caching *|}自动{-}%downloads_,}缓存在其中 `~/.docsummarizer` |

## 摘要摘要

RAG管道需要基础设施, 才能在有趣的部分 @._DocSummarizer@.}(Core)交给你#:之前,

1. **嵌入线段** & - @% 1 已准备进入任何矢量仓库
2. **优等分数** - 并非所有块都相等
3. **引用跟踪** 知道答案来自何方
4. **本地端@- @% 1** -无 API 键@, 离线运行
5. **生产量遥测** *- 位于

```bash
dotnet add package Mostlylucid.DocSummarizer
```

管道已经完工了. 构建您的 RAG AppMS K1

## 相关条款

### DocSummaizer 丛书

- [部分 @1 @ @ @ -# 建筑结构@&}模式](/blog/building-a-document-summarizer-with-rag) “- ”为什么管道方法起作用?
- [使用此工具](/blog/docsummarizer-tool) -CLI 安裝@, 模式 @,樣本
- [部分: 3 @ @ @ MS K1_ 高级概念](/blog/docsummarizer-advanced-concepts) -BERT嵌入,ONNXMS K2混合搜索
- [部分@5 @ @ @ -_ DoomSummerizer @:}深层研究](/blog/doomsummarizer-deep-research) - 多-来源检索@,实体剖析 *,语义图解发现*,和平行长MS K5法合成

### RAG 深海底潜水器

- [RAG 开源器](/blog/rag-primer) 用于检索的基础概念 @-_QAUG 一代
- [RAG 建筑结构](/blog/rag-architecture) ASG的系统设计模式
- [混合查找和索引](/blog/rag-hybrid-search-and-indexing) 将密集和稀少的检索结合起来
- [RAG 实际应用](/blog/rag-practical-applications) -Real-世界使用案例

### 图图RAG

- [RAG 知识图示](/blog/graphrag-knowledge-graphs-for-rag) *% -* 当矢量搜索为 < ' t}
- [图图RAG 最低限度可行实施](/blog/graphrag-minimum-viable-implementation) 建立工作图示系统

### 相关工具

- [用 ONNX 和 Qdrant 进行语义搜索](/blog/semantic-search-with-onnx-and-qdrant) *-* 构件
- [自动-主矢量数据库 @:Qdrant](/blog/self-hosted-vector-databases-qdrant) - 正在本地執行 Qdrant
- [用本地 LLM 分析大型 CSV 文件](/blog/analysing-large-csv-files-with-local-llms) -}相同模式 @,}不同的域名
- [使用 LLMM 获取和分析网络内容](/blog/fetching-and-analysing-web-content-with-llms) -RAG的网络剪切
- [多@-_}格式化文件转换服务](/blog/multi-format-document-conversion-service) 深入潜水

## 链接链接链接

- [NuGet 软件包](https://www.nuget.org/packages/Mostlylucid.DocSummarizer)
- [GitHub 核心图书馆](https://github.com/scottgal/mostlylucidweb/tree/main/Mostlylucid.DocSummarizer.Core)
- [GitHub -CLI 工具](https://github.com/scottgal/mostlylucidweb/tree/main/Mostlylucid.DocSummarizer)