.NET - Elasticsearch Labs

Cómo usar el Conector de Almacenamiento de Vectores de Elasticsearch para el Kernel Semántico de Microsoft para el desarrollo de agentes de IA

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

En colaboración con el equipo de Microsoft Semantic Kernel , anunciamos la disponibilidad del Semantic Kernel Elasticsearch Vector Store Connector, para usuarios de Microsoft Semantic Kernel (.NET). Semantic Kernel simplifica la construcción de agentes de IA de nivel empresarial, incluyendo la capacidad de mejorar grandes modelos de lenguaje (LLMs) con respuestas más relevantes y basadas en datos desde una Vector Store. Semantic Kernel proporciona una capa de abstracción fluida para interactuar con Vector Stores como Elasticsearch, ofreciendo funciones esenciales como crear, listar y eliminar colecciones de registros, así como subir, recuperar y eliminar registros individuales.

El conector de almacenamiento vectorial de Semantic Kernel Elasticsearch, ya de fábrica , soporta las abstracciones de almacenamiento vectorial Semantic Kernel, lo que facilita mucho a los desarrolladores integrar Elasticsearch como un almacén vectorial mientras crean agentes de IA.

Elasticsearch tiene una estable base en la comunidad de código abierto y recientemente adoptó la licencia AGPL. Combinadas con el kernel semántico de código abierto de Microsoft, estas herramientas ofrecen una solución poderosa y preparada para compañías. Puedes empezar localmente activando Elasticsearch en unos minutos ejecutando este curl -fsSL https://elastic.co/start-local | sh de comandos (consulta start-local para más detalles) y pasar a versiones alojadas en la nube o autoalojadas mientras produces tus agentes de IA.

En este blog analizamos cómo usar Semantic Kernel Elasticsearch Vector Store Connector al usar Semantic Kernel. En el futuro se pondrá a disposición una versión en Python del conector.

Escenario de alto nivel: Construcción de una aplicación RAG con Kernel Semántico y Elasticsearch

En la siguiente sección repasamos un ejemplo. A un nivel general, estamos construyendo una aplicación RAG (Recuperación Generación Aumentada) que toma la pregunta del usuario como entrada y devuelve una respuesta. Usaremos Azure OpenAI (también se puede usar un LLM local ) como LLM, Elasticsearch como almacén vectorial y Semantic Kernel (.net) como marco para unir todos los componentes.

Si no estás familiarizado con las arquitecturas RAG, puedes hacer una breve introducción con este artículo: https://www.elastic.co/search-labs/blog/retrieval-augmented-generation-rag.

La respuesta la genera el LLM, que se alimenta con el contexto relevante para la pregunta, recuperado de Elasticsearch vectorstore. La respuesta también incluye la fuente que el LLM empleó como contexto.

Ejemplo RAG

En este ejemplo concreto, construimos una aplicación que permite a los usuarios hacer preguntas sobre hoteles almacenados en una base de datos interna de hoteles. El usuario podría, por ejemplo, Busca un hotel específico, según diferentes criterios, o pide una lista de hoteles.

Para la base de datos de ejemplo, generamos una lista de hoteles con 100 entradas. El tamaño de la muestra es intencionadamente pequeño para que puedas probar la demo del conector lo más fácilmente posible. En una aplicación real, el conector Elasticsearch mostraría sus beneficios sobre otras opciones, como la implementación de almacenamiento vectorial 'InMemory', especialmente cuando se trabaja con cantidades extremadamente grandes de datos.

La aplicación de demostración completa se puede encontrar en el repositorio de conectores de almacenamiento vectorial de Elasticsearch.

Empecemos agregando los paquetes NuGet necesarios y aplicando directivas a nuestro proyecto:

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;

Ahora podemos crear nuestro modelo de datos y proporcionarle atributos específicos del Núcleo Semántico para definir el esquema del modelo de almacenamiento y algunas pistas para la búsqueda de texto:

///

/// 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; } }

Los atributos del Esquema del Modelo de Almacenamiento ('VectorStore*') son los más relevantes para el uso real del Conector de Almacenamiento Vectorial Elasticsearch, a saber:

VectorStoreRecordKey para marcar una propiedad en una clase de registro como la clave bajo la cual el registro se almacena en un almacén vectorial.
VectorStoreRecordData para marcar una propiedad en una clase de registro como 'datos'.
VectorStoreRecordVector para marcar una propiedad en una clase de registro como vector.

Todos estos atributos aceptan varios parámetros opcionales que pueden emplear para personalizar aún más el modelo de almacenamiento. En el caso de VectorStoreRecordKey , por ejemplo, es posible especificar una función de distancia diferente o un tipo de índice distinto.

Los atributos de búsqueda de texto (TextSearch*) serán importantes en el último paso de este ejemplo. Volveremos a ellos más tarde.

En el siguiente paso, inicializamos el motor Semantic Kernel y obtenemos referencias a los servicios principales. En una aplicación real, se debe usar inyección de dependencias en lugar de acceder directamente a la colección de servicios. Lo mismo se aplica a la configuración y secretos codificados en fija, que deberían leer usando un proveedor de configuración en su lugar:

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"));

El servicio de vectorStoreCollection ahora puede usar para crear la colección e incorporar algunos discos demo:

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] }); } }

Esto muestra cómo Semantic Kernel reduce el uso de un almacén vectorial con toda su complejidad a unas pocas llamadas a métodos simples.

En el fondo, se crea un nuevo índice en Elasticsearch y se generan todas las asignaciones de propiedades necesarias. Nuestro conjunto de datos se mapea de forma completamente transparente en el modelo de almacenamiento y finalmente se almacena en el índice. A continuación se muestra cómo se ven los mapeos en Elasticsearch.

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

El embeddings.GenerateEmbeddingsAsync() llama de forma transparente al servicio configurado Azure AI Embeddings Generation.

Se puede observar aún más magia en el último paso de esta demo.

Con una sola llamada a InvokePromptAsync, se realizan todas las siguientes operaciones cuando el usuario hace una pregunta sobre los datos:

1. Se genera una incrustación para la pregunta del usuario

2. Se busca en el almacén vectorial las entradas relevantes

3. Los resultados de la consulta se insertan en una plantilla de prompt

4. La consulta real en forma de prompt final se envía al servicio de finalización de chat con IA

// 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());

¿Recuerdas los atributos TextSearch* que definimos previamente en nuestro modelo de datos? Estos atributos nos permiten usar marcadores de posición correspondientes en nuestra plantilla de prompts, que se llenan automáticamente con la información de nuestras entradas en el almacén vectorial.

La respuesta final a nuestra pregunta "Por favor, muéstrame todos los hoteles que tengan un bar en la azotea" es la siguiente:

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).

La respuesta correcta se refiere a la siguiente entrada de nuestro 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

Este ejemplo muestra muy bien cómo el uso de Microsoft Semantic Kernel logra una reducción significativa de la complejidad gracias a sus abstracciones bien pensadas, además de permitir un nivel muy alto de flexibilidad. Por ejemplo, al cambiar una sola línea de código, el almacén vectorial o los servicios de IA empleados pueden ser reemplazados sin necesidad de refactorizar ninguna otra parte del código.

Al mismo tiempo, el framework proporciona un enorme conjunto de funcionalidades de alto nivel, como la función 'InvokePrompt', o el sistema de plantillas o plugins de búsqueda.

La aplicación de demostración completa se puede encontrar en el repositorio de conectores de almacenamiento vectorial de Elasticsearch.

¿Qué más es posible con Elasticsearch?

Elasticsearch & Semantic Kernel: ¿Qué sigue?

Mostramos cómo la tienda vectorial de Elasticsearch puede conectarse fácilmente a Semantic Kernel mientras se construyen aplicaciones GenAI en .NET. Estad atentos para la próxima integración de Python.
A medida que Semantic Kernel construye abstracciones para funciones avanzadas de búsqueda como la búsqueda híbrida, el Elasticsearch Connect permitirá a los desarrolladores .NET implementarlas fácilmente usando Semantic Kernel.

Crear una aplicación de búsqueda con Blazor y Elasticsearch

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

En este artículo, aprenderás cómo aprovechar tus habilidades en C# para crear una aplicación de búsqueda usando Blazor y Elasticsearch. Vamos a usar el cliente Elasticsearch .NET para ejecutar consultas de texto completo, semánticas y búsquedas híbridas .

NOTA Si conoces la versión anterior del cliente Nest de Elasticsearch en C#, lee esta entrada del blog sobre la deprecación del cliente NEST y las nuevas funciones. NEST fue la generación anterior del cliente .NET que fue reemplazado por el Elastic.Clients.Elasticsearch package

¿Qué es Blazor?

Blazor es un framework sitio web de código abierto basado en HTML, CSS y C# creado por Microsoft para permitir a los desarrolladores crear aplicaciones sitio web que se ejecuten en el cliente o en el servidor. Blazor también permite crear componentes reutilizables para construir aplicaciones más rápido; permite a los desarrolladores construir la vista HTML y las acciones en C# dentro del mismo archivo, lo que ayuda a mantener un código legible y limpio. Además, con Blazor Hybrid puedes crear aplicaciones móviles nativas accediendo a las capacidades nativas de la plataforma mediante código .NET.

Algunas de las características que hacen de Blazor un excelente marco para trabajar:

Opciones de renderizado tanto en el lado servidor como en el cliente
Componentes reutilizables de la interfaz
Actualizaciones en tiempo real con SignalR
Gestión del estado integrada
Sistema de enrutamiento integrado
Comprobaciones fuertes de tipado y tiempo de compilación

¿Por qué Blazor?

Blazor ofrece varios beneficios sobre otros frameworks y librerías: permite a los desarrolladores usar C# tanto para el código cliente como para el servidor, proporcionando una fuerte verificación de tipado y compilación que mejora la fiabilidad. Se integra perfectamente con el ecosistema .NET, permitiendo la reutilización de librerías y herramientas .NET, y ofrece un soporte robusto para depuración.

¿Qué es ESRE?

El Elasticsearch Relevance Engine™ (ESRE) es un conjunto de herramientas para construir aplicaciones de búsqueda empleando aprendizaje automático e inteligencia artificial sobre el poderoso motor de búsqueda Elasticsearch.

Para saber más sobre ESRE, puedes leer nuestra interesante entrada de blog aquí

Configuración de ELSER

Para aprovechar las capacidades ESRE de Elastic, vamos a emplear ELSER como nuestro proveedor de modelos.

Nota: para usar los modelos ELSER de Elasticsearch, debes tener una licencia Platinum o Enterprise, y disponer de un nodo mínimo dedicado de Machine Lerning (ML) de 4GB de tamaño. Lee más sobre esto aquí.

Empieza creando el punto final de inferencia:

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

Si es la primera vez que usas ELSER, puede que te encuentres con un error 502 de Mal Gateway mientras el modelo se carga en segundo plano. Puedes consultar el estado del modelo en Machine Learning > Trained Models en Kibana. Una vez desplegado, puedes pasar al siguiente paso.

Datos de indexación

Puedes descargar el conjunto de datos aquí y luego importar los datos usando Kibana. Para ello, ve a la página principal y haz clic en "Subir datos". Luego, sube el archivo y haz clic Import. Por último, ve a la pestaña Advanced y pega los siguientes mapeos:

{ "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" } } }

Vamos a crear un índice capaz de ejecutar consultas semánticas y de texto completo. El tipo de campo semantic_text se encargará del fragmento de datos y la incrustación. Ten en cuenta que estamos indexando longDescription como semantic_text, puedes usar copy_to si quieres indexar un campo tanto como semantic_text como texto'.

Construcción de la app con Blazor & Elasticsearch

Clave API

Lo primero que tenemos que hacer es crear una clave API para autenticar nuestras solicitudes a Elasticsearch. La clave API debe ser de solo lectura y solo permitir consultar el índice de books-blazor .

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

Verás algo así:

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

Almacena el valor del campo de respuesta encoded cuando sea necesario más adelante. Si usas Elastic Cloud, también necesitarás tu ID de la nube. (Puedes encontrarlo aquí).

Creación del proyecto Blazor

Empieza instalando Blazor y creando un proyecto de muestra siguiendo las instrucciones oficiales.

Una vez que tengas el proyecto creado, la estructura de carpetas y los archivos deberían ver así:

La aplicación plantilla incluye Bootstrap v5.1.0 para peinar.

Termina la configuración del proyecto instalando el cliente Elasticsearch .NET :

dotnet add package Elastic.Clients.Elasticsearch

Una vez que completes este paso, tu página debería ver así:

Estructura de carpetas

Ahora, vamos a organizar nuestras carpetas de la siguiente manera:

Archivos explicados:

Components/Pages/Search.razor: página principal que contiene la barra de búsqueda, los resultados y los filtros.
Componentes/Páginas/Search.razor.css: estilos de página.
Components/Elasticsearch/SearchBar.razor: componente de la barra de búsqueda.
Components/Elasticsearch/Results.razor: componente de resultados.
Components/Elasticsearch/Facet.razor: componente de filtros.
Components/Svg/GlassIcon.razor: icono de búsqueda.
Components/_Imports.razor: esto importará todos los componentes.
Modelos/Book.cs: esto almacenará el esquema del campo libro.
Modelos/Response.cs: esto almacenará el esquema de respuesta, incluyendo los resultados de búsqueda, facetas y resultados totales.
Servicios/ElasticsearchService.cs: Servicio Elasticsearch. Se encargará de la conexión y las consultas a Elasticsearch.

Configuración inicial

Empecemos con una limpieza.

Elimina los archivos:

Componentes/Páginas/Counter.razor
Componentes/Páginas/Weather.razor
Componentes/Páginas/Home.razor
Componentes/Layout/NavMenu.razor
Componentes/Diseño/NavMenu.razor.css

Revisa el archivo /Components/_Imports.razor . Deberías tener las siguientes importaciones:

@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

Integración de Elastic en el proyecto

Ahora, importemos los componentes de Elasticsearch:

Vamos a eliminar la barra lateral predeterminada para tener más espacio para nuestra aplicación eliminándola del archivo /Components/Layout/MainLayout.razor :

@inherits LayoutComponentBase

@Body

An unhandled error has occurred. Reload 🗙

Ahora introduzcamos las credenciales de Elasticsearch para los secretos de usuario:

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

Con este enfoque, .Net 8 almacena datos sensibles en una ubicación separada, fuera de la carpeta del proyecto, y los hace accesibles mediante la interfaz IConfiguration . Estas variables estarán disponibles para cualquier proyecto .Net que emplee los mismos secretos de usuario.

Luego, modifiquemos el archivo Program.cs para leer los secretos y montar el cliente Elasticsearch:

Primero, importa las bibliotecas necesarias:

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

BlazorApp.Services: contiene el servicio Elasticsearch.
Elastic.Clients.Elasticsearch: importa la biblioteca cliente .Net 8 de Elasticsearch.
Elastic.Transport: importa la biblioteca de transporte Elasticsearch, que nos permite usar la clase ApiKey para autenticar nuestras solicitudes.

Segundo, inserta el siguiente código antes de la línea 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); });

Este código leerá las credenciales de Elasticsearch de los secretos de usuario y creará una instancia cliente de Elasticsearch.

Tras la inicialización del cliente ElasticSearch, agrega la siguiente línea para registrar el servicio Elasticsearch:

builder.Services.AddScoped();

El siguiente paso será construir la lógica de búsqueda en el archivo /Services/ElasticsearchService.cs :

Primero, importa las bibliotecas y modelos necesarios:

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

Segundo, agregar la clase ElasticsearchService, constructor y variables:

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; } } }

Configuración de búsqueda

Ahora, vamos a construir nuestra lógica de búsqueda:

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 construirá los filtros para la consulta de búsqueda usando las facetas seleccionadas por el usuario.
BuildHybridQuery construirá una consulta de búsqueda híbrida que combine texto completo y búsqueda semántica.

A continuación, agrega el método de búsqueda:

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: realizará la búsqueda usando la consulta híbrida y devolverá los resultados incluidas agregaciones para construir las facetas.
FormatFacets: formateará la respuesta de agregación en un diccionario.
ConvertFacetDictionary: convertirá el diccionario de facetas en un formato más legible.

El siguiente paso es crear los modelos que representarán los datos devueltos en el hits de la consulta de Elasticsearch que se imprimirán como resultados en nuestra página de búsqueda.

Comenzamos creando el /Models/Book.cs de archivo y agregando lo siguiente:

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; } } }

Luego, configurar la respuesta Elastic en el archivo /Models/Response.cs y agregar lo siguiente:

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; } } }

Configuración de una interfaz básica

A continuación, agrega el componente Barra de búsqueda. En el archivo /Components/Elasticsearch/SearchBar.razor y agrega lo siguiente:

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

Este componente contiene una barra de búsqueda y un botón para realizar la búsqueda.

Blazor ofrece una gran flexibilidad al permitir generar HTML dinámicamente usando código C# dentro del mismo archivo.

Después, en el archivo /Components/Elasticsearch/Results.razor construiremos el componente de resultados que mostrará los resultados de búsqueda:

@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 ""; } }

Finalmente, necesitaremos crear facetas para filtrar los resultados de búsqueda.

Nota: Los facetos son filtros que permiten a los usuarios reducir los resultados de búsqueda en función de atributos o categorías específicas, como el tipo de producto, el rango de precio o la marca. Estos filtros suelen presentar como opciones clicables, a menudo en forma de casillas para marcar, para ayudar a los usuarios a refinar su búsqueda y encontrar resultados relevantes con mayor facilidad. En el contexto de Elasticsearch, las facetas se crean mediante agregaciones.

Configuramos facetas poniendo el siguiente código en el archivo /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); } }

Este componente lee de una agregación terms en los campos author, categoriesy status , y luego produce una lista de filtros para enviar de vuelta a Elasticsearch.

Ahora, vamos a juntar todo.

En /Components/Pages/Search.razor expediente:

@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); } }

¡Nuestra página funciona!

Como puedes ver, la página es funcional pero carece de estilos. Vamos a agregar algo de CSS para que parezca más organizado y receptivo.

Empecemos a reemplazar los estilos de distribución. En el archivo 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; }

Agrega los estilos de la página de búsqueda en el archivo 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; } }

Nuestra página empieza a ver mejor:

Vamos a darle los toques finales:

Crea los siguientes archivos:

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

Y agrega los estilos para 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; }

Para 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; }

Resultado final:

Para ejecutar la aplicación puedes usar el siguiente comando:

dotnet watch

¡Lo conseguiste! Ahora puedes buscar libros en tu índice de Elasticsearch usando la barra de búsqueda y filtrar los resultados por autor, categoría y estado.

Realización de búsqueda en texto completo y semántica

Por defecto, nuestra app realiza una búsqueda híbrida usando tanto texto completo como búsqueda semántica. Puedes cambiar la lógica de búsqueda creando dos métodos separados, uno para texto completo y otro para búsqueda semántica, y luego seleccionar uno para construir la consulta basar en la entrada del usuario.

Agrega los siguientes métodos a la clase ElasticsearchService en el archivo /Services/ElasticsearchService.cs :

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()) ); }

Ambos métodos funcionan de forma similar al método BuildHybridQuery , pero solo realizan búsqueda en texto completo o semántica.

Puedes modificar el método SearchBooksAsync para usar el método de búsqueda seleccionado:

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(); } }

Puedes encontrar la solicitud completa aquí

Conclusión

Blazor es un framework eficaz que te permite crear aplicaciones sitio web usando C#. Elasticsearch es un poderoso motor de búsqueda que te permite crear aplicaciones de búsqueda. Combinando ambos, puedes construir fácilmente aplicaciones de búsqueda robustas, aprovechando el poder de ESRE para crear una experiencia de búsqueda semántica en poco tiempo.

Evolución del cliente Elasticsearch .NET: De NEST a Elastic.Clients.Elasticsearch

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

Introducción al cliente .NET y NEST

En el mundo .NET, la integración con Elasticsearch fue facilitada durante mucho tiempo por la biblioteca NEST , que sirve como una interfaz robusta para que los desarrolladores interactúen con las poderosas capacidades de búsqueda y análisis de Elasticsearch. NEST, nacida de la necesidad de un cliente .NET nativo para Elasticsearch, ganó rápidamente popularidad entre los desarrolladores por su amplio conjunto de funciones y sus integraciones fluidas.

Durante casi 14 años y solo 8 meses después del primer commit de Elasticsearch , NEST estuvo siguiendo fielmente las versiones de Elasticsearch.

Transición de NEST a Elastic.Clients.Elasticsearch

A medida que Elasticsearch evolucionó, mantener la compleja base de código de NESTse volvió cada vez más difícil. Reconocimos la necesidad de un enfoque más sostenible en el desarrollo de clientes y emprendimos un camino para rediseñar el cliente .NET desde cero. Nos llevó casi un año lanzar la primera versión beta y otro año más acercarnos a dar soporte a todos y cada uno de los endpoints de servidor. Una de las decisiones más difíciles fue reducir el alcance de la biblioteca para priorizar la mantenibilidad.

Dado el tamaño actual de la superficie de la API de Elasticsearch, ya no es práctico mantener manualmente más de 450 endpoints y casi 3000 tipos (solicitudes, respuestas, consultas, agregaciones, etc.). Para cerciorar una alineación consistente, precisa y oportuna entre los clientes del lenguaje y Elasticsearch, los clientes 8.x y muchos de los tipos asociados ahora se generan automáticamente por código a partir de una especificación compartida. Esta es una solución común para mantener la alineación entre cliente y servidor entre SDKs y librerías, como los de Azure, AWS y la Google Cloud Platform.

La especificación Elasticsearch se creó hace más de 8 años exportando los mapeos de tipos de NEST y, gracias al arduo trabajo del equipo de clientes, ahora podemos usar la misma especificación para crear un nuevo cliente .NET (y clientes para varios otros lenguajes como Java, Go, etc.).

Con el lanzamiento de la versión 8.13, se anunció oficialmente la desaparición de NEST . A medida que Elasticsearch se transforma en Elastic.Clients.Elasticsearch, NEST irá desapareciendo gradualmente, alcanzando su fin de vida útil al final del año. Se anima encarecidamente a los promotores a iniciar los esfuerzos de migración con antelación para garantizar una transición fluida y mitigar posibles interrupciones. Adoptar Elastic.Clients.Elasticsearch no solo garantiza compatibilidad con las últimas funciones del servidor, sino que también protege a futuro las aplicaciones contra funcionalidades obsoletas.

Elastic.Clients.Elasticsearch: resumen de características y cambios

Cambiar al cliente v8 Elastic.Clients.Elasticsearch permite acceder a todas las nuevas funciones de Elasticsearch 8 y también aporta numerosas modernizaciones a la propia biblioteca, pero implica una reducción en las características de comodidad en comparación con su predecesor. Algunas de las nuevas características principales incluyen el lenguaje de consultas ES|QL, capacidades modernas de aprendizaje automático (ML) y diagnósticos mejorados en forma de actividades compatibles con OpenTelemetry. A partir de la versión 8.13, Elastic.Clients.Elasticsearch soporta casi todas las funciones de servidor de Elasticsearch 8.

Un cambio importante de ruptura, por ejemplo, está relacionado con las agregaciones. En NEST, el uso fluido de la API es así:

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)) ) ) )

mientras que el cliente v8 requiere la siguiente sintaxis:

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))) ) ) )

Migración de NEST v7 a .NET client v8

Aquí está disponible una guía completa de migración: Guía de migración: De NEST v7 a .NET Client v8.

.NET - Elasticsearch Labs

Cómo usar el Conector de Almacenamiento de Vectores de Elasticsearch para el Kernel Semántico de Microsoft para el desarrollo de agentes de IA

Escenario de alto nivel: Construcción de una aplicación RAG con Kernel Semántico y Elasticsearch

Ejemplo RAG

¿Qué más es posible con Elasticsearch?

Elasticsearch & Semantic Kernel: ¿Qué sigue?

Crear una aplicación de búsqueda con Blazor y Elasticsearch

¿Qué es Blazor?

¿Por qué Blazor?

¿Qué es ESRE?

Configuración de ELSER

Datos de indexación

Construcción de la app con Blazor & Elasticsearch

Clave API

Creación del proyecto Blazor

Estructura de carpetas

Configuración inicial

Integración de Elastic en el proyecto

Configuración de búsqueda

Configuración de una interfaz básica

@result?.Title

@facet.Key

Semantic Search with Elasticsearch and Blazor

Realización de búsqueda en texto completo y semántica

Conclusión

Evolución del cliente Elasticsearch .NET: De NEST a Elastic.Clients.Elasticsearch

Introducción al cliente .NET y NEST

Transición de NEST a Elastic.Clients.Elasticsearch

Elastic.Clients.Elasticsearch: resumen de características y cambios

Migración de NEST v7 a .NET client v8

Recursos adicionales

.NET - Elasticsearch Labs

Cómo usar el Conector de Almacenamiento de Vectores de Elasticsearch para el Kernel Semántico de Microsoft para el desarrollo de agentes de IA

Escenario de alto nivel: Construcción de una aplicación RAG con Kernel Semántico y Elasticsearch

Ejemplo RAG

¿Qué más es posible con Elasticsearch?

Elasticsearch & Semantic Kernel: ¿Qué sigue?

Crear una aplicación de búsqueda con Blazor y Elasticsearch

¿Qué es Blazor?

¿Por qué Blazor?

¿Qué es ESRE?

Configuración de ELSER

Datos de indexación

Construcción de la app con Blazor & Elasticsearch

Clave API

Creación del proyecto Blazor

Estructura de carpetas

Configuración inicial

Integración de Elastic en el proyecto

Configuración de búsqueda

Configuración de una interfaz básica

@result?.Title

@facet.Key

Semantic Search with Elasticsearch and Blazor

Realización de búsqueda en texto completo y semántica

Conclusión

Evolución del cliente Elasticsearch .NET: De NEST a Elas­tic.Cli­ents.Elastic­search

Introducción al cliente .NET y NEST

Transición de NEST a Elastic.Clients.Elasticsearch

Elastic.Clients.Elasticsearch: resumen de características y cambios

Migración de NEST v7 a .NET client v8

Recursos adicionales

Evolución del cliente Elasticsearch .NET: De NEST a Elastic.Clients.Elasticsearch