2025-11-25Add T09:00

一. 导言 导言 导言 导言 导言 导言 一,导言 导言 导言 导言 导言 导言

部分RAG系列: 这是第4b部分 - 搜索功能和UI:

• 第1部分:RAG起源和基本要点 - 什么是嵌入,为什么它们重要
• 第2部分:RAG建筑和内部 - 启动、象征化、矢量数据库
• 第3部分:在实务中协助通知书 - 建立完整的ARAG系统
• 第4a部分:ONNX和Qdrant执行 - CPU友好语义搜索基金会
• 第4b部分:语义搜索行动 (本条) - 头型、混合搜索和UI组件
• 第5部分:混合搜索和自动插入 - 生产一体化模式
• 第6部分:图表 - 用于了解人身知识的知识图

内 第4部分a我们建立了基础: ONNX 嵌入和 Qdrant 矢量存储。 实际搜索 UI - 包括头型自动完成、混合搜索,结合语义+全文和高级过滤。

这篇文章涵盖实际搜索经验用户在这个博客上互动。

机头搜索经验

此站点顶端的搜索框提供即时搜索即时类型结果。 以下是它是如何工作的 :

sequenceDiagram
    participant U as User
    participant A as Alpine.js
    participant API as SearchApi
    participant H as HybridSearch
    participant S as Semantic Search
    participant P as PostgreSQL

    U->>A: Types "docker"
    A->>A: Debounce 300ms
    A->>API: GET /api/search/docker
    API->>H: HybridSearchAsync("docker")
    par Parallel Search
        H->>S: SearchAsync("docker", 20)
        H->>P: GetSearchResultForComplete("docker")
    end
    S-->>H: Semantic results (by meaning)
    P-->>H: Full-text results (by keywords)
    H->>H: Apply RRF scoring
    H-->>API: Combined results
    API-->>A: JSON results
    A->>U: Display dropdown

Alpine.js高山体头组件

搜索框使用 阿尔卑山 对于没有重 JavaScript 框架的活性 UI 。 以下是组件 :

export function typeahead() {
    return {
        query: '',
        results: [],
        highlightedIndex: -1, // Tracks keyboard navigation

        search() {
            // Minimum 2 characters to trigger search
            if (this.query.length < 2) {
                this.results = [];
                this.highlightedIndex = -1;
                return;
            }

            fetch(`/api/search/${encodeURIComponent(this.query)}`, {
                method: 'GET',
                headers: { 'Content-Type': 'application/json' }
            })
            .then(response => {
                if (response.ok) return response.json();
                return Promise.reject(response);
            })
            .then(data => {
                this.results = data;
                this.highlightedIndex = -1;
                // Process HTMX attributes in results
                this.$nextTick(() => {
                    htmx.process(document.getElementById('searchresults'));
                });
            })
            .catch((response) => {
                console.log("Error fetching search results");
            });
        },

        // Keyboard navigation
        moveDown() {
            if (this.highlightedIndex < this.results.length - 1) {
                this.highlightedIndex++;
            }
        },

        moveUp() {
            if (this.highlightedIndex > 0) {
                this.highlightedIndex--;
            }
        },

        selectHighlighted() {
            if (this.highlightedIndex >= 0 && this.highlightedIndex < this.results.length) {
                this.selectResult(this.highlightedIndex);
            }
        },

        selectResult(selectedIndex) {
            // Click the HTMX link to navigate
            let links = document.querySelectorAll('#searchresults a');
            links[selectedIndex].click();
            this.results = [];
            this.highlightedIndex = -1;
            this.query = '';
        }
    }
}

关键特征:

1. 跳跃输入:300米延迟防止了对服务器的敲锤
2. 最短长度:至少需要两个字符
3. 键盘导航:箭头键 + Enter 访问无障碍
4. HTMX 集成成果使用HTMX系统进行顺利导航

HTML 搜索盒 HTML

<div x-data="window.mostlylucid.typeahead()"
     class="relative"
     x-on:click.outside="results = []">

    <label class="input input-sm bg-white dark:bg-custom-dark-bg input-bordered flex items-center gap-2">
        <input
            type="text"
            x-model="query"
            x-on:input.debounce.300ms="search"
            x-on:keydown.down.prevent="moveDown"
            x-on:keydown.up.prevent="moveUp"
            x-on:keydown.enter.prevent="selectHighlighted"
            placeholder="Search..."
            class="border-0 grow input-sm text-black dark:text-white bg-transparent w-full"/>
        <i class="bx bx-search"></i>
    </label>

    <!-- Dropdown Results -->
    <ul x-show="results.length > 0"
        id="searchresults"
        class="absolute z-10 my-2 w-full bg-white dark:bg-custom-dark-bg border rounded-lg shadow-lg">
        <template x-for="(result, index) in results" :key="result.slug">
            <li :class="{'bg-blue-light dark:bg-blue-dark': index === highlightedIndex}"
                class="cursor-pointer text-sm p-2 m-2 hover:bg-blue-light dark:hover:bg-blue-dark">
                <a hx-boost="true"
                   hx-target="#contentcontainer"
                   hx-swap="innerHTML show:window:top"
                   :href="result.url"
                   x-text="result.title"></a>
            </li>
        </template>
    </ul>
</div>

为什么 x-on:click.outside? 点击下拉调之外关闭 - 自动完成的标准 UX 模式 。

搜索 API

缩略 /api/search/{query} 端点使型号具有能量。下面是控制器:

[ApiController]
[Route("api")]
public class SearchApi(
    BlogSearchService searchService,
    UmamiBackgroundSender umamiBackgroundSender,
    ISemanticSearchService semanticSearchService,
    SemanticSearchConfig semanticSearchConfig) : ControllerBase
{
    private const int RrfConstant = 60; // Reciprocal Rank Fusion constant

    [HttpGet]
    [Route("search/{query}")]
    [OutputCache(Duration = 3600, VaryByQueryKeys = new[] { "query" })]
    public async Task<Results<JsonHttpResult<List<SearchResults>>, BadRequest<string>>> Search(string query)
    {
        using var activity = Log.Logger.StartActivity("Search {query}", query);
        try
        {
            var host = Request.Host.Value;
            List<SearchResults> output;

            // Use hybrid search if semantic search is enabled
            if (semanticSearchConfig.Enabled)
            {
                output = await HybridSearchAsync(query, host);
            }
            else
            {
                // Fallback to full-text search only
                output = await FullTextSearchAsync(query, host);
            }

            // Track search event for analytics
            var encodedQuery = HttpUtility.UrlEncode(query);
            await umamiBackgroundSender.Track("searchEvent", new UmamiEventData { { "query", encodedQuery } });

            return TypedResults.Json(output);
        }
        catch (Exception e)
        {
            Log.Error(e, "Error in search");
            return TypedResults.BadRequest("Error in search");
        }
    }
}

重要设计决定:

1. 特征标志: semanticSearchConfig.Enabled 使您能够切换语义搜索
2. 输出缓存:1小时的缓存缓存减少用于常见查询的服务器负荷
3. 分析跟踪:每个搜索都被跟踪(帮助理解用户行为)
4. 优减退化:如果语义搜索失败, 返回 PostgreSQL

与对等相互搜索混合

真正的魔法是 混合混合搜索 我们用对等级融合(RRF)来公平合并它们。

为什么进行混合搜索?

不同的搜索方法有不同的长处:

搜索类型 强项 弱项 |------------|-----------|------------| | 语义 同义词,意思,概念 可能错过了确切的短语 | 全文本 * 确切的关键词,技术术语 * 无同义词理解 *

示例: 搜索“ 集装箱部署”

• 语义学发现:“Docker教义”、“Kubernetes 指南”(相关概念)
• 全文查找: 内有确切“集装箱部署”的员额
• 两者的结合都是最好的!

RRRF 算法

flowchart TB
    subgraph Semantic[Semantic Results]
        S1[Docker Containers - 0.92]
        S2[Kubernetes Basics - 0.87]
        S3[Container Security - 0.81]
    end

    subgraph FullText[Full-Text Results]
        F1[Container Security - rank 1]
        F2[Docker Containers - rank 2]
        F3[CI/CD Pipelines - rank 3]
    end

    subgraph RRF[RRF Scores]
        R1[Container Security = 0.0327]
        R2[Docker Containers = 0.0325]
        R3[Kubernetes Basics = 0.0161]
        R4[CI/CD Pipelines = 0.0159]
    end

    subgraph Final[Final Ranking]
        O1[Container Security]
        O2[Docker Containers]
        O3[Kubernetes Basics]
        O4[CI/CD Pipelines]
    end

    S1 --> R2
    S2 --> R3
    S3 --> R1
    F1 --> R1
    F2 --> R2
    F3 --> R4
    R1 --> O1
    R2 --> O2
    R3 --> O3
    R4 --> O4

公式 : score = Σ(1 / (k + rank))

此处:

• k = 60 (防止早期军衔占据主导地位)
• rank = 搜索方法结果中的位置(1个索引)

RRF为何工作:

• 产生的结果 两者兼 来源得分高
• 任何单一来源都无法主宰
• 不需要复杂的调音

执行 执行情况 执行

private async Task<List<SearchResults>> HybridSearchAsync(string query, string host)
{
    // Run both searches in parallel
    var fullTextTask = GetFullTextResultsAsync(query);
    var semanticTask = semanticSearchService.SearchAsync(query, limit: 20);

    await Task.WhenAll(fullTextTask, semanticTask);

    var fullTextResults = await fullTextTask;
    var semanticResults = await semanticTask;

    // Apply Reciprocal Rank Fusion to combine results
    var rrfScores = new Dictionary<string, (double Score, string Title, string Slug)>();

    // Score full-text results
    for (int i = 0; i < fullTextResults.Count; i++)
    {
        var (title, slug) = fullTextResults[i];
        var key = slug.ToLowerInvariant();
        var rrfScore = 1.0 / (RrfConstant + i + 1);

        if (rrfScores.TryGetValue(key, out var existing))
        {
            rrfScores[key] = (existing.Score + rrfScore, title, slug);
        }
        else
        {
            rrfScores[key] = (rrfScore, title, slug);
        }
    }

    // Score semantic results
    for (int i = 0; i < semanticResults.Count; i++)
    {
        var result = semanticResults[i];
        var key = result.Slug.ToLowerInvariant();
        var rrfScore = 1.0 / (RrfConstant + i + 1);

        if (rrfScores.TryGetValue(key, out var existing))
        {
            rrfScores[key] = (existing.Score + rrfScore, existing.Title, existing.Slug);
        }
        else
        {
            rrfScores[key] = (rrfScore, result.Title, result.Slug);
        }
    }

    // Sort by combined RRF score and return top results
    return rrfScores.Values
        .OrderByDescending(x => x.Score)
        .Take(15)
        .Select(x => new SearchResults(
            x.Title.Trim(),
            x.Slug,
            Url.ActionLink("Show", "Blog", new { x.Slug }, "https", host)))
        .ToList();
}

关键执行细节:

1. 平行执行:两个搜索同时运行(两个搜索同时运行)Task.WhenAll)
2. 不区分大小写: 空格与 ToLowerInvariant()
3. 累计累计计分:两个来源的同一个点数被添加到分数上
4. 最前15项成果足够打字头,不是压倒

全文本搜索后退

当语义搜索被禁用或失败时, 我们返回到 PostgreSQL 全文搜索 。

查询处理

全文搜索处理两个案件的方式不同:

private async Task<List<(string Title, string Slug)>> GetFullTextResultsAsync(string query)
{
    if (!query.Contains(' '))
        return await searchService.GetSearchResultForComplete(query);  // Wildcard
    else
        return await searchService.GetSearchResultForQuery(query);     // Web search
}

单单词 使用通配符前缀搜索 docker:* 多个单词 使用 PostgreSQL 的网络搜索语法

PostgresSQL 查询

// Single word with wildcard
private IQueryable<BlogPostEntity> QueryForWildCard(string query)
{
    return context.BlogPosts
        .Include(x => x.Categories)
        .Include(x => x.LanguageEntity)
        .AsNoTracking()
        .Where(x =>
            !x.IsHidden
            && (x.ScheduledPublishDate == null || x.ScheduledPublishDate <= now)
            && (x.SearchVector.Matches(EF.Functions.ToTsQuery("english", query + ":*"))
                || x.Categories.Any(c =>
                    EF.Functions.ToTsVector("english", c.Name)
                        .Matches(EF.Functions.ToTsQuery("english", query + ":*"))))
            && x.LanguageEntity.Name == "en")
        .OrderByDescending(x =>
            x.SearchVector.Rank(EF.Functions.ToTsQuery("english", query + ":*")));
}

// Multiple words with web search
private IQueryable<BlogPostEntity> QueryForSpaces(string processedQuery)
{
    return context.BlogPosts
        .Where(x =>
            x.SearchVector.Matches(EF.Functions.WebSearchToTsQuery("english", processedQuery))
            || x.Categories.Any(c =>
                EF.Functions.ToTsVector("english", c.Name)
                    .Matches(EF.Functions.WebSearchToTsQuery("english", processedQuery))))
        .OrderByDescending(x =>
            x.SearchVector.Rank(EF.Functions.WebSearchToTsQuery("english", processedQuery)));
}

为什么 WebSearchToTsQuery? 它处理像谷歌这样的自然语言问题:

• "docker containers" 搜索这两个词
• docker OR kubernetes 布尔 OR
• docker -compose 排除了“ 溶解” 。

更多关于PostgreSQL全文搜索的更多信息,见 使用 Postgres 搜索完整文本.

完整搜索页面

除了字头外, 还有一个带有高级过滤功能的完整搜索结果页面 :

flowchart LR
    subgraph SearchPage[Search Page]
        A[Query Input] --> B{Filters}
        B --> C[Language Filter]
        B --> D[Date Range Filter]
        C --> E[Search Results]
        D --> E
        E --> F[Paginated List]
    end

    style A stroke:#10b981,stroke-width:2px
    style B stroke:#6366f1,stroke-width:2px
    style E stroke:#ec4899,stroke-width:2px
    style F stroke:#8b5cf6,stroke-width:2px

搜索主计长

[Route("search")]
public class SearchController(
    BaseControllerService baseControllerService,
    BlogSearchService searchService,
    ISemanticSearchService semanticSearchService,
    ILogger<SearchController> logger)
    : BaseController(baseControllerService, logger)
{
    [HttpGet]
    [Route("")]
    [OutputCache(Duration = 3600, VaryByQueryKeys = new[] { "query", "page", "pageSize", "language", "dateRange", "startDate", "endDate" })]
    public async Task<IActionResult> Search(
        string? query,
        int page = 1,
        int pageSize = 10,
        string? language = null,
        DateRangeOption dateRange = DateRangeOption.AllTime,
        DateTime? startDate = null,
        DateTime? endDate = null,
        [FromHeader] bool pagerequest = false)
    {
        // Calculate date range based on option
        var (calculatedStartDate, calculatedEndDate) = CalculateDateRange(dateRange, startDate, endDate);

        // Get available languages for the filter dropdown
        var availableLanguages = await searchService.GetAvailableLanguagesAsync();

        if (string.IsNullOrEmpty(query?.Trim()))
        {
            var emptyModel = new SearchResultsModel { /* ... */ };
            if (Request.IsHtmx()) return PartialView("SearchResults", emptyModel);
            return View("SearchResults", emptyModel);
        }

        var searchResults = await searchService.HybridSearchWithPagingAsync(
            query,
            language,
            calculatedStartDate,
            calculatedEndDate,
            page,
            pageSize);

        // Build response model...
        if (pagerequest && Request.IsHtmx())
            return PartialView("_SearchResultsPartial", searchModel.SearchResults);
        if (Request.IsHtmx())
            return PartialView("SearchResults", searchModel);
        return View("SearchResults", searchModel);
    }
}

日期范围选项

public enum DateRangeOption
{
    AllTime,
    LastWeek,
    LastMonth,
    LastYear,
    Custom
}

private static (DateTime? StartDate, DateTime? EndDate) CalculateDateRange(
    DateRangeOption dateRange, DateTime? startDate, DateTime? endDate)
{
    var now = DateTime.UtcNow;
    return dateRange switch
    {
        DateRangeOption.LastWeek => (now.AddDays(-7), now),
        DateRangeOption.LastMonth => (now.AddMonths(-1), now),
        DateRangeOption.LastYear => (now.AddYears(-1), now),
        DateRangeOption.Custom => (startDate, endDate),
        _ => (null, null) // AllTime - no date filter
    };
}

相关员额,含懒惰加载

每个博客文章都显示在可折叠的面板上,

<!-- In blog post view -->
<div class="print:hidden"
     hx-get="/search/related/@Model.Slug/@Model.Language"
     hx-trigger="load delay:500ms"
     hx-swap="innerHTML">
    <!-- Loading placeholder -->
    <div class="mt-8 mb-8 text-center opacity-50">
        <span class="loading loading-spinner loading-md"></span>
        <p class="text-sm mt-2">Finding related posts...</p>
    </div>
</div>

为什么迟到500米? 主要内容先加载,然后在背景中加载相关文章。 用户会立即看到内容 。

相关员额

[HttpGet]
[Route("related/{slug}/{language}")]
[OutputCache(Duration = 7200, VaryByRouteValueNames = new[] {"slug", "language"})]
public async Task<IActionResult> RelatedPosts(string slug, string language, int limit = 5)
{
    var results = await semanticSearchService.GetRelatedPostsAsync(slug, language, limit);

    if (Request.IsHtmx())
    {
        return PartialView("_RelatedPosts", results);
    }

    return Json(results);
}

2小时缓存相关职位不会经常改变,

相关员额构成部分

DaisimiUI 的崩溃部件, 有辐射进展显示相似得分 :

@model List<SearchResult>

@if (Model != null && Model.Any())
{
    <div class="mt-8 mb-8">
        <div class="collapse collapse-arrow bg-base-200">
            <input type="checkbox" class="peer" />
            <div class="collapse-title text-xl font-medium">
                <i class='bx bx-brain text-2xl mr-2'></i>
                Related Posts
                <span class="badge badge-secondary badge-sm ml-2">@Model.Count</span>
            </div>
            <div class="collapse-content">
                <div class="divider mt-0"></div>
                <div class="space-y-2">
                    @foreach (var post in Model)
                    {
                        <div class="card bg-base-100 shadow-sm hover:shadow-md transition-shadow">
                            <div class="card-body p-4">
                                <div class="flex items-start justify-between">
                                    <div class="flex-1">
                                        <a hx-boost="true"
                                           hx-target="#contentcontainer"
                                           asp-action="Show"
                                           asp-controller="Blog"
                                           asp-route-slug="@post.Slug"
                                           asp-route-language="@post.Language"
                                           class="card-title text-base hover:text-secondary">
                                            @post.Title
                                        </a>

                                        @if (post.Categories?.Any() == true)
                                        {
                                            <div class="flex flex-wrap gap-1 mt-2">
                                                @foreach (var category in post.Categories.Take(3))
                                                {
                                                    <span class="badge badge-outline badge-sm">@category</span>
                                                }
                                            </div>
                                        }

                                        <div class="flex items-center gap-3 mt-2 text-sm opacity-70">
                                            <span>
                                                <i class='bx bx-calendar'></i>
                                                @post.PublishedDate.ToString("MMM dd, yyyy")
                                            </span>
                                            <span>
                                                <i class='bx bx-planet'></i>
                                                @post.Language.ToUpper()
                                            </span>
                                        </div>
                                    </div>

                                    <!-- Similarity Score -->
                                    <div class="flex flex-col items-end ml-4">
                                        <div class="radial-progress text-primary text-xs"
                                             style="--value:@(post.Score * 100); --size:3rem; --thickness:3px;"
                                             role="progressbar">
                                            @((post.Score * 100).ToString("F0"))%
                                        </div>
                                        <span class="text-xs opacity-60 mt-1">similarity</span>
                                    </div>
                                </div>
                            </div>
                        </div>
                    }
                </div>
            </div>
        </div>
    </div>
}

光线进步 显示相似的百分比(0-100%),帮助用户了解每个员额的关联性。

API 参考 API

类型标题搜索

GET /api/search/{query}

|-----------|------|-------------| | query 字符串 (path) 搜尋名 (min 2 字符)

答复: List<SearchResults>

[
  {
    "title": "Docker Containers Explained",
    "slug": "docker-containers",
    "url": "https://example.com/blog/docker-containers"
  }
]

缓存 : 1小时,因查询而异

语义搜索

GET /search/semantic?query={query}&limit={limit}

• 参数 * 类型 * 默认 * 描述 * |-----------|------|---------|-------------| | query 字符串 * 需要 * 搜索术语 * * * | limit {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}什么? {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}什么? {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}什么? {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}什么? {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}什么?

答复: List<SearchResult> 类似得分

相关员额

GET /search/related/{slug}/{language}?limit={limit}

• 参数 * 类型 * 默认 * 描述 * |-----------|------|---------|-------------| | slug | language * 字符串 要求 * 语言代码 (en, es, etc.) * * * 语言代码 (en, es, etc.) * | limit @ int @ 5 @ Max 相关职位 @

答复: List<SearchResult> 按相似性分类

缓存 : 2小时,视子弹和语言不同而不同

带过滤器的完整搜索

GET /search?query={query}&page={page}&pageSize={pageSize}&language={language}&dateRange={dateRange}&startDate={startDate}&endDate={endDate}

• 参数 * 类型 * 默认 * 描述 * |-----------|------|---------|-------------| | query 字符串 * 需要 * 搜索术语 * * * | page 英文第1页 第1页 第2页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 第1页 | pageSize 10 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 每页结果 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | language | dateRange 全时 最后一年 最后一年 最后一年 最后一年 惯例 | startDate 开始日期(日期Range=Custom) | endDate 结束日期(日期为Range=Custom)

绩效提示

缓结战略

// Typeahead - 1 hour (queries are repeated often)
[OutputCache(Duration = 3600, VaryByQueryKeys = new[] { "query" })]

// Related posts - 2 hours (rarely change)
[OutputCache(Duration = 7200, VaryByRouteValueNames = new[] {"slug", "language"})]

// Full search - 1 hour (many filter combinations)
[OutputCache(Duration = 3600, VaryByQueryKeys = new[] { "query", "page", "pageSize", "language", "dateRange", "startDate", "endDate" })]

击败

总是去掉用户输入, 以防止 API 调用过量 :

x-on:input.debounce.300ms="search"

300米是一个良好的平衡 -- -- 足够快,足以感觉反应迅速,足够慢,可减少服务器负荷。

懒惰装入

使用 HTMX 的 load delay: 非关键内容的触发 :

hx-trigger="load delay:500ms"

这确保了主要内容在二次内容载荷之前是可见的。

下一个是什么

本条涵盖: 搜索经验 - 用户如何与语义搜索互动。 生产量部署部署 包括自动索引编制和背景服务,继续:

第5部分:混合搜索和自动插入 - 生产一体化模式:

• FileSystem 实时索引化文件系统监视器
• 启动指数化的背景服务
• 用于增量更新的内容散列检测

资源资源资源 资源资源资源 资源资源 资源资源

相关条款

• 第4a部分:ONNX和Qdrant执行 - 本条的基础是:
• 使用 PostgreSQL 搜索完整文本 - PostgreSQL全文搜索设置
• 完整文本搜索 - 类型标题 - 最初实施期

使用的技术

• 阿尔卑山 - 轻量度活性 JavaScript
• HTMX - HTML超线
• DisacyUI 调音界面 - 尾风CSS 组件库
• 相互排名融合 RRF算法文件

完整代码

所有代码可用于: com/scottgal/ mostlylylucidweb 缩略图/ com/ scottgal/ mostlylylucidweb 缩略图/ 缩略图/ 缩略图/ 缩略图/ 缩略图/ 缩略图/ 缩略图/ 缩略图/ 缩略图/ 缩略图/ 缩略图/ 缩略图/ 缩略图/ 缩略图/ 缩略图/ 缩略图/ 缩略图

• Mostlylucid/API/SearchApi.cs - 原型API
• Mostlylucid/Controllers/SearchController.cs - 完整搜索页面
• Mostlylucid.Services/Blog/BlogSearchService.cs - 混合搜索逻辑
• Mostlylucid/src/js/typeahead.js - 阿尔卑山主体部分