<![CDATA[Florian Bernd - Elasticsearch Labs]]> <![CDATA[Florian Bernd - Elasticsearch Labs]]> https://static-www.elastic.co/v3/assets/bltefdd0b53724fa2ce/blt1121c0bf0e8a6e65/6a88da6340a1841030ef456f/search-labs-thumbnail.png https://www.elastic.co/cn/search-labs/author/florian-bernd https://www.elastic.co/cn/search-labs/author/florian-bernd Sat, 17 Oct 2026 00:13:18 GMT <![CDATA[LINQ to Elasticsearch ES|QL：编写 C# 代码，查询 Elasticsearch]]> 从 v9.3.4 和 v8.19.18 开始，Elasticsearch .NET 客户端包含一个语言集成查询 (LINQ) 提供程序，可在运行时将 C# LINQ 表达式转换为 Elasticsearch 查询语言 (ES|QL) 查询。您可以使用Where、Select、OrderBy、GroupBy 和其他标准操作符来编写查询，而无需手工编写 ES|QL 字符串。提供程序负责转换、参数化和结果反序列化，包括按行流式传输，无论结果集大小如何，都能保持稳定的内存使用量。

您的第一个查询

首先定义一个映射到 Elasticsearch 索引的普通旧 CLR 对象 (POCO)。属性名称通过标准System.Text.Json 属性（如[JsonPropertyName]）或配置的JsonNamingPolicy 解析为 ES|QL 列名。适用于客户端其他部分的源序列化规则在这里也同样适用。

using System.Text.Json.Serialization; public class Product { [JsonPropertyName("product_id")] public string Id { get; set; } public string Name { get; set; } public string Brand { get; set; } [JsonPropertyName("price_usd")] public double Price { get; set; } [JsonPropertyName("in_stock")] public bool InStock { get; set; } }

类型设置完成后，查询语句如下所示：

var minPrice = 100.0; var brand = "TechCorp"; await foreach (var product in client.Esql.QueryAsync<Product>(q => q .From("products") .Where(p => p.InStock && p.Price >= minPrice && p.Brand == brand) .OrderByDescending(p => p.Price) .Take(10))) { Console.WriteLine($"{product.Name}: ${product.Price}"); }

该提供程序将此转换为以下 ES|QL：

需要注意的一些细节：

  • 属性名称解析：由于 [JsonPropertyName] 属性，p.Price 变成了 price_usd，根据默认 camelCase 命名策略，p.Brand 变成 brand。

  • 参数捕获：C# 变量 minPrice 和 brand 被捕获为命名参数 (?minPrice，?brand)。它们与 JSON 有效负载中的查询字符串分开发送，这样可以防止注入，并实现服务器端查询计划缓存。

  • 流式传输：QueryAsync<T> 返回 IAsyncEnumerable<T>。从 Elasticsearch 返回数据时，数据会逐行具体化。

您还可以在不执行的情况下检查生成的查询及其参数：

var query = client.Esql.CreateQuery<Product>() .Where(p => p.InStock && p.Price >= minPrice && p.Brand == brand) .OrderByDescending(p => p.Price) .Take(10); Console.WriteLine(query.ToEsqlString()); // FROM products | WHERE (in_stock == true AND price_usd >= 100) | SORT price_usd DESC | LIMIT 10 Console.WriteLine(query.ToEsqlString(inlineParameters: false)); // FROM products | WHERE (in_stock == true AND price_usd >= ?minPrice AND brand == ?brand) | SORT price_usd DESC | LIMIT 10 var parameters = query.GetParameters(); // { "minPrice": 100.0, "brand": "TechCorp" }

这如何运作？快速回顾一下 LINQ

使 LINQ 提供程序成为可能的机制是 IEnumerable<T> 和 IQueryable<T> 之间的区别。

在 IEnumerable<T> 上调用 .Where(p => p.Price > 100) 时，lambda 会编译为 Func<Product, bool>，即一个由运行时在进程内执行的常规委托。这就是 LINQ-to-Objects。

当您在IQueryable<T> 上调用相同的方法时，C# 编译器会将 lambda 封装在Expression<Func<Product, bool>> 中。这是一种数据结构，表示代码的结构，而不是代码的可执行形式。在运行时，该表达式树可被检查、分析，并转换为另一种语言。

// IEnumerable: the lambda is a compiled delegate IEnumerable<Product> local = products.Where(p => p.Price > 100); // IQueryable: the lambda is an expression tree, a data structure IQueryable<Product> remote = queryable.Where(p => p.Price > 100);

IQueryProvider 接口是扩展点。任何提供程序均可通过实现 CreateQuery<T> 和 Execute<T>，将这些表达式树转换为目标语言。实体框架就是利用此机制生成 SQL 语句。LINQ to ES|QL 提供程序使用它来生成 ES|QL 查询。

上述查询的表达式树如下所示：

示例查询的表达式树。

示例查询的表达式树。

此表达式树由内而外嵌套：Take 包裹着 OrderByDescending，它又包裹着 Where，而后者再包裹着 From，而最内层是根节点 EsqlQueryable<Product> 常量。对于 &&、>= 和 == 这几种操作符而言，Where 谓词本身是一个由 BinaryExpression 个节点构成的子树，其中包含 MemberExpression 个叶子节点，这些叶子节点用于属性访问，以及对 minPrice 和 brand 变量的闭包捕获。提供程序会遍历这一数据结构，从而生成最终的 ES|QL 查询。

深入了解：转换管道

从 LINQ 表达式到查询结果的路径遵循六阶段管道：

转换管道概述。

转换管道概述。

1. 表达式树捕获

当在一个 IQueryable<T> 对象上串联使用 .Where()、.OrderBy()、.Take() 及其他操作符时，标准的 LINQ 基础架构会构建一个表达式树。EsqlQueryable<T> 实现了 IQueryable<T> 接口，并将处理委托给 EsqlQueryProvider。

2. 翻译

当查询被执行 (通过枚举、调用 ToList()，或使用 await foreach) 时)，EsqlExpressionVisitor自内而外遍历表达式树。它会将每个 LINQ 方法调用分派给一个专门的访问器进行处理：

访客

翻译

进入

WhereClauseVisitor

.Where(predicate)

WHERE 条件

SelectProjectionVisitor

.Select(selector)

评估 + 保留 + 重命名

GroupByVisitor

.GroupBy().Select()

统计信息 ... 依据

OrderByVisitor

.OrderBy() / .ThenBy()

SORT 字段 [ASC\|DESC]

EsqlFunctionTranslator

EsqlFunctions.*、Math.*、字符串方法

80+ ES|QL 函数

在翻译过程中，表达式中引用的 C# 变量被捕获为命名参数。

3. 查询模型

访问器不会直接生成字符串。相反，它们会产生 QueryCommand 对象，一个不可变的中间表征。一个 FromCommand、一个 WhereCommand、一个 SortCommand 和一个 LimitCommand，各代表一条 ES|QL 处理命令。这些数据被收集到EsqlQuery 模型中。

查询模型和命令模式。

查询模型和命令模式。

该中间模型与表达式树和输出格式均解耦。它可以被检查、拦截（通过 IEsqlQueryInterceptor）或在格式化前进行修改。

4. 格式化

EsqlFormatter 依次访问每个QueryCommand ，并生成最终的 ES|QL 字符串。每条命令占一行，通过 ES|QL 中用于串联处理命令的管道 (|) 运算符分隔。若标识符包含特殊字符，系统会自动用反引号进行转义处理。

5. 执行

格式化后的 ES|QL 查询字符串及捕获的参数会以 JSON 数据载荷的形式发送至 Elasticsearch 的 /_query 终端。而 IEsqlQueryExecutor 接口则对传输层进行了抽象封装，这正是分层包架构发挥作用的关键环节。

6. 实现

EsqlResponseReader 流式传输JSON响应，但不会将整个结果集缓冲到内存中。以流式方式传输 JSON 响应数据，无需将整个结果集缓存至内存。针对每次查询预先计算生成的 ColumnLayout 树结构，会将扁平化的 ES|QL 列名（如 address.street、address.city）映射到嵌套的 POCO 属性。每行数据会被组装为 T 实例，并通过 IEnumerable<T> 或 IAsyncEnumerable<T> 逐个返回。

分层架构

LINQ to ES|QL 功能分为三个软件包：

软件包架构。

软件包架构。Elastic.Esql 是纯转换引擎。该组件完全不依赖 HTTP 协议栈，集成了表达式访问器、查询模型、格式化器及响应解析器等核心模块。您可独立使用它来构建和检查 ES|QL 查询（无需连接 Elasticsearch），这在测试验证、查询日志记录或自定义执行层开发等场景中极具实用价值。翻译要点解析：

// Translation-only: no Elasticsearch connection needed var provider = new EsqlQueryProvider(); var query = new EsqlQueryable<Product>(provider) .From("products") .Where(p => p.InStock) .OrderByDescending(p => p.Price); Console.WriteLine(query.ToEsqlString()); // FROM products | WHERE in_stock == true | SORT price_usd DESC

Elastic.Clients.Esql 是一款轻量级的独立 ES|QL 客户端。该组件通过 Elastic.Transport 在 Elastic.Esql 之上扩展了 HTTP 协议执行能力。如果您的应用程序仅需使用 ES|QL 而无需其他 Elasticsearch API，此方案可实现最小化依赖集成。

Elastic.Clients.Elasticsearch 是完整的 Elasticsearch.NET 客户端。它还建立在Elastic.Esql 的基础上，并通过client.Esql 命名空间公开 LINQ 提供程序接口。这是大多数应用程序的推荐入口点。

两个执行层组件包均提供了针对 IEsqlQueryExecutor 接口的独立实现。该策略接口作为转换与传输层的桥梁。

当与源码生成的 JsonSerializerContext 配合使用时，这三个组件包均支持原生 AOT 编译。如需完整客户端集成方案，请参阅原生 AOT 文档。

不只使用基础功能

上面的例子涵盖了筛选、排序和分页。该提供程序支持更广泛的操作范围。

聚合

GroupBy结合 Select 中的聚合函数，转换为 ES|QL STATS ... BY：

var stats = client.Esql.Query<Product, object>(q => q .GroupBy(p => p.Brand) .Select(g => new { Brand = g.Key, Count = g.Count(), AvgPrice = g.Average(p => p.Price), MaxPrice = g.Max(p => p.Price) })); // -> FROM products | STATS COUNT(*), AVG(price_usd), MAX(price_usd) BY brand

投影

Select，使用匿名类型生成 EVAL、KEEP 和 RENAME 命令：

var query = client.Esql.CreateQuery<Product>() .Select(p => new { ProductName = p.Name, p.Price, p.InStock }); // -> FROM products | KEEP name, price_usd, in_stock | RENAME name AS ProductName

丰富的函数库

通过 EsqlFunctions 类，可以使用超过 80 个 ES|QL 函数，涵盖日期/时间、字符串、数学、IP、模式匹配和评分。标准 Math.* 和 string.* 方法也已转换：

.Where(p => p.Name.Contains("Pro")) // -> WHERE name LIKE "*Pro*" .Where(p => EsqlFunctions.CidrMatch( // -> WHERE CIDR_MATCH(ip, "10.0.0.0/8") p.IpAddress, "10.0.0.0/8"))

查找连接

跨索引查找转换为 ES|QL LOOKUP JOIN：

var enriched = client.Esql.Query<Product, object>(q => q .LookupJoin<Product, CategoryLookup, string, object>( "category-lookup-index", product => product.Id, category => category.CategoryId, (product, category) => new { product.Name, category!.CategoryLabel }));

原生 ES|QL 直通接口

对于 LINQ 提供程序尚未涵盖的 ES|QL 功能，您可以添加原始片段：

var results = client.Esql.Query<Product>(q => q .Where(p => p.InStock) .RawEsql("| EVAL discounted = price_usd * 0.9"));

服务器端异步查询

对于长时间运行的查询，可将其提交给服务器进行后台处理：

await using var asyncQuery = await client.Esql.SubmitAsyncQueryAsync<Product>( q => q.Where(p => p.InStock), asyncQueryOptions: new EsqlAsyncQueryOptions { WaitForCompletionTimeout = TimeSpan.FromSeconds(5), KeepAlive = TimeSpan.FromMinutes(10) }); await asyncQuery.WaitForCompletionAsync(); await foreach (var product in asyncQuery.AsAsyncEnumerable()) Console.WriteLine(product.Name);

服务器端异步查询对于长时间运行的分析型查询/大规模数据集处理尤其有用，这类操作可能会超出常规的超时阈值；在存在负载均衡器、API 网关或代理（这些组件会强制执行严格的 HTTP 超时设置）的超时敏感环境中，异步查询同样优势显著。异步查询通过将查询提交与结果获取解耦，避免了连接中断的情况。

开始使用

LINQ to ES|QL 自以下版本起可用：

  • Elastic.Clients.Elasticsearch v9.3.4（9.x 分支）

  • Elastic.Clients.Elasticsearch v8.19.18（8.x 分支）

从 NuGet 安装：

dotnet add package Elastic.Clients.Elasticsearch

入口点位于client.Esql上：

方法

返回值

用例

查询<T>(...)

IEnumerable<T>

同步执行

QueryAsync<T>(...)

IAsyncEnumerable<T>

异步流式处理

CreateQuery<T>()

IEsqlQueryable<T>

高级结构分析和检测

SubmitAsyncQueryAsync<T>(...)

EsqlAsyncQuery<T>

长时间运行的服务器端查询

有关完整的功能参考，包括查询选项、多字段访问、嵌套对象和多值字段处理，请参阅LINQ to ES|QL 文档。

结论

LINQ 转 ES|QL 将 C# LINQ 的强大表达能力引入到 Elasticsearch 的 ES|QL 查询语言中，让您无需手工编写查询字符串，就能生成强类型、可组合的查询。它具备自动参数捕获、流式物化功能，还拥有分层式的软件包架构，既能满足独立转换需求，也能适配完整的 Elasticsearch 客户端，可自然融入任意规模的 .NET 应用程序。安装最新客户端，将 LINQ 表达式指向索引，剩下的就交给该提供程序来处理。

]]> https://www.elastic.co/search-labs/blog/linq-esql-c-elasticsearch-net-client https://www.elastic.co/search-labs/blog/linq-esql-c-elasticsearch-net-client Wed, 01 Apr 2026 00:00:00 GMT <![CDATA[如何使用用于微软语义内核（Microsoft Semantic Kernel）的Elasticsearch矢量存储连接器进行人工智能代理开发]]> 我们与 微软语义内核 （ 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）的特定属性，以定义存储模型模式和文本搜索的一些提示：

/// <summary> /// Data model for storing a "hotel" with a name, a description, a description embedding and an optional reference link. /// </summary> 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<float>? 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<Hotel>(); // Register Elasticsearch vector store. var elasticsearchClientSettings = new ElasticsearchClientSettings(new Uri("https://my-elasticsearch-instance.cloud")) .Authentication(new BasicAuthentication("elastic", "my_password")); kernelBuilder.AddElasticsearchVectorStoreRecordCollection<string, Hotel>("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<Kernel>()!; var embeddings = host.Services.GetService<ITextEmbeddingGenerationService>()!; var vectorStoreCollection = host.Services.GetService<IVectorStoreRecordCollection<string, Hotel>>()!; // Register search plugin. var textSearch = host.Services.GetService<VectorStoreTextSearch<Hotel>>()!; 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（语义内核）的同时轻松实现这些功能。

]]> https://www.elastic.co/search-labs/blog/elasticsearch-connector-microsoft-semantic-kernel https://www.elastic.co/search-labs/blog/elasticsearch-connector-microsoft-semantic-kernel Fri, 06 Dec 2024 00:00:00 GMT <![CDATA[Elasticsearch .NET 客户端的演变：从 NEST 到 Elastic.Clients.Elasticsearch]]> .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<CommitActivity>("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。

其他资源

]]> https://www.elastic.co/search-labs/blog/net-client-evolution https://www.elastic.co/search-labs/blog/net-client-evolution Tue, 16 Apr 2024 00:00:00 GMT