Abril de 2019

Volumen 34, número 4

[.NET]

Implementar su propio motor de búsqueda Enterprise Search

Por Xavier Morera

Probablemente, da por sentada la búsqueda. La usa a diario para realizar todo tipo de tareas, desde la búsqueda de alojamiento para su próximo viaje hasta la información que necesita para su trabajo. Una búsqueda implementada correctamente puede ayudarle a ahorrar (o ganar) dinero. Además, incluso en una aplicación excelente, una mala experiencia de búsqueda puede crear una experiencia de usuario insatisfactoria.

El problema es que, a pesar de su importancia, la búsqueda es una de las funcionalidades más incomprendidas de TI, ya que solo se le presta atención cuando falta o no funciona. Pero la búsqueda no tiene que ser una característica desconocida difícil de implementar. En este artículo, explicaré cómo puede desarrollar una API de motor de búsqueda Enterprise Search en C#.

Para conocer mejor la búsqueda, necesita un motor de búsqueda. Hay muchas opciones: desde código abierto hasta soluciones comerciales o una combinación de estos. Muchas de estas opciones usan internamente Lucene: una de las bibliotecas de recuperación de información favoritas. Incluye Azure Search, ElasticSearch y Solr. Hoy usaré Solr. ¿Por qué? Existe desde hace tiempo, tiene una buena documentación, una comunidad dinámica y muchos usuarios destacados. Personalmente, la he usado para implementar la búsqueda en muchas aplicaciones, desde sitios pequeños hasta grandes empresas.

Obtener Solr

La instalación de un motor de búsqueda puede parecer una tarea complicada y, de hecho, si está configurando una instancia de Solr de producción que necesita admitir un gran número de consultas por segundo (QPS), efectivamente, puede resultar complicado. (QPS es una métrica común que se usa para hacer referencia a la carga de trabajo de búsqueda).

Estos pasos se describen en detalle en la sección "Instalar Solr" de la documentación de Solr (lucene.apache.org/solr), así como en la sección “The Well-Configured Solr Instance” (La instancia de Solr bien configurada) de la guía de referencia de Apache Solr (bit.ly/2IK7mqY). Pero me basta con una instancia de Solr de desarrollo, así que voy a bit.ly/2tEXqoo y descargo una versión binaria; por ejemplo, solr-7.7.0.zip me servirá.

Descargo el archivo .zip, lo descomprimo, abro la línea de comandos y cambio el directorio a la raíz de la carpeta en la que descomprimí el archivo. A continuación, emito el comando siguiente:

> bin\solr.cmd start

Eso es todo. Ahora solo tengo que ir a http://localhost:8983, donde me encuentro con la UI de administración de Solr, como se muestra en la Figura 1.

Figura 1 Motor de búsqueda activo y en ejecución

Obtener datos

A continuación, necesito datos. Hay una gran cantidad de conjuntos de datos disponibles con datos interesantes, pero, cada día, miles de desarrolladores acaban en StackOverflow porque no recuerdan cómo se escribe contenido en un archivo, no pueden salir de VIM o necesitan un fragmento de código de C# que resuelva un problema concreto. La buena noticia es que los datos de StackOverflow están disponibles como volcado XML que contiene, aproximadamente, 10 millones de preguntas y respuestas, etiquetas, notificaciones, información de usuario anónima y muchas cosas más (bit.ly/1GsHll6).

Aún mejor, puedo seleccionar un conjunto de datos con el mismo formato de un sitio de StackExchange más pequeño que solo contenga unas miles de preguntas. Puedo probar primero con el conjunto de datos más pequeño y, más adelante, reforzar la infraestructura para trabajar con más datos.

Comenzaré con los datos de datascience.stackexchange.com, que contiene, aproximadamente, 25 000 publicaciones. El archivo se denomina datascience.stackexchange.com.7z. Lo descargo y extraigo Posts.xml.

Algunos conceptos necesarios

Tengo un motor de búsqueda y datos, por lo que es un buen momento para revisar algunos conceptos importantes. Si está acostumbrado a trabajar con bases de datos relacionales, probablemente le resultarán familiares.

El índice es donde un motor de búsqueda almacena todos los datos que se recopilan para la búsqueda. En un nivel superior, Solr almacena los datos en lo que se denomina un índice invertido. En un índice invertido, las palabras (o tokens) apuntan a documentos específicos. Una búsqueda de una palabra concreta es una consulta. Si se encuentra la palabra (un resultado o coincidencia), el índice indicará qué documentos contienen esta palabra y dónde.

El esquema es la forma de especificar la estructura de los datos. Cada registro se considera un documento y, del mismo modo que se definen las columnas de una base de datos, se especifican los campos de un documento en un motor de búsqueda.

Para construir el esquema, se edita un archivo XML llamado schema.xml y se definen los campos con sus tipos. Sin embargo, también puede usar campos dinámicos, en los que se crea un campo nuevo automáticamente cuando se agrega un campo desconocido. Esto puede ser útil si no está totalmente seguro de todos los campos que están presentes en los datos.

Puede que ya haya observado que Solr es bastante similar a un almacén de documentos NoSQL, ya que puede contener documentos con campos desnormalizados que no son necesariamente coherentes dentro de la colección de documentos.

El modo sin esquema es otra forma de modelar los datos del índice. En este caso, no indica explícitamente a Solr qué campos indexará. En su lugar, basta con agregar datos y Solr construye un esquema basado en el tipo de datos que se agrega al índice. Para usar el modo sin esquema, debe tener un esquema administrado, lo que significa que no puede editar manualmente los campos. Esto resulta especialmente útil para una fase de exploración de datos o prueba de concepto.

Usaré un esquema editado manualmente, que es el enfoque recomendado para la producción, ya que proporciona mayor control.

La indexación es el proceso de agregar datos al índice. Durante la indexación, una aplicación lee de distintos orígenes y prepara los datos para la ingesta. Esta es la palabra que se usa para agregar documentos. También es posible que escuche el término alimentación.

Una vez indexados los documentos, es posible buscar y, con suerte, encontrar los documentos más pertinentes para una búsqueda concreta en las primeras posiciones. 

La clasificación de relevancia consiste en situar los resultados más adecuados al principio. Este es un concepto fácil de explicar. En la mejor situación, se ejecuta una consulta y el motor de búsqueda "lee" su mente y le devuelve, exactamente, los documentos que buscaba.

Precisión frente a coincidencia: La precisión hace referencia a cuántos de los resultados son pertinentes (la calidad de los resultados), mientras que la coincidencia indica cuántos de los resultados totales devueltos son pertinentes (la cantidad o integridad de los resultados). 

Analizadores, tokenizadores y filtros: al indexar o buscar datos, un analizador examina el texto y genera una secuencia de tokens. A continuación, se aplican transformaciones a través de filtros para intentar crear correspondencias entre las consultas y los datos indexados. Debe comprender estos conceptos si quiere tener conocimientos más profundos de la tecnología de motor de búsqueda. Por suerte, para empezar a crear una aplicación, basta con una visión general.

Descripción de los datos

Para modelar el índice, es necesario comprender los datos. Para ello, abriré Posts.xml y lo analizaré. 

Este es el aspecto de los datos. El nodo de publicaciones contiene muchos nodos secundarios de fila. Cada nodo secundario se corresponde con un registro, y cada campo se exporta como atributo en cada nodo secundario. Los datos están muy limpios para la ingesta en el motor de búsqueda, lo que es bueno:

<posts>
  <row Id=”5” PostTypeId=”1” CreationDate=”2014-05-13T23:58:30.457”
    Score=”9” ViewCount=”448” Body=”<Contains the body of the question or answer>”
      OwnerUserId=”5” LastActivityDate=”2014-05-14T00:36:31.077”
        Title=”How can I do simple machine learning without hard-coding behavior?”
          Tags=”<machine-learning,artificial-intelligence>;” AnswerCount=”4”
            CommentCount=”5” FavoriteCount=”1”
              ClosedDate=”2014-05-14T14:40:25.950” />
  ...
</posts>

A simple vista, puedo observar rápidamente que hay campos de distintos tipos. Hay un identificador único, algunas fechas, un par de campos numéricos, algunos campos de texto largo y corto, y algunos campos de metadatos. Para mayor brevedad, edité el cuerpo, que es un campo de texto grande, pero todos los demás conservan su estado original.

Configuración de Solr para usar un esquema clásico

Hay varias formas de especificar la estructura de los datos para el índice. De forma predeterminada, Solr utiliza un esquema administrado, lo que significa que usa el modo sin esquema. Pero me gustaría construir manualmente el esquema, lo que se llama esquema clásico, así que necesito realizar algunos cambios de configuración. En primer lugar, crearé una carpeta para almacenar la configuración del índice, que llamaré msdnarticledemo. La carpeta se encuentra en <solr>\server\solr\, donde <solr> es la carpeta en la que descomprimí Solr.

A continuación, creo un archivo de texto en la raíz de esta carpeta denominado core.properties, al que solo debo agregar la línea siguiente: name=msdnarticledemo. Este archivo se usa para crear un núcleo de Solr, que es, simplemente, una instancia en ejecución de un índice de Lucene. Es posible que también escuche la palabra colección, que puede tener un significado diferente en función del contexto. Para mi intención y finalidad actual, un núcleo es el equivalente de un índice.

Ahora debo copiar el contenido de un índice limpio de muestra que se puede usar como base. Solr incluye uno en <solr>\server\solr\configsets\_default. Copio la carpeta conf en msdnarticledemo.

En el próximo paso, muy importante, indico a Solr que quiero usar un esquema clásico; es decir, que editaré manualmente mi esquema. Para hacerlo, abro solrconfig.xml y agrego la línea siguiente:

<schemaFactory class=”ClassicIndexSchemaFactory”/>

Además, aún dentro de este archivo, comento dos nodos: updateRequestProcessorChain con:

name=”add-unknown-fields-to-the-schema”
and updateProcessor with:
name=”add-schema-fields”

Esas dos características son las que permiten a Solr agregar nuevos campos e indexar datos en un modo sin esquema. También quito el comentario del nodo xml, ya que "--" no se permite dentro de los comentarios xml.

Finalmente, cambio el nombre de managed-schema a schema.xml. Y así, Solr está listo para usar un esquema creado manualmente.

Creación del esquema

El siguiente paso es definir los campos del esquema, así que abro schema.xml y me desplazo hacia abajo hasta que encuentro la definición de id, _text_ y _root_.

Así se define cada campo, como nodo xml <field> que contiene:

• name: nombre para cada campo.
• type: tipo de campo; puede modificar cómo se controla cada tipo en schema.xml.
• indexed: "true" indica que este campo se puede usar para realizar búsquedas.
• stored: "true" indica que este campo se puede devolver y presentar.
• required: "true" indica que este campo se debe indexar. En caso contrario, se genera un error.
• multiValued: "true" indica que este campo puede contener más de un valor.

Al principio, puede resultar confuso: algunos campos se pueden mostrar, pero no se pueden buscar, y algunos campos se pueden buscar, pero puede que no se puedan recuperar después de la indexación. Hay otros atributos avanzados, pero no entraré en detalles en este momento.

En la figura 2 se muestra cómo defino los campos en el esquema para publicaciones. Para los tipos de texto, tengo varias opciones, como string, text_get_sort y text_general. La búsqueda de texto es uno de los principales objetivos de la búsqueda; de ahí los distintos tipos compatibles con texto. También tengo una fecha, un entero, un flotante y un campo que admite más de un valor: Tags.

Figura 2 Campos en Schema.xml

<field name=”id” type=”string” indexed=”true” stored=”true”
  required=”true” multiValued=”false” />
<field name=”postTypeId” type=”pint” indexed=”true” stored=”true” />
<field name=”title” type=”text_gen_sort” indexed=”true”
  stored=”true” multiValued=”false”/
<field name=”body” type=”text_general” indexed=”false”
  stored=”true” multiValued=”false”/>
<field name=”tags” type=”string” indexed=”true” stored=”true”
  multiValued=”true”/>
<field name=”postScore” type=”pfloat” indexed=”true” stored=”true”/>
<field name=”ownerUserId” type=”pint” indexed=”true” stored=”true” />
<field name=”answerCount” type=”pint” indexed=”true” stored=”true” />
<field name=”commentCount” type=”pint” indexed=”true” stored=”true” />
<field name=”favoriteCount” type=”pint” indexed=”true” stored=”true” />
<field name=”viewCount” type=”pint” indexed=”true” stored=”true” />                
<field name=”creationDate” type=”pdate” indexed=”true” stored=”true” />
<field name=”lastActivityDate” type=”pdate” indexed=”true” stored=”true” />
<field name=”closedDate” type=”pdate” indexed=”true” stored=”true” />

Lo que ocurre después puede variar en función de la implementación. De momento, tengo muchos campos y puedo especificar el que quiero buscar y la importancia de que el campo sea relativo a otros campos.

Para empezar, puedo usar el campo _text_ de catch-all para realizar una búsqueda en todos mis campos. Simplemente, creo copyField y le indico a Solr que los datos de todos los campos se deben copiar en mi campo predeterminado:

<copyField source=”*” dest=”_text_”/>

Ahora, al ejecutar una búsqueda, Solr buscará en este campo y devolverá cualquier documento que coincida con la consulta.

A continuación, reinicio Solr para cargar el núcleo y aplicar los cambios mediante este comando:

> bin\solr.cmd restart

Ahora estoy listo para empezar a crear una aplicación de C#.                 

Obtención de SolrNet y modelación de los datos

Solr proporciona una API de tipo REST que puede usar fácilmente desde cualquier aplicación. Mejor aún: hay una biblioteca denominada SolrNet (bit.ly/2XwkROA) que proporciona una abstracción sobre Solr, lo que le permite trabajar fácilmente con objetos fuertemente tipados, con una gran funcionalidad que permite agilizar el desarrollo de aplicaciones de búsqueda.

La manera más fácil de obtener SolrNet es instalar el paquete SolrNet de NuGet. Incluiré la biblioteca en la nueva aplicación de consola que creé con Visual Studio 2017. También puede descargar paquetes adicionales, como SolrCloud, que son necesarios para usar otros mecanismos de control de inversión y para obtener una funcionalidad adicional.

En mi aplicación de consola, necesito modelar los datos de mi índice. Es bastante sencillo: simplemente, creo un nuevo archivo de clase denominado Post.cs, como se muestra en la figura 3.

Figura 3 Modelo de documento Post

class Post
{
  [SolrUniqueKey(“id”)]
  public string Id { get; set; }
  [SolrField(“postTypeId”)]
  public int PostTypeId { get; set; }
  [SolrField(“title”)]
  public string Title { get; set; }
  [SolrField(“body”)]
  public string Body { get; set; }
  [SolrField(“tags”)]
  public ICollection<string> Tags { get; set; } = new List<string>();
  [SolrField(“postScore”)]
  public float PostScore { get; set; }
  [SolrField(“ownerUserId”)]
  public int? OwnerUserId { get; set; }
  [SolrField(“answerCount”)]
  public int? AnswerCount { get; set; }
  [SolrField(“commentCount”)]
  public int CommentCount { get; set; }
  [SolrField(“favoriteCount”)]
  public int? FavoriteCount { get; set; }
  [SolrField(“viewCount”)]
  public int? ViewCount { get; set; }
  [SolrField(“creationDate”)]
  public DateTime CreationDate { get; set; }
  [SolrField(“lastActivityDate”)]
  public DateTime LastActivityDate { get; set; }
  [SolrField(“closedDate”)]
  public DateTime? ClosedDate { get; set; }
}

Esto es, simplemente, un objeto CRL estándar (POCO) que representa cada documento individual de mi índice, pero con un atributo que indica a SolrNet a qué campo se asigna cada propiedad.

Creación de una aplicación de búsqueda

Cuando se crea una aplicación de búsqueda, normalmente, se crean dos funcionalidades independientes:

El indizador: se trata de la aplicación que necesito crear en primer lugar. Es bastante simple: para tener datos que buscar, debo alimentar datos en Solr. Esto puede implicar la lectura de datos de varios orígenes, convirtiéndolos a partir de diversos formatos, hasta que, finalmente, estén listos para la búsqueda.

La aplicación de búsqueda: una vez que tengo datos en mi índice, puedo empezar a trabajar en la aplicación de búsqueda.

En ambos casos, el primer paso requiere la inicialización de SolrNet, que se puede hacer con la línea siguiente de la aplicación de consola (asegúrese de que Solr se esté ejecutando):

Startup.Init<Post>(“http://localhost:8983/solr/msdnarticledemo”);

Crearé una clase para cada funcionalidad en mi aplicación.

Creación del indizador

Para indexar los documentos, empiezo por obtener la instancia de servicio de SolrNet, lo que me permite iniciar cualquier operación admitida:

var solr = ServiceLocator.Current.GetInstance<ISolrOperations<Post>>();

A continuación, debo leer el contenido de Posts.xml en un documento XML, lo que implica la iteración en cada nodo, la creación de un nuevo objeto Post, la extracción de cada atributo de XMLNode y la asignación a la propiedad correspondiente.

Tenga en cuenta que, dentro del campo de recuperación de la información, o de búsqueda, los datos se almacenan desnormalizados. En cambio, cuando trabaja con bases de datos, los datos se suelen normalizar para evitar la duplicación. En lugar de agregar el nombre del propietario a una publicación, agregue un identificador de entero y cree una tabla independiente para que el identificador coincida con un nombre. Sin embargo, en la búsqueda, el nombre se agrega como parte de la publicación, lo que genera datos duplicados. ¿Por qué? Porque, cuando se normalizan los datos, es necesario realizar conexiones para la recuperación, y son bastante caras. Pero uno de los principales objetivos de un motor de búsqueda es la velocidad. Los usuarios esperan presionar un botón y obtener los resultados que quieren inmediatamente.

Ahora volvamos a la creación del objeto de publicación. En la figura 4, voy a mostrar solo tres campos, ya que agregar otros es bastante fácil. Tenga en cuenta que Tags tiene varios valores y que estoy comprobando si existen valores null para evitar excepciones.  

Figura 4 Completar campos

Post post = new Post();
post.Id = node.Attributes[“Id”].Value;
if (node.Attributes[“Title”] != null)
{
  post.Title = node.Attributes[“Title”].Value;
}
if (node.Attributes[“Tags”] != null){
  post.Tags = node.Attributes[“Tags”].Value.Split(new char[] { ‘<’, ‘>’ })
    .Where(t => !string.IsNullOrEmpty(t)).ToList();}
// Add all other fields

Una vez rellenado el objeto, puedo agregar cada instancia con el método Add:

solr.Add(post);

Como alternativa, puedo crear una colección de publicaciones y agregar publicaciones en lotes mediante AddRange:

solr.AddRange(post_list);

Cualquiera de los enfoques es correcto, pero se ha observado en muchas implementaciones de producción que agregar documentos en lotes de 100 tiende a incrementar el rendimiento. Tenga en cuenta que la adición de un documento no hace que este se pueda buscar. Es necesario confirmar:

solr.Commit();

Ahora voy a ejecutar y, según la cantidad de datos que se indexen y la máquina en que se ejecuten, el proceso puede tardar desde unos pocos segundos hasta un par de minutos.

Una vez completado, puedo navegar a la UI de administración de Solr, buscar un elemento desplegable en el lateral izquierdo con el texto Core Selector (Selector de núcleos) y elegir mi núcleo (msdnarticledemo). Desde la pestaña Overview (Información general), puedo ver las estadísticas, que me indican cuántos documentos acabo de indexar.

En mi volcado de datos, tenía 25 488 publicaciones, lo que coincide con lo que veo:

Statistics
  Last Modified: less than a minute ago
  Num Docs:25488
  Max Doc:25688

Ahora que tengo datos en mi índice, puedo empezar a trabajar en la búsqueda.

Búsqueda en Solr

Antes de volver a Visual Studio, quiero demostrar una búsqueda rápida desde la UI de administración de Solr y explicar algunos de los parámetros disponibles.

En el núcleo de msdnarticledemo, haré clic en Query (Consulta) y presionaré el botón azul de la parte inferior con el texto Execute Query (Ejecutar consulta). Recupero todos mis documentos en formato JSON, tal como se muestra en la figura 5.

Figura 5 Consulta en Solr mediante la UI de administración

Así pues, ¿qué acabo de hacer y por qué se me han devuelto todos los documentos del índice? La respuesta es sencilla. Eche un vistazo a los parámetros: la columna con el texto Request-Handler (qt) en la parte superior. Como puede ver, un parámetro tiene la etiqueta q y el valor *:*.  Eso es lo que ha devuelto todos los documentos. De hecho, la consulta que ejecuté consistía en buscar en todos los campos todos los valores mediante un par clave-valor. Si, en lugar de eso, solo quisiera buscar Solr en el título, el valor q sería Title:Solr. 

Esto resulta muy útil para crear consultas más complicadas que proporcionan distintos pesos para cada campo, lo que tiene sentido. Una palabra o frase de un título es más importante que una del contenido. Por ejemplo, si un documento contiene Enterprise Search en el título, es muy probable que el documento trate sobre los motores de búsqueda Enterprise Search. Pero si encuentro esta frase en cualquier parte del cuerpo de un documento, puede que solo sea una referencia a algo que apenas tenga relación.

El parámetro q es, probablemente, el más importante, ya que calcula una puntuación y recupera los documentos en orden de relevancia. Sin embargo, hay otros parámetros que puede usar mediante el controlador de solicitudes para configurar cómo procesa las solicitudes Solr, incluida una consulta de filtro (fq), orden, lista de campos (fl) y muchos más que puede buscar en la documentación de Solr en bit.ly/2GVmYGl. Con estos parámetros, puede empezar a crear consultas más complicadas. Se necesita algún tiempo para perfeccionar la técnica, pero cuanto más aprenda, mejores clasificaciones de relevancia obtendrá.

Recuerde que la UI de administrador no es la manera de interactuar de la aplicación con Solr. Para eso, se usa una interfaz similar a REST. Justo encima de los resultados, hay un vínculo en un cuadro gris que contiene la llamada para esta consulta concreta. Al hacer clic en él, se abre una nueva ventana, que tiene la respuesta.

Esta es mi consulta:

http://localhost:8983/solr/msdnarticledemo/select?q=*%3A*&wt=json

SolrNet realiza llamadas como esta de forma interna, pero presenta objetos que puedo usar desde mi aplicación .NET. Ahora crearé una aplicación de búsqueda básica.

Creación de la aplicación de búsqueda

En este caso concreto, voy a buscar las preguntas en todos los campos de mi conjunto de datos. Dado que los datos contienen tanto las preguntas como las respuestas, filtraré por PostTypeId con "1", lo que significa que es una pregunta.  Para hacerlo, usaré una consulta de filtro: el parámetro fq.

Además, definiré algunas opciones de consulta para devolver una página de resultados a la vez; en concreto, Rows, para indicar el número de resultados, y StartOrCursor para especificar el desplazamiento (inicio). Y, por supuesto, definiré la consulta.

En la figura 6 se muestra el código necesario para ejecutar una búsqueda básica, donde la consulta es el texto que estoy buscando.

Figura 6 Ejecutar una búsqueda básica

QueryOptions query_options = new QueryOptions
{
  Rows = 10,
  StartOrCursor = new StartOrCursor.Start(0),
  FilterQueries = new ISolrQuery[] {
    new SolrQueryByField(“postTypeId”, “1”),
    }
};
// Construct the query
SolrQuery query = new SolrQuery(keywords);
// Run a basic keyword search, filtering for questions only
var posts = solr.Query(query, query_options);

Después de ejecutar la consulta, obtengo publicaciones, que son un objeto SolrQueryResults. Contiene una colección de resultados, así como muchas propiedades con varios objetos que proporcionan una funcionalidad adicional. Ahora que tengo los resultados, puedo mostrarlos al usuario.

Restricción de los resultados

En muchos casos, los resultados originales pueden ser buenos, pero puede que el usuario quiera restringirlos por un campo de metadatos concreto. Es posible explorar en profundidad un campo mediante facetas. En una faceta, recibo una lista de pares clave-valor. Por ejemplo, con Tags, obtengo cada etiqueta y el número de veces que se repite. Las facetas se suelen usar con campos numéricos, de fecha o de cadena. Los campos de texto son complicados.

Para habilitar las facetas, debo agregar un nuevo elemento QueryOption (Facet):  

Facet = new FacetParameters
{
  Queries = new[] {
    new SolrFacetFieldQuery(“tags”)
  }
}

Ahora puedo recuperar mis facetas desde posts.FacetFields[“tags”], que es una colección de pares clave-valor que contienen cada etiqueta concreta y el número de veces que se repite cada etiqueta en el conjunto de resultados.

A continuación, puedo permitir al usuario seleccionar las etiquetas en las que quiere profundizar, lo que reduce la cantidad de resultados con una consulta de filtro e, idealmente, devuelve documentos pertinentes. 

Mejorar la búsqueda: ¿y ahora, qué?

Hasta ahora, he tratado los aspectos básicos de la implementación de una búsqueda básica en C# con Solr y SolrNet con las preguntas de uno de los sitios de StackExchange. Sin embargo, esto es solo el comienzo de un nuevo viaje donde puedo indagar en el arte de devolver resultados pertinentes mediante Solr.

Algunos de los siguientes pasos permiten buscar por campos individuales con distintos pesos, marcar resultados para destacar las correspondencias de contenido, aplicar sinónimos para devolver resultados que pueden estar relacionados, pero no contienen las palabras exactas de la búsqueda, determinar la raíz para reducir las palabras a su base y facilitar su recuperación, buscar por fonética para ayudar a los usuarios internacionales, etc.

En definitiva, aprender a implementar la búsqueda es una aptitud valiosa que puede aportarle resultados útiles en el futuro como desarrollador.

Para acompañar este artículo, he creado un proyecto de búsqueda básico, como se muestra en la figura 7, que puede descargar para obtener más información sobre motores de búsqueda Enterprise Search. Que disfrute de la búsqueda.

Figura 7 Proyecto de búsqueda de muestra

Xavier Morera ayuda a los desarrolladores a comprender los motores de búsqueda Enterprise Search y los macrodatos. Crea cursos en Pluralsight y, a veces, en Cloudera. Trabajó durante muchos años en Search Technologies (ahora parte de Accenture) con implementaciones de búsqueda. Vive en Costa Rica y puede encontrarle en xaviermorera.com.

Gracias a los siguientes expertos técnicos por revisar este artículo: Jose Arias (Accenture), Jonathan Gonzalez (Accenture)
Jose Arias es un apasionado de las tecnologías relacionadas con la búsqueda y los macrodatos, especialmente las que se usan para el análisis de datos.  Trabaja como desarrollador sénior en Accenture Search & Content Analytics. https://www.linkedin.com/in/joseariasq/
Jonathan Gonzalez <(j.gonzalez.vindas@accenture.com)>
Jonathan Gonzalez trabaja como arquitecto de administración sénior en Accenture, con más de 18 años de experiencia en desarrollo y diseño de software. Durante los últimos 13 años, se ha especializado en recuperación de la información, motores de búsqueda Enterprise Search, procesamiento de datos y análisis de contenido. https://www.linkedin.com/in/jonathan-gonzalez-vindas-ba3b1543/