.NET - Elasticsearch Labs

如何使用用于微软语义内核（Microsoft Semantic Kernel）的Elasticsearch矢量存储连接器进行人工智能代理开发

Florian Bernd,Srikanth Manvi — Fri, 06 Dec 2024 00:00:00 GMT

我们与微软语义内核（ Microsoft Semantic Kernel ）团队合作，宣布面向微软语义内核（.NET）用户推出 Semantic Kernel Elasticsearch矢量存储连接器（Vector Store Connector ）。语义内核（Semantic Kernel）简化了企业级人工智能代理的构建过程，包括利用来自矢量存储库（Vector Store）的更多相关数据驱动响应来增强大型语言模型（LLM）的能力。语义内核（Semantic Kernel）为与Elasticsearch等矢量存储进行交互提供了一个无缝的抽象层，可提供创建、列出和删除记录集合以及上传、检索和删除单条记录等基本功能。

开箱即用的Semantic Kernel Elasticsearch向量存储连接器（Vector Store Connector）支持Semantic Kernel向量存储抽象，这使得开发人员在构建人工智能代理时能够非常容易地将Elasticsearch作为向量存储插件。

Elasticsearch 在开源社区拥有坚实的基础，最近采用了AGPL 许可证。这些工具与开源的微软语义内核（Microsoft Semantic Kernel）相结合，可提供强大的企业级解决方案。您可以通过运行此命令curl -fsSL https://elastic.co/start-local | sh ，在几分钟内启动 Elasticsearch（详情请参考start-local），然后在生产人工智能代理的同时，迁移到云托管或自托管版本。

在本篇博客中，我们将探讨在使用Semantic Kernel（语义内核）时，如何使用Semantic Kernel Elasticsearch向量存储连接器。该连接器的 Python 版本将在未来推出。

高级应用场景：利用 Semantic Kernel& Elasticsearch 构建 RAG 应用程序

下面我们将举例说明。在高层次上，我们正在构建一个 RAG（检索增强生成）应用程序，它将用户的问题作为输入，并返回一个答案。我们将使用 Azure OpenAI （也可使用本地 LLM ）作为 LLM，Elasticsearch 作为向量存储，Semantic Kernel (.net) 作为将所有组件连接在一起的框架。

如果您不熟悉 RAG 架构，可以通过以下文章快速了解： https://www.elastic.co/search-labs/blog/retrieval-augmented-generation-rag。

答案由 LLM 生成，LLM 从 Elasticsearch 向量存储中获取与问题相关的上下文。答复还包括法律硕士用作背景的资料来源。

RAG 示例

在这个具体例子中，我们创建了一个应用程序，允许用户就内部酒店数据库中存储的酒店提出问题。例如，用户可以根据不同标准搜索特定酒店，或要求提供酒店列表。

在示例数据库中，我们生成了一个包含 100 个条目的酒店列表。为了让您尽可能轻松地试用连接器演示，我们特意设置了较小的样本量。在实际应用中，Elasticsearch 连接器将显示出其优于其他选项（如 "InMemory "向量存储实现）的优势，尤其是在处理超大数据量时。

完整的演示应用程序可在 Elasticsearch 向量存储连接器存储库中找到。

让我们先将所需的 NuGet 软件包和指令添加到项目中：

dotnet add package "Elastic.Clients.Elasticsearch" -v 8.16.2 dotnet add package "Elastic.SemanticKernel.Connectors.Elasticsearch" -v 0.1.2 dotnet add package "Microsoft.Extensions.Hosting" -v 9.0.0 dotnet add package "Microsoft.SemanticKernel.Connectors.AzureOpenAI" -v 1.30.0 dotnet add package "Microsoft.SemanticKernel.PromptTemplates.Handlebars" -v 1.30.0using System; using System.IO; using System.Linq; using System.Threading.Tasks; using Elastic.Clients.Elasticsearch; using Elastic.Transport; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; using Microsoft.Extensions.VectorData; using Microsoft.SemanticKernel; using Microsoft.SemanticKernel.Data; using Microsoft.SemanticKernel.Embeddings; using Microsoft.SemanticKernel.PromptTemplates.Handlebars;

现在，我们可以创建我们的数据模型，并为其提供语义内核（Semantic Kernel）的特定属性，以定义存储模型模式和文本搜索的一些提示：

///

/// Data model for storing a "hotel" with a name, a description, a description embedding and an optional reference link. ///

public sealed record Hotel { [VectorStoreRecordKey] public required string HotelId { get; set; } [TextSearchResultName] [VectorStoreRecordData(IsFilterable = true)] public required string HotelName { get; set; } [TextSearchResultValue] [VectorStoreRecordData(IsFullTextSearchable = true)] public required string Description { get; set; } [VectorStoreRecordVector(Dimensions: 1536, DistanceFunction.CosineSimilarity, IndexKind.Hnsw)] public ReadOnlyMemory? DescriptionEmbedding { get; set; } [TextSearchResultLink] [VectorStoreRecordData] public string? ReferenceLink { get; set; } }

存储模型模式属性（`VectorStore*`）与 Elasticsearch 向量存储连接器的实际使用最为相关，即

VectorStoreRecordKey 来标记记录类上的一个属性，作为记录存储在向量存储中的键。
VectorStoreRecordData 将记录类的一个属性标记为 "数据"。
VectorStoreRecordVector 将记录类的一个属性标记为矢量。

所有这些属性都接受各种可选参数，可用于进一步定制存储模型。以VectorStoreRecordKey 为例，可以指定不同的距离函数或不同的索引类型。

文本搜索属性 (TextSearch*) 在本示例的最后一步中非常重要。我们稍后再谈。

下一步，我们将初始化语义内核引擎，并获取核心服务的引用。在实际应用中，应使用依赖注入而不是直接访问服务集合。同样的道理也适用于硬编码的配置和秘密，它们应该使用配置提供程序来读取：

var builder = Host.CreateApplicationBuilder(args); // Register AI services. var kernelBuilder = builder.Services.AddKernel(); kernelBuilder.AddAzureOpenAIChatCompletion("gpt-4o", "https://my-service.openai.azure.com", "my_token"); kernelBuilder.AddAzureOpenAITextEmbeddingGeneration("ada-002", "https://my-service.openai.azure.com", "my_token"); // Register text search service. kernelBuilder.AddVectorStoreTextSearch(); // Register Elasticsearch vector store. var elasticsearchClientSettings = new ElasticsearchClientSettings(new Uri("https://my-elasticsearch-instance.cloud")) .Authentication(new BasicAuthentication("elastic", "my_password")); kernelBuilder.AddElasticsearchVectorStoreRecordCollection("skhotels", elasticsearchClientSettings); // Build the host. using var host = builder.Build(); // For demo purposes, we access the services directly without using a DI context. var kernel = host.Services.GetService()!; var embeddings = host.Services.GetService()!; var vectorStoreCollection = host.Services.GetService>()!; // Register search plugin. var textSearch = host.Services.GetService>()!; kernel.Plugins.Add(textSearch.CreateWithGetTextSearchResults("SearchPlugin"));

现在可以使用vectorStoreCollection 服务创建数据集，并摄取一些演示记录：

await vectorStoreCollection.CreateCollectionIfNotExistsAsync(); // CSV format: ID;Hotel Name;Description;Reference Link var hotels = (await File.ReadAllLinesAsync("hotels.csv")) .Select(x => x.Split(';')); foreach (var chunk in hotels.Chunk(25)) { var descriptionEmbeddings = await embeddings.GenerateEmbeddingsAsync(chunk.Select(x => x[2]).ToArray()); for (var i = 0; i < chunk.Length; ++i) { var hotel = chunk[i]; await vectorStoreCollection.UpsertAsync(new Hotel { HotelId = hotel[0], HotelName = hotel[1], Description = hotel[2], DescriptionEmbedding = descriptionEmbeddings[i], ReferenceLink = hotel[3] }); } }

由此可见，语义内核（Semantic Kernel）是如何将向量存储的使用及其复杂性简化为几个简单的方法调用的。

在 Elasticsearch 中创建一个新索引，并创建所有必要的属性映射。然后，我们的数据集会完全透明地映射到存储模型中，并最终存储到索引中。下面是映射在 Elasticsearch 中的显示方式。

{ "mappings": { "properties": { "descriptionEmbedding": { "dims": 1536, "index": true, "index_options": { "type": "hnsw" }, "similarity": "cosine", "type": "dense_vector" }, "hotelName": { "type": "keyword" }, "description": { "type": "text" } } } }

embeddings.GenerateEmbeddingsAsync() 会透明地调用已配置的 Azure AI 嵌入生成服务。

在这个演示的最后一个步骤中，我们还可以看到更多的神奇之处。

当用户就数据提问时，只需调用InvokePromptAsync ，就能执行以下所有操作：

1.为用户的问题生成嵌入代码

2.在矢量存储器中搜索相关条目

3.将查询结果插入提示模板

4.最终提示形式的实际查询将发送到人工智能聊天完成服务

// Invoke the LLM with a template that uses the search plugin to // 1. get related information to the user query from the vector store // 2. add the information to the LLM prompt. var response = await kernel.InvokePromptAsync( promptTemplate: """ Please use this information to answer the question: {{#with (SearchPlugin-GetTextSearchResults question)}} {{#each this}} Name: {{Name}} Value: {{Value}} Source: {{Link}} ----------------- {{/each}} {{/with}} Include the source of relevant information in the response. Question: {{question}} """, arguments: new KernelArguments { { "question", "Please show me all hotels that have a rooftop bar." }, }, templateFormat: "handlebars", promptTemplateFactory: new HandlebarsPromptTemplateFactory());

还记得我们之前在数据模型上定义的TextSearch* 属性吗？有了这些属性，我们就能在提示模板中使用相应的占位符，这些占位符会根据向量存储中的条目信息自动填充。

对于我们的问题"，请告诉我所有拥有屋顶酒吧的酒店。" ，最终答复如下：

Console.WriteLine(response.ToString()); // > The hotel that has a rooftop bar is Skyline Suites. You can find more information about this hotel [here](https://example.com/yz567).

正确答案是指 hotels.csv 中的以下条目

9; Skyline Suites; Offering panoramic city views from every suite, this hotel is perfect for those who love the urban landscape. Enjoy luxurious amenities, a rooftop bar, and close proximity to attractions. Luxurious and contemporary.; https://example.com/yz567

这个例子很好地说明了微软语义内核的使用是如何通过其深思熟虑的抽象功能大大降低复杂性，并实现高度灵活性的。例如，只需修改一行代码，就可以更换向量存储或所使用的人工智能服务，而无需重构代码的任何其他部分。

同时，该框架还提供了大量高级功能，如 "InvokePrompt "函数或模板或搜索插件系统。

完整的演示应用程序可在 Elasticsearch 向量存储连接器存储库中找到。

Elasticsearch 还能做什么

Elasticsearch& Semantic Kernel（语义内核）：下一步是什么？

我们展示了在.NET中构建GenAI应用时，如何将Elasticsearch向量存储轻松插入Semantic Kernel。敬请期待下一步的 Python 集成。
由于Semantic Kernel（语义内核）为混合搜索等高级搜索功能建立了抽象，Elasticsearch连接将使.NET开发人员能够在使用Semantic Kernel（语义内核）的同时轻松实现这些功能。

使用 Blazor 和 Elasticsearch 构建搜索应用

Gustavo Llermaly — Wed, 09 Oct 2024 00:00:00 GMT

在本文中，您将学习如何利用 C# 技能使用 Blazor 和 Elasticsearch 构建搜索应用程序。我们将使用Elasticsearch .NET客户端运行全文、语义和混合搜索查询。

注意如果您熟悉旧版本的 Elasticsearch C# 客户端NEST，请阅读这篇关于 NEST 客户端弃用和新功能的博文。NEST 是上一代的 .NET 客户端，后来被 Elastic.Clients.Elasticsearch package

什么是 Blazor？

Blazor是微软开发的基于 HTML、CSS 和 C# 的开放源代码网络框架，允许开发人员构建可在客户端或服务器上运行的网络应用程序。Blazor 还允许您制作可重复使用的组件，以更快地构建应用程序；它使开发人员能够在同一个文件中构建 HTML 视图和 C# 操作，这有助于保持代码的可读性和简洁性。此外，有了Blazor Hybrid，您还可以通过.NET代码构建本地移动应用程序，访问本地平台功能。

Blazor 的部分功能使其成为一个非常适合工作的框架：

服务器端和客户端渲染选项
可重复使用的用户界面组件
利用 SignalR 实时更新
内置状态管理
内置路由系统
强大的类型和编译时检查

为什么选择 Blazor？

与其他框架和库相比，Blazor 具有以下优势：它允许开发人员在客户端和服务器代码中使用 C#，提供强大的类型和编译时检查功能，从而提高了可靠性。它与 .NET 生态系统无缝集成，实现了 .NET 库和工具的重用，并提供强大的调试支持。

什么是 ESRE？

Elasticsearch Relevance Engine™ (ESRE)是一套在强大的 Elasticsearch 搜索引擎基础上使用机器学习和人工智能构建搜索应用程序的工具。

要了解有关 ESRE 的更多信息，请点击此处阅读我们的博文。

配置 ELSER

为了充分利用 Elastic 的ESRE功能，我们将使用ELSER作为模型提供者。

请注意，要使用 Elasticsearch 的 ELSER 模型，您必须拥有白金级或企业级许可证，并至少拥有一个 4GB 大小的专用机器学习 (ML) 节点。 点击此处了解更多信息。

首先创建推理端点：

PUT _inference/sparse_embedding/my-elser-model { "service": "elser", "service_settings": { "num_allocations": 1, "num_threads": 1 } }

如果您是第一次使用 ELSER，在后台加载模型时可能会遇到 502 Bad Gateway 错误。您可以在 Kibana 的Machine Learning > Trained Models 中查看模型的状态。部署完成后，就可以进行下一步。

索引数据

您可以在这里下载数据集，然后使用 Kibana 导入数据。为此，请访问主页并点击"Upload data" 。然后，上传文件并点击Import 。最后，进入Advanced 标签，粘贴以下映射：

{ "properties":{ "authors":{ "type":"keyword" }, "categories":{ "type":"keyword" }, "longDescription":{ "type":"semantic_text", "inference_id":"my-elser-model", "model_settings":{ "task_type":"sparse_embedding" } }, "pageCount":{ "type":"integer" }, "publishedDate":{ "type":"date" }, "shortDescription":{ "type":"text" }, "status":{ "type":"keyword" }, "thumbnailUrl":{ "type":"keyword" }, "title":{ "type":"text" } } }

我们将创建一个能够运行语义和全文查询的索引。语义文本字段类型将负责数据分块和嵌入。请注意，我们是将索引longDescription 为semantic_text ，如果要将一个字段索引为semantic_text 和 text` ，可以使用 copy_to 。

使用 Blazor& Elasticsearch 构建应用程序

API 密钥

我们需要做的第一件事是创建一个 API 密钥，以验证对 Elasticsearch 的请求。API 密钥应为只读，只允许查询books-blazor 索引。

POST /_security/api_key { "name": "books-blazor-key", "role_descriptors": { "books-blazor-reader": { "indices": [ { "names": ["books-blazor"], "privileges": ["read"] } ] } } }

你会看到类似这样的内容：

{ "id": "XXXXXXXXXXXXXXXXXXXXXXXX", "name": "books-blazor-key", "api_key": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "encoded": "XXXXXXXXXXXXXXXXXXXXXXXX==" }

保存encoded 响应字段的值，以备不时之需。如果您在Elastic Cloud 上运行，还需要您的 Cloud ID。(您可以在此处找到）。

创建 Blazor 项目

首先安装 Blazor，并按照官方说明创建一个示例项目。

创建项目后，文件夹结构和文件应如下所示：

模板应用程序包括Bootstrap v5.1.0用于造型。

安装Elasticsearch .NET客户端，完成项目设置：

dotnet add package Elastic.Clients.Elasticsearch

完成这一步后，您的页面应该是这样的：

文件夹结构

现在，我们将按如下方式整理文件夹：

文件解释：

Components/Pages/Search.razor：包含搜索栏、搜索结果和过滤器的主页面。
Components/Pages/Search.razor.css：页面样式。
Components/Elasticsearch/SearchBar.razor：搜索栏组件。
Components/Elasticsearch/Results.razor：结果组件。
Components/Elasticsearch/Facet.razor: 过滤器组件。
Components/Svg/GlassIcon.razor: 搜索图标。
Components/_Imports.razor：这将导入所有组件。
Models/Book.cs：这将存储图书字段模式。
Models/Response.cs：这将存储响应模式，包括搜索结果、面和总点击数。
Services/ElasticsearchService.cs：Elasticsearch 服务。它将处理与 Elasticsearch 的连接和查询。

初始配置

我们先来清理一下。

删除文件：

Components/Pages/Counter.razor
Components/Pages/Weather.razor
Components/Pages/Home.razor
Components/Layout/NavMenu.razor
Components/Layout/NavMenu.razor.css

检查/Components/_Imports.razor 文件。您应该有以下进口：

@using System.Net.Http @using System.Net.Http.Json @using Microsoft.AspNetCore.Components.Forms @using Microsoft.AspNetCore.Components.Routing @using Microsoft.AspNetCore.Components.Web @using static Microsoft.AspNetCore.Components.Web.RenderMode @using Microsoft.AspNetCore.Components.Web.Virtualization @using Microsoft.JSInterop @using BlazorApp @using BlazorApp.Components

将 Elastic 集成到项目中

现在，让我们导入 Elasticsearch 组件：

我们将从/Components/Layout/MainLayout.razor 文件中删除默认侧边栏，以便为应用程序提供更多空间：

@inherits LayoutComponentBase

@Body

An unhandled error has occurred. Reload 🗙

现在让我们输入用户机密的 Elasticsearch 凭据：

dotnet user-secrets init dotnet user-secrets set ElasticsearchCloudId "your Cloud ID" dotnet user-secrets set ElasticsearchApiKey "your API Key"

使用这种方法，.Net 8 可将敏感数据存储在项目文件夹之外的单独位置，并可通过IConfiguration 界面进行访问。任何使用相同用户秘密的 .Net 项目都可以使用这些变量。

然后，让我们修改Program.cs 文件以读取机密并挂载 Elasticsearch 客户端：

首先，导入必要的库：

using BlazorApp.Services; using Elastic.Clients.Elasticsearch; using Elastic.Transport;

BlazorApp.Services：包含 Elasticsearch 服务。
Elastic.Clients.Elasticsearch：导入 Elasticsearch 客户端 .Net 8 库。
Elastic.Transport：导入 Elasticsearch 传输库，它允许我们使用 ApiKey 类来验证请求。

其次，在var app = builder.Build() 行之前插入以下代码：

// Initialize the Elasticsearch client. builder.Services.AddScoped(sp => { // Getting access to the configuration service to read the Elasticsearch credentials. var configuration = sp.GetRequiredService(); var cloudId = configuration["ElasticsearchCloudId"]; var apiKey = configuration["ElasticsearchApiKey"]; if (string.IsNullOrEmpty(cloudId) || string.IsNullOrEmpty(apiKey)) { throw new InvalidOperationException( "Elasticsearch credentials are missing in configuration." ); } var settings = new ElasticsearchClientSettings(cloudId, new ApiKey(apiKey)).EnableDebugMode(); return new ElasticsearchClient(settings); });

这段代码将从用户机密中读取 Elasticsearch 凭据，并创建一个 Elasticsearch 客户端实例。

在初始化 ElasticSearch 客户端后，添加以下一行以注册 Elasticsearch 服务：

builder.Services.AddScoped();

下一步将在/Services/ElasticsearchService.cs 文件中建立搜索逻辑：

首先，导入必要的库和模型：

using BlazorApp.Models; using Elastic.Clients.Elasticsearch; using Elastic.Clients.Elasticsearch.QueryDsl;

其次，添加类ElasticsearchService 、构造函数和变量：

namespace BlazorApp.Services { public class ElasticsearchService { private readonly ElasticsearchClient _client; // The logger is used to log information, warnings and errors about the Elasticsearch service and requests. private readonly ILogger _logger; public ElasticsearchService( ElasticsearchClient client, ILogger logger ) { _client = client ?? throw new ArgumentNullException(nameof(client)); _logger = logger; } } }

配置搜索

现在，让我们构建搜索逻辑：

private static Action> BuildHybridQuery( string searchTerm, Dictionary> selectedFacets ) { var filters = BuildFilters(selectedFacets); return retrievers => retrievers.Rrf(rrf => rrf.RankWindowSize(50) .RankConstant(20) .Retrievers( retrievers => retrievers.Standard(std => std.Query(q => q.Bool(b => b.Must(m => m.MultiMatch(mm => mm.Query(searchTerm) .Fields( new[] { "title", "shortDescription", } ) ) ) .Filter(filters.ToArray()) ) ) ), retrievers => retrievers.Standard(std => std.Query(q => q.Bool(b => b.Must(m => m.Semantic(sem => sem.Field("longDescription") .Query(searchTerm) ) ) .Filter(filters.ToArray()) ) ) ) ) ); } public static List>> BuildFilters( Dictionary> selectedFacets ) { var filters = new List>>(); if (selectedFacets != null) { foreach (var facet in selectedFacets) { foreach (var value in facet.Value) { var field = facet.Key.ToLower(); if (!string.IsNullOrEmpty(field)) { filters.Add(m => m.Term(t => t.Field(new Field(field)).Value(value))); } } } } return filters; }

BuildFilters 将使用用户选择的面为搜索查询建立过滤器。
BuildHybridQuery 将建立一个结合全文和语义搜索的混合搜索查询。

接下来，添加搜索方法：

public async Task SearchBooksAsync( string searchTerm, Dictionary> selectedFacets ) { try { _logger.LogInformation($"Performing search for: {searchTerm}"); // Retrieve the hybrid query with filters applied. var retrieverQuery = BuildHybridQuery(searchTerm, selectedFacets); var response = await _client.SearchAsync(s => s.Index("elastic-blazor-books") .Retriever(retrieverQuery) .Aggregations(aggs => aggs.Add("Authors", agg => agg.Terms(t => t.Field(p => p.Authors))) .Add( "Categories", agg => agg.Terms(t => t.Field(p => p.Categories)) ) .Add("Status", agg => agg.Terms(t => t.Field(p => p.Status))) ) ); if (response.IsValidResponse) { _logger.LogInformation($"Found {response.Documents.Count} documents"); var hits = response.Total; var facets = response.Aggregations != null ? FormatFacets(response.Aggregations) : new Dictionary>(); var elasticResponse = new ElasticResponse { TotalHits = hits, Documents = response.Documents.ToList(), Facets = facets, }; return elasticResponse; } else { _logger.LogWarning($"Invalid response: {response.DebugInformation}"); return new ElasticResponse(); } } catch (Exception ex) { _logger.LogError(ex, "Error performing search"); return new ElasticResponse(); } } public static Dictionary> FormatFacets( Elastic.Clients.Elasticsearch.Aggregations.AggregateDictionary aggregations ) { var facets = new Dictionary>(); foreach (var aggregation in aggregations) { if ( aggregation.Value is Elastic.Clients.Elasticsearch.Aggregations.StringTermsAggregate termsAggregate ) { var facetName = aggregation.Key; var facetDictionary = ConvertFacetDictionary( termsAggregate.Buckets.ToDictionary(b => b.Key, b => b.DocCount) ); facets[facetName] = facetDictionary; } } return facets; } private static Dictionary ConvertFacetDictionary( Dictionary original ) { var result = new Dictionary(); foreach (var kvp in original) { result[kvp.Key.ToString()] = kvp.Value; } return result; }

SearchBooksAsync该功能将使用混合查询执行搜索，并返回结果，其中包括用于构建切面的聚合。
FormatFacets：将聚合响应格式化为字典。
ConvertFacetDictionary：将面字典转换为更易读的格式。

下一步是创建模型，这些模型将代表 Elasticsearch 查询hits 中返回的数据，这些数据将作为结果打印在搜索页面中。

我们首先创建文件/Models/Book.cs 并添加以下内容：

namespace BlazorApp.Models { public class BookDoc { public string? Title { get; set; } public int? PageCount { get; set; } public string? PublishedDate { get; set; } public string? ThumbnailUrl { get; set; } public string? ShortDescription { get; set; } public LongDescription? LongDescription { get; set; } public string? Status { get; set; } public List? Authors { get; set; } public List? Categories { get; set; } } public class LongDescription { public string? Text { get; set; } } }

然后，在/Models/Response.cs 文件中设置弹性响应，并添加以下内容：

namespace BlazorApp.Models { public class ElasticResponse { public ElasticResponse() { Documents = new List(); Facets = new Dictionary>(); } public long TotalHits { get; set; } public List Documents { get; set; } public Dictionary> Facets { get; set; } } }

配置基本用户界面

接下来，添加 SearchBar 组件。在文件/Components/Elasticsearch/SearchBar.razor 中添加以下内容：

@using System.Threading.Tasks @code { [Parameter] public EventCallback OnSearch { get; set; } private string searchTerm = ""; private async Task SubmitSearch() { await OnSearch.InvokeAsync(searchTerm); } }

该组件包含一个搜索栏和一个执行搜索的按钮。

Blazor 允许在同一文件中使用 C# 代码动态生成 HTML，具有极大的灵活性。

之后，我们将在/Components/Elasticsearch/Results.razor 文件中构建显示搜索结果的结果组件：

@using BlazorApp.Models @if (SearchResults != null && SearchResults.Any()) {

@foreach (var result in SearchResults) {

@if (!string.IsNullOrEmpty(result?.ThumbnailUrl)) { } else {

@result?.Title

}

@result?.Title

@if (result?.Authors?.Any() == true) {

Authors: @string.Join(", ", result.Authors)

} @if (result?.Categories?.Any() == true) {

Categories: @string.Join(", ", result.Categories)

}

@if (result?.PageCount != null) {

Pages: @result.PageCount

} @if (result?.Status != null) {

Status: @result.Status

}

@result?.LongDescription?.Text

@if (!string.IsNullOrEmpty(result?.PublishedDate)) {

Published Date: @FormatDate(result.PublishedDate)

}

} else if (SearchResults != null) {

No results found.

} @code { [Parameter] public List SearchResults { get; set; } = new List(); private string FormatDate(string? date) { if (DateTime.TryParse(date, out DateTime parsedDate)) { return parsedDate.ToString("MMMM dd, yyyy"); } return ""; } }

最后，我们需要创建面来过滤搜索结果。

注：筛选器允许用户根据特定属性或类别（如产品类型、价格范围或品牌）缩小搜索结果的范围。这些筛选器通常以复选框的形式显示为可点击的选项，帮助用户缩小搜索范围，更轻松地找到相关结果。在 Elasticsearch 的上下文中，面是通过聚合创建的。

我们在文件/Components/Elasticsearch/Facet.razor 中输入以下代码来设置切面：

@if (Facets != null) { } @code { [Parameter] public Dictionary>? Facets { get; set; } [Parameter] public EventCallback>> OnFacetChanged { get; set; } private Dictionary> selectedFacets = new(); private void ToggleFacet(string facetName, string facetValue) { if (!selectedFacets.TryGetValue(facetName, out var facetValues)) { facetValues = selectedFacets[facetName] = new List(); } if (!facetValues.Remove(facetValue)) { facetValues.Add(facetValue); } OnFacetChanged.InvokeAsync(selectedFacets); } private bool IsFacetSelected(string facetName, string facetValue) { return selectedFacets.ContainsKey(facetName) && selectedFacets[facetName].Contains(facetValue); } }

该组件从terms 中读取author 、categories 和status 字段的聚合，然后生成一个过滤器列表，发送回 Elasticsearch。

现在，让我们把所有东西放在一起。

在/Components/Pages/Search.razor 文件中：

@page "/" @rendermode InteractiveServer @using BlazorApp.Models @using BlazorApp.Services @inject ElasticsearchService ElasticsearchService @inject ILogger Logger Search

Semantic Search with Elasticsearch and Blazor

About

Current search term: @currentSearchTerm

Total results: @totalResults

@code { private string currentSearchTerm = ""; private long totalResults = 0; private List searchResults = new List(); private Dictionary> facets = new Dictionary>(); private Dictionary> selectedFacets = new Dictionary>(); protected override async Task OnInitializedAsync() { await PerformSearch(); } private async Task PerformSearch(string searchTerm = "") { try { currentSearchTerm = searchTerm; var response = await ElasticsearchService.SearchBooksAsync(currentSearchTerm, selectedFacets); if (response != null) { searchResults = response.Documents; facets = response.Facets; totalResults = response.TotalHits; } else { Logger.LogWarning("Search response is null."); } StateHasChanged(); } catch (Exception ex) { Logger.LogError(ex, "Error performing search."); } } private async Task OnFacetChanged(Dictionary> newSelectedFacets) { selectedFacets = newSelectedFacets; await PerformSearch(currentSearchTerm); } }

我们的页面正在运行！

如您所见，该页面功能齐全，但缺乏风格。让我们添加一些 CSS，使其看起来更有条理，反应更灵敏。

让我们开始更换布局样式。在Components/Layout/MainLayout.razor.css 文件中：

.page { position: relative; display: flex; flex-direction: column; } main { flex: 1; } #blazor-error-ui { background: lightyellow; bottom: 0; box-shadow: 0 -1px 2px rgba(0, 0, 0, 0.2); display: none; left: 0; padding: 0.6rem 1.25rem 0.7rem 1.25rem; position: fixed; width: 100%; z-index: 1000; } #blazor-error-ui .dismiss { cursor: pointer; position: absolute; right: 0.75rem; top: 0.5rem; }

在Components/Pages/Search.razor.css 文件中添加搜索页面的样式：

.input-group .input-group-svg { background: transparent; border: transparent; pointer-events: none; } .results-facet-container { display: flex; margin-top: 1rem; overflow-x: auto; } .search-details-container { display: flex; justify-content: space-between; margin-top: 1rem; } .searchbar-container { padding-top: 2rem; display: flex; flex-direction: column; flex-grow: 1; height: 100%; max-width: 100%; } .searchbar-container h4 { margin: 0; } .top-row { margin-top: -1.1rem; position: relative; background-color: hsl(216, 29%, 67%); border-bottom: 1px solid #d6d5d5; display: flex; align-items: center; height: 100%; padding: 0 1rem; } .top-row a { margin-left: auto; margin-top: -4rem; color: #000000; text-decoration: none; } .top-row a:hover { text-decoration: underline; } @media (max-width: 640.98px) { .top-row { justify-content: space-between; } .top-row ::deep a, .top-row ::deep .btn-link { margin-left: 0; } } @media (min-width: 641px) { .top-row.auth ::deep a:first-child { flex: 1; text-align: right; width: 0; } .top-row, article { padding-left: 2rem !important; padding-right: 1.5rem !important; } }

我们的页面开始变得更好看了：

让我们来做最后的润色：

创建以下文件

Components/Elasticsearch/Facet.razor.css
Components/Elasticsearch/Results.razor.css

并为Facet.razor.css 添加样式：

.facets-container { font-size: 15px; margin-right: 4rem; overflow-x: auto; white-space: nowrap; max-width: 300px; } .results-facet-container { display: flex; margin-top: 1rem; overflow-x: auto; } .results-facet-container > * { flex-shrink: 0; }

供Results.razor.css ：

.image-container { display: flex; justify-content: center; align-items: center; height: 100%; padding: 1rem; box-sizing: border-box; } .image-container img { max-width: 100%; height: auto; border-radius: 0.5rem; } .placeholder { display: flex; justify-content: center; align-items: center; height: 100%; width: 100%; background-color: #f0f0f0; border: 1px solid #ccc; font-size: 0.9rem; color: #888; text-align: center; padding: 1rem; border-radius: 0.5rem; } .card-body { padding: 1rem; } .details-container { display: flex; justify-content: space-between; padding: 1.5rem 0; } .date-container { margin-top: 1rem; display: flex; justify-content: flex-end; } .date-container .small-date { font-weight: bold; }

最终结果

要运行应用程序，可以使用以下命令：

dotnet watch

你做到了现在，您可以使用搜索栏在 Elasticsearch 索引中搜索图书，并按作者、类别和状态过滤结果。

进行全文和语义搜索

默认情况下，我们的应用程序将使用全文和语义搜索执行混合搜索。您可以通过创建两个独立的方法来改变搜索逻辑，一个用于全文搜索，另一个用于语义搜索，然后根据用户的输入选择一种方法来创建查询。

在/Services/ElasticsearchService.cs 文件中的ElasticsearchService 类中添加以下方法：

private static Action> BuildSemanticQuery( string searchTerm, Dictionary> selectedFacets ) { var filters = BuildFilters(selectedFacets); return query => query.Bool(b => b.Must(m => m.Semantic(sem => sem.Field("longDescription").Query(searchTerm))) .Filter(filters.ToArray()) ); } private static Action> BuildMultiMatchQuery( string searchTerm, Dictionary> selectedFacets ) { var filters = BuildFilters(selectedFacets); if (string.IsNullOrEmpty(searchTerm)) { return query => query.Bool(b => b.Filter(filters.ToArray())); } return query => query.Bool(b => b.Should(m => m.MultiMatch(mm => mm.Query(searchTerm).Fields(new[] { "title", "shortDescription" }) ) ) .Filter(filters.ToArray()) ); }

这两种方法的工作原理与BuildHybridQuery 方法类似，但它们只进行全文或语义搜索。

您可以修改SearchBooksAsync 方法，使用选定的搜索方法：

public async Task SearchBooksAsync( string searchTerm, Dictionary> selectedFacets ) { try { _logger.LogInformation($"Performing search for: {searchTerm}"); // Modify the query builder to use the selected search method. var multiMatchQuery = BuildMultiMatchQuery(searchTerm, selectedFacets); // For full text search var semanticQuery = BuildSemanticQuery(searchTerm, selectedFacets); // For semantic search // In this case we will not use retrievers, but you can add them if you want to use them. var response = await _client.SearchAsync(s => s.Index("elastic-blazor-books") .Query(multiMatchQuery) // Change this line to use different search methods, for example: .Query(semanticQuery) for semantic search .Aggregations(aggs => aggs.Add("Authors", agg => agg.Terms(t => t.Field(p => p.Authors))) .Add( "Categories", agg => agg.Terms(t => t.Field(p => p.Categories)) ) .Add("Status", agg => agg.Terms(t => t.Field(p => p.Status))) ) ); if (response.IsValidResponse) { _logger.LogInformation($"Found {response.Documents.Count} documents"); var hits = response.Total; var facets = response.Aggregations != null ? FormatFacets(response.Aggregations) : new Dictionary>(); var elasticResponse = new ElasticResponse { TotalHits = hits, Documents = response.Documents.ToList(), Facets = facets, }; return elasticResponse; } else { _logger.LogWarning($"Invalid response: {response.DebugInformation}"); return new ElasticResponse(); } } catch (Exception ex) { _logger.LogError(ex, "Error performing search"); return new ElasticResponse(); } }

您可在此处找到完整的申请表

结论

Blazor 是一个有效的框架，可让您使用 C# 构建网络应用程序。Elasticsearch 是一个功能强大的搜索引擎，可让您构建搜索应用程序。将两者结合起来，您就可以轻松构建强大的搜索应用程序，利用 ESRE 的强大功能在短时间内创建语义搜索体验。

Elasticsearch .NET 客户端的演变：从 NEST 到 Elastic.Clients.Elasticsearch

Florian Bernd — Tue, 16 Apr 2024 00:00:00 GMT

.NET 客户端和 NEST 简介

在.NET世界中，与Elasticsearch的集成长期以来一直是通过NEST 库来实现的，该库是开发人员与Elasticsearch强大的搜索和分析功能进行交互的强大接口。NESTElasticsearch 的本地 .NET 客户端的需求而诞生的，因其丰富的功能集和无缝集成能力而迅速受到开发人员的青睐。

近14 年来，在Elasticsearch 首次提交后仅 8 个月，NEST 就一直忠实地跟踪 Elasticsearch 的发布情况。

从 NEST 过渡到 Elastic.Clients.Elasticsearch

随着 Elasticsearch 的发展，维护NEST 的复杂代码库变得越来越困难。我们认识到需要一种更可持续的客户端开发方法，并开始了从头开始重新设计 .NET 客户端的旅程。我们花了将近一年的时间才发布了第一个测试版，又花了一年的时间才接近支持所有服务器端点。最困难的决定之一是缩小图书馆的范围，以便优先考虑可维护性。

鉴于目前 Elasticsearch API 的规模，手动维护 450 多个端点和近 3000 种类型（请求、响应、查询、聚合等）已不再现实。为了确保语言客户端和 Elasticsearch 之间一致、准确和及时的对齐，8.x 客户端和许多相关类型现在都是根据共享规范自动生成代码的。这是在 SDK 和库（如 Azure、AWS 和 Google 云平台的 SDK 和库）中保持客户端和服务器之间一致性的常见解决方案。

Elasticsearch 规范是 8 年前通过从NEST 导出类型映射创建的，通过客户团队的辛勤工作，我们现在可以使用相同的规范创建新的 .NET 客户端（以及 Java、Go 等其他多种语言的客户端）。

随着 8.13 版的发布，NEST 正式宣布弃用。随着 Elasticsearch 过渡到Elastic.Clients.Elasticsearch ，NEST 将逐步淘汰，并在今年年底达到报废期。我们强烈建议开发人员尽早开始迁移工作，以确保平稳过渡并减少任何潜在的中断。采用Elastic.Clients.Elasticsearch 不仅能确保与最新服务器功能的兼容性，还能使应用程序免受未来功能过时的影响。

Elastic.Clients.Elasticsearch：功能和变更概述

切换到 v8 客户端Elastic.Clients.Elasticsearch 可以访问 Elasticsearch 8 的所有新功能，还为库本身带来了大量现代化功能，但也意味着与前代产品相比，便利功能有所减少。一些新的核心功能包括查询语言ES|QL 、现代机器学习（ML）功能以及以兼容 OpenTelemetry 活动的形式改进的诊断功能。从 8.13 版开始，Elastic.Clients.Elasticsearch 支持 Elasticsearch 8 的几乎所有服务器功能。

例如，一个重要的突破性变化与聚合有关。在NEST 中，Fluent API 的用法如下：

s => s .Aggregations(aggs => aggs .Children("name_of_child_agg", child => child .Aggregations(childAggs => childAggs .Average("average_per_child", avg => avg.Field(p => p.ConfidenceFactor)) .Max("max_per_child", max => max.Field(p => p.ConfidenceFactor)) .Min("min_per_child", min => min.Field(p => p.ConfidenceFactor)) ) ) )

而 v8 客户端需要使用以下语法：

s => s .Aggregations(aggs => aggs .Add("name_of_child_agg", agg => agg .Children(_ => {}) .Aggregations(childAggs => childAggs .Add("average_per_child", agg => agg.Avg(avg => avg.Field(p => p.ConfidenceFactor))) .Add("max_per_child", agg => agg.Max(max => max.Field(p => p.ConfidenceFactor))) .Add("min_per_child", agg => agg.Min(min => min.Field(p => p.ConfidenceFactor))) ) ) )

从 NEST v7 迁移到 .NET 客户端 v8

这里有一份全面的迁移指南：迁移指南：从 NEST v7 到 .NET Client v8。

.NET - Elasticsearch Labs

如何使用用于微软语义内核（Microsoft Semantic Kernel）的Elasticsearch矢量存储连接器进行人工智能代理开发

高级应用场景：利用 Semantic Kernel& Elasticsearch 构建 RAG 应用程序

RAG 示例

Elasticsearch 还能做什么

Elasticsearch& Semantic Kernel（语义内核）：下一步是什么？

使用 Blazor 和 Elasticsearch 构建搜索应用

什么是 Blazor？

为什么选择 Blazor？

什么是 ESRE？

配置 ELSER

索引数据

使用 Blazor& Elasticsearch 构建应用程序

API 密钥

创建 Blazor 项目

文件夹结构

初始配置

将 Elastic 集成到项目中

配置搜索

配置基本用户界面

@result?.Title

@facet.Key

Semantic Search with Elasticsearch and Blazor

进行全文和语义搜索

结论

Elasticsearch .NET 客户端的演变：从 NEST 到 Elastic.Clients.Elasticsearch

.NET 客户端和 NEST 简介

从 NEST 过渡到 Elastic.Clients.Elasticsearch

Elastic.Clients.Elasticsearch：功能和变更概述

从 NEST v7 迁移到 .NET 客户端 v8

其他资源