Inleiding

📖 Del av RAG-serien Detta är en del 5 - produktionsintegreringsmönster

Del 1: RAG ursprung och grundlagen - Vad är inbäddar , varför de är viktiga
Del 2: RAG arkitektur och inre - ,-tokenisering
Del 3: RAG i praktiken - Att bygga kompletta RAG-system
Del 4a: ONNX & Garantiimplementering - CPU-vänligt semantisk sökgrund
Del 4b: Semantisk sökande i aktivitet - Typahead, ,, hybridsökning, , och gränssnittkomponenter
Del 5: Hybridsökning & Auto-Indexering (den här artikeln) - Tillverkningsintegreringsmönster
Del 6: GraphRAG - kunskapsgrafer för korpusen

I Del 4a, vi byggde grunden : ONNX-integreringar och Qdrant lagring Del 4b,, vi tog in sökinterfacet och implementerade den hybrida sökningen. ., nu kommer vi att göra det till produktion. automatisk indexering (zeroM SK1tillkänna innehållsupdater ) via FileSystemWatcher.

Hybrida sökningar : Det bästa av båda världarna

Semantiska sökningar är kraftfulla men traditionella fulla Lösningen? Använd båda

Varför Hybrid? olika angrepp har olika styrkor:

PostgreSQL Full-Text (täckt här): Exakt matchar, tekniska termer, Boolean-operatörer
Semantisk vektorsökning: Meaning , context, synonymerM SK3 konceptuellt besläktad innehåll

Reciprokal rankfuusio (RRFM SK1

Vi använder Reciprokal rangfuusion att kombinera resultat från flera sökkällor:

flowchart TB
    A[User Query: 'docker containers'] --> B[PostgreSQL Full-Text Search]
    A --> C[Semantic Vector Search]

    B --> D["Results:<br/>1. 'Docker Basics' (rank 1)<br/>2. 'Containerizing Apps' (rank 2)<br/>3. 'Docker Compose' (rank 3)"]
    C --> E["Results:<br/>1. 'Containerizing Apps' (rank 1)<br/>2. 'Kubernetes Guide' (rank 2)<br/>3. 'Docker Basics' (rank 3)"]

    D --> F[RRF Algorithm]
    E --> F

    F --> G["Combined Results:<br/>1. 'Containerizing Apps'<br/>   (1/61 + 1/62 = 0.0328)<br/>2. 'Docker Basics'<br/>   (1/61 + 1/63 = 0.0322)<br/>3. 'Docker Compose'<br/>   (1/63 = 0.0159)"]

    style A stroke:#10b981,stroke-width:2px
    style B stroke:#3b82f6,stroke-width:2px
    style C stroke:#6366f1,stroke-width:2px
    style D stroke:#3b82f6,stroke-width:2px
    style E stroke:#6366f1,stroke-width:2px
    style F stroke:#ec4899,stroke-width:4px
    style G stroke:#8b5cf6,stroke-width:2px

RRF-formulären: score = Σ(1 / (k + rank))

k = 60 | | ( | konstant för att förhindra att första rangen dominerar
rank = position i den sökmetoden
Resultat i båda källor får poäng från varje tillsatta tillsammans

Varför fungerar RRF:

Reduktion: Samma resultat i båda källorna med högre poäng
Rättvisa: Ingen sökmetod dominerar orättvist
Enkelhet: Inga komplexa tunning krävs

Implementering

public class HybridSearchService : IHybridSearchService
{
    private readonly ISemanticSearchService _semanticSearchService;
    private const int RrfConstant = 60;

    public async Task<List<SearchResult>> SearchAsync(
        string query,
        string language = "en",
        int limit = 10,
        CancellationToken cancellationToken = default)
    {
        // Execute both searches in parallel
        var semanticResults = await _semanticSearchService.SearchAsync(
            query, limit * 2, cancellationToken);

        // Filter by language and apply RRF
        var filteredResults = semanticResults
            .Where(r => r.Language == language)
            .ToList();

        return ApplyReciprocalRankFusion(filteredResults)
            .Take(limit)
            .ToList();
    }

    private List<SearchResult> ApplyReciprocalRankFusion(List<SearchResult> results)
    {
        var rrfScores = new Dictionary<string, RrfScore>();

        for (int i = 0; i < results.Count; i++)
        {
            var result = results[i];
            var key = $"{result.Slug}_{result.Language}";

            if (!rrfScores.ContainsKey(key))
                rrfScores[key] = new RrfScore { Result = result };

            // RRF formula: 1 / (k + rank)
            rrfScores[key].Score += 1.0 / (RrfConstant + i + 1);
        }

        return rrfScores.Values
            .OrderByDescending(x => x.Score)
            .Select(x => x.Result)
            .ToList();
    }
}

Nota: Det här visar endast semantiska sökningar. I produktionen , utför PostgreSQL fulla- textsökning parallellt och inbegrip dessa resultat i RRF beräkningen

Integrering

Om du redan implementerat PostgreSQL fullsom täckts här), att lägga till semantisk sök är enkelt

// Program.cs
services.AddSemanticSearch(configuration);
services.AddSingleton<IHybridSearchService, HybridSearchService>();

[HttpGet("search/hybrid")]
public async Task<IActionResult> HybridSearch(string query, string language = "en")
{
    var results = await _hybridSearchService.SearchAsync(query, language);
    return PartialView("_SearchResults", results);
}

Automatisk indexering med File System Watcher

Den kraftfullaste egenskapen: automatisk indexering. spara en bloggpost

Hur det fungerar

flowchart TB
    A[Save Markdown File] --> B[FileSystemWatcher Detects Change]
    B --> C{File in Main Directory?}
    C -->|Yes| D[Save to Database]
    C -->|No| E[Save to Database Only]
    D --> F[Create BlogPostDocument]
    F --> G[Generate Embedding via ONNX]
    G --> H[Store in Qdrant]
    H --> I[Post Searchable Immediately]

    style A stroke:#10b981,stroke-width:2px
    style B stroke:#f59e0b,stroke-width:2px
    style C stroke:#ec4899,stroke-width:3px
    style D stroke:#3b82f6,stroke-width:2px
    style E stroke:#6b7280,stroke-width:2px
    style F stroke:#8b5cf6,stroke-width:2px
    style G stroke:#6366f1,stroke-width:3px
    style H stroke:#ef4444,stroke-width:2px
    style I stroke:#10b981,stroke-width:2px

Nyckeldesign lösning: Bara indexdateer i huvud Markdown-folder, inte underordningar (translated/, drafts/, comments/). Det gör att sökindexet är ren

Att integrera File Watcher

Boken har redan en MarkdownDirectoryWatcherService. Vi utökar den till att aktivera semantisk indexering

// In MarkdownDirectoryWatcherService.cs
private async Task OnChangedAsync(WaitForChangedResult e)
{
    if (e.Name == null) return;

    await retryPolicy.ExecuteAsync(async () =>
    {
        var savedModel = await blogService.SavePost(slug, language, markdown);

        // Index ONLY if file is in main directory (no path separators in name)
        if (!e.Name.Contains(Path.DirectorySeparatorChar) &&
            !e.Name.Contains(Path.AltDirectorySeparatorChar))
        {
            await IndexPostForSemanticSearchAsync(scope, savedModel, language);
        }
    });
}

private async Task IndexPostForSemanticSearchAsync(
    IServiceScope scope,
    BlogPostDto post,
    string language)
{
    var semanticSearchService = scope.ServiceProvider.GetService<ISemanticSearchService>();
    if (semanticSearchService == null) return; // Not configured

    var document = new BlogPostDocument
    {
        Id = $"{post.Slug}_{language}",
        Slug = post.Slug,
        Title = post.Title,
        Content = post.PlainTextContent,
        Language = language,
        Categories = post.Categories?.ToList() ?? new List<string>(),
        PublishedDate = post.PublishedDate
    };

    await semanticSearchService.IndexPostAsync(document);
    _logger.LogInformation("Indexed {Slug} ({Language}) in semantic search", post.Slug, language);
}

Att lösa rader

När ett meddelande är löscht, löser du det från den semantiska indexen.

private async Task OnDeletedAsync(WaitForChangedResult e)
{
    await blogService.Delete(slug, language);

    // Delete from semantic search ONLY if file was in main directory
    if (!e.Name.Contains(Path.DirectorySeparatorChar) &&
        !e.Name.Contains(Path.AltDirectorySeparatorChar))
    {
        var semanticSearchService = scope.ServiceProvider.GetService<ISemanticSearchService>();
        await semanticSearchService?.DeletePostAsync(slug, language);
    }
}

Hintergrundtjänster för inledande indexering

När man startar upp ett ",", så indekserar en bakgrundstjänst existerande jobb som inte är ännu i Qdrant.

flowchart TB
    A[Application Starts] --> B[Wait 10 seconds]
    B --> C[Initialize Semantic Search]
    C --> D{Model Exists?}
    D -->|No| E[Download from Hugging Face]
    D -->|Yes| F[Load ONNX Model]
    E --> F
    F --> G[Scan Main Markdown Directory]
    G --> H{For Each .md File}
    H --> I[Compute Content Hash]
    I --> J{Hash Changed?}
    J -->|Yes| K[Generate Embedding]
    J -->|No| L[Skip - Already Indexed]
    K --> M[Store in Qdrant]
    M --> H
    L --> H
    H -->|Done| N[Indexing Complete]

    style A stroke:#10b981,stroke-width:2px
    style C stroke:#6366f1,stroke-width:2px
    style E stroke:#f59e0b,stroke-width:2px
    style F stroke:#6366f1,stroke-width:3px
    style G stroke:#8b5cf6,stroke-width:2px
    style J stroke:#ec4899,stroke-width:3px
    style K stroke:#6366f1,stroke-width:2px
    style M stroke:#ef4444,stroke-width:2px
    style N stroke:#10b981,stroke-width:2px

public class SemanticIndexingBackgroundService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        // Wait for app to be ready
        await Task.Delay(TimeSpan.FromSeconds(10), stoppingToken);

        // Initialize (downloads model if needed)
        await _semanticSearchService.InitializeAsync(stoppingToken);

        // Get all posts from main directory only
        var markdownFiles = Directory.GetFiles(
            _markdownConfig.MarkdownPath,
            "*.md",
            SearchOption.TopDirectoryOnly);  // NOT subdirectories

        foreach (var file in markdownFiles)
        {
            var needsIndexing = await _semanticSearchService.NeedsReindexingAsync(
                slug, language, contentHash, stoppingToken);

            if (needsIndexing)
                await _semanticSearchService.IndexPostAsync(document, stoppingToken);
        }
    }
}

Detta gör att:

Låg modell laddande - Downloads vid första användning, inte blockerar uppstart
Tillväxtindexering - Bara nya / utbyttade postituser re-indexerade med hjälp av innehållet hashM SK4
Bara huvudkatalogen - Skivor och översatta plikter förorenar inte indexet

Vad vi har byggt

Över delar 4a, 4bM SK3 och 5, har vi nu

✅ CPU-vänlig semantisk sök - Ingen GPU krävs
✅ Related posts discovery - Semantiskt liknande innehåll
✅ Naturspråkssökningar - Hitta genom meningen, inte bara nyckelord
✅ Hybridsökning - Det bästa av semantiskt + fulla
✅ Automatiskt indexering - Noll -tillkänna innehållsupdater
✅ Själva - Dina data stannar på din server

Framstående förbättringar:

Kategorie-Aktuala sökningar - Boostresultat från specifika kategorier
Multilinguella inbäddar - språk - specifika inbäddade modeller
OpenSearch integration - Lägg OpenSearch till den hybrida blandningense min OpenSearch artikel)

Slutsatsen

Detta kompletterar den praktiska implementeringen av RAG-style semantic search. kombinerat med Del 4a (foundation) och Del 4b (sökningsgui

Fortsätt lära sig

RAG-delen 1: källor och grunder - Teorin bakom inbäddar
RAG-delen 2: arkitektur och inre - djupt dyka in i RAG-system
RAG Part 3: Praktiska tillämpningar - Komplett RAG med LLM-integration
Del 4a: ONNX & Garantiimplementering - Foundation
Del 4b: Semantisk sökande i aktivitet - Typanledningen , hybridsökningen , och gränssnittet
Full-Textsökning med PostgreSQL - Fulltextsidan av hybridsökningen

resurser

Qdrant & Vektordatabaser

Self-Hosted Vector Databases with Qdrant - djupt dyka in i Qdrants koncept
Qdrant Hybrids sök - Qdrant

Hybridsökning

Reciproka Rang Fusion Papier - RRF-algoritmen

Att titta på filesystem

FileSystemWatcher klass - .NET-dokumentation
BackgroundService klass - Manade tjänster i ASP.NET Core

Komplett kod

Alla koder är tillgängliga på: github.com/scottgalM SK2mostlylucidweb

Mostlylucid.SemanticSearch/ - Kernsemantisk sökbibliotek
Mostlylucid/Blog/WatcherService/ - File watcher med semantisk indexering

RAG för implementerare: Hybridsökning och automatiserad indexering

Inleiding

Hybrida sökningar : Det bästa av båda världarna

Reciprokal rankfuusio (RRFM SK1

Implementering

Integrering

Automatisk indexering med File System Watcher

Hur det fungerar

Att integrera File Watcher

Att lösa rader

Hintergrundtjänster för inledande indexering

Vad vi har byggt

Slutsatsen

Fortsätt lära sig

resurser

Qdrant & Vektordatabaser

Hybridsökning

Att titta på filesystem

Komplett kod