Bitzsoft.Integrations.RAG 1.0.0-alpha.2

Bitzsoft.Integrations.RAG

检索增强生成 -- Qdrant 向量数据库 + Ollama 嵌入模型集成，开箱即用的 RAG 解决方案。

功能特性

• 基于 Qdrant 向量数据库的高性能相似度检索
• 集成 Ollama 嵌入模型，支持单条与批量文本向量化
• 提供完整的文档处理管线：清理、分块（按段落 / 按固定大小）、嵌入、索引
• 自动生成基于检索结果的系统提示词（SystemPrompt），无缝对接 AI 对话流程
• 支持相似度阈值过滤与 Top-K 检索
• 所有服务均通过 DI 注册，可独立替换各层实现

安装

dotnet add package Bitzsoft.Integrations.RAG

或通过 csproj 引用：

<PackageReference Include="Bitzsoft.Integrations.RAG" Version="*" />

配置

在 appsettings.json 中添加以下配置节：

{
  "Ollama": {
    "Url": "http://localhost:11434",
    "ApiKey": "",
    "DefaultModel": "nomic-embed-text",
    "VectorSize": 1536
  },
  "Qdrant": {
    "Url": "http://localhost:6334",
    "ApiKey": "",
    "CertificateThumbprint": ""
  }
}

Ollama 配置

Qdrant 配置

注册服务

using Bitzsoft.Integrations.RAG;
using Bitzsoft.Integrations.RAG.Ollama;
using Bitzsoft.Integrations.RAG.Qdrant;

// Program.cs / Startup.cs
services.AddRAG(
    configureOllama: options =>
    {
        options.Url = "http://localhost:11434";
        options.DefaultModel = "nomic-embed-text";
        options.VectorSize = 1536;
    },
    configureQdrant: options =>
    {
        options.Url = "http://localhost:6334";
        options.ApiKey = "your-qdrant-api-key";
    });

AddRAG 会同时注册 IOllamaService、IQdrantService 和 IRAGService 三个服务，均可在 DI 容器中独立注入使用。

使用示例

文档索引与检索问答

using Bitzsoft.Integrations.RAG;
using Bitzsoft.Integrations.RAG.Dto;
using Bitzsoft.Integrations.RAG.Ollama;

public class KnowledgeBaseService
{
    private const string CollectionName = "company-docs";

    private readonly IRAGService _ragService;
    private readonly IOllamaService _ollamaService;

    public KnowledgeBaseService(IRAGService ragService, IOllamaService ollamaService)
    {
        _ragService = ragService;
        _ollamaService = ollamaService;
    }

    /// <summary>
    /// 索引一篇文档到知识库
    /// </summary>
    public async Task<bool> IndexDocumentAsync(
        string content,
        string fileName,
        string title,
        string category = "",
        CancellationToken ct = default)
    {
        // 清理文档内容
        var cleanedContent = DocumentProcessor.CleanDocument(content);

        // 索引到 Qdrant（自动按段落分块并生成向量）
        return await _ragService.IndexDocumentAsync(
            collectionName: CollectionName,
            content: cleanedContent,
            sourceFile: fileName,
            title: title,
            category: category);
    }

    /// <summary>
    /// 基于知识库回答用户问题
    /// </summary>
    public async Task<(string Answer, List<DocumentChunkDto> Sources)> AskAsync(
        string question,
        CancellationToken ct = default)
    {
        // 1. 将用户问题向量化
        var queryVector = await _ollamaService.GetEmbeddingAsync(question, ct);

        // 2. 检索相关文档并生成 SystemPrompt
        var (success, systemPrompt, documents) = await _ragService.GetSystemPromptAsync(
            collectionName: CollectionName,
            queryVector: queryVector,
            topK: 3,
            scoreThreshold: 0.7);

        // 3. 将检索结果作为上下文传给 AI（此处以 IAIClient 为例）
        // var aiResult = await _aiClient.SendAsync(question, systemPrompt, cancellationToken: ct);
        // return (aiResult.GetContent() ?? "无法回答", documents);

        return (systemPrompt, documents);
    }
}

按固定大小分块索引

using Bitzsoft.Integrations.RAG;
using Bitzsoft.Integrations.RAG.Dto;

public class ChunkedIndexingService
{
    private readonly IRAGService _ragService;

    public ChunkedIndexingService(IRAGService ragService)
    {
        _ragService = ragService;
    }

    /// <summary>
    /// 使用固定大小分块策略索引长文档
    /// </summary>
    public async Task<bool> IndexWithFixedSizeChunksAsync(
        string content,
        string fileName,
        string title,
        CancellationToken ct = default)
    {
        // 按固定大小分块，每块 800 字符，重叠 100 字符
        var textChunks = DocumentProcessor.ChunkBySize(
            content,
            chunkSize: 800,
            overlap: 100);

        // 构建文档块 DTO 列表（向量将由 IndexChunksAsync 自动生成）
        var chunks = textChunks.Select((text, index) => new DocumentChunkDto
        {
            Id = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() + index,
            Content = text,
            SourceFile = fileName,
            Title = title,
            Category = "manual-chunk",
            ChunkIndex = index
        }).ToList();

        return await _ragService.IndexChunksAsync("large-docs", chunks);
    }
}

直接使用底层向量数据库服务

using Bitzsoft.Integrations.RAG.Dto;
using Bitzsoft.Integrations.RAG.Ollama;
using Bitzsoft.Integrations.RAG.Qdrant;

public class VectorSearchService
{
    private readonly IQdrantService _qdrantService;
    private readonly IOllamaService _ollamaService;

    public VectorSearchService(IQdrantService qdrantService, IOllamaService ollamaService)
    {
        _qdrantService = qdrantService;
        _ollamaService = ollamaService;
    }

    /// <summary>
    /// 创建集合并初始化
    /// </summary>
    public async Task<bool> InitializeCollectionAsync(string name, CancellationToken ct = default)
    {
        return await _qdrantService.CreateCollectionAsync(name, vectorSize: 1536);
    }

    /// <summary>
    /// 自定义相似度搜索
    /// </summary>
    public async Task<List<DocumentChunkDto>> SearchAsync(
        string query,
        string collectionName,
        int topK = 5,
        double minScore = 0.75,
        CancellationToken ct = default)
    {
        var queryVector = await _ollamaService.GetEmbeddingAsync(query, ct);

        return await _qdrantService.SearchAsync(
            collectionName,
            queryVector,
            (ulong)topK,
            scoreThreshold: minScore);
    }

    /// <summary>
    /// 批量嵌入
    /// </summary>
    public async Task<List<float[]>> BatchEmbedAsync(
        IEnumerable<string> texts,
        CancellationToken ct = default)
    {
        return await _ollamaService.GetEmbeddingsAsync(texts, ct);
    }
}

相关包