Integrando Elasticsearch e OpenAI em uma API Web ASP.NET Core

Neste artigo, vamos percorrer o processo de criação de uma ASP.NET Core Web API que integra Elasticsearch e OpenAI. O objetivo é construir um sistema que possa responder perguntas com base em dados armazenados no Elasticsearch, usando OpenAI para gerar respostas baseadas nos dados recuperados. Essa abordagem é poderosa para aplicativos como suporte ao cliente, assistentes virtuais e sistemas de recomendação.

1. Configurando o projeto ASP.NET Core Web API

a) Criação do Projeto

Primeiro, vamos criar um novo projeto ASP.NET Core Web API usando o .NET CLI:

 dotnet new webapi -n ElasticsearchOpenAIWebAPI
 

Este comando cria um novo projeto de API da Web chamado ElasticsearchOpenAIWebAPI .

b) Instalando os Pacotes Necessários

Em seguida, instale os pacotes NEST e OpenAI para permitir a interação com o Elasticsearch e o OpenAI:

dotnet add package NEST
 dotnet add package OpenAI-API
 

NEST é a biblioteca oficial para comunicação com Elasticsearch em C#. O pacote OpenAI-API será usado para interagir com a OpenAI API.

2. Configurando appsettings.json

As chaves da API e a URL do Elasticsearch são normalmente armazenadas no appsettings.json arquivo para fácil acesso:

{
  "Elasticsearch": {
    "Uri": "https://0179425de9034d8596bdb1b192f8229b.us-central1.gcp.cloud.es.io:443",
    "ApiKey": "your_elasticsearch_api_key"
  }, 
"OpenAI" : {
 "ApiKey" : "sua_chave_api_openai"
 }
 } 

Este arquivo de configuração contém informações de conexão para o Elasticsearch e a API OpenAI, que serão carregadas no aplicativo durante a inicialização.

3. Criando classes de configuração

Vamos criar uma classe AppSettings.cs para mapear as configurações de appsettings.json :

 public class AppSettings
 { 
público ElasticsearchSettings Elasticsearch { obter ; definir ; } 
Configurações públicas do OpenAI OpenAI { obter ; definir ; }
 }

 classe pública ElasticsearchSettings
 { 
string pública Uri { obter ; definir ; } 
string pública ApiKey { obter ; definir ; }
 }

 classe pública OpenAISettings
 { 
string pública ApiKey { obter ; definir ; }
 } 

Essa estrutura de classe nos permitirá acessar as configurações em nossos serviços.

4. Configurando o serviço Elasticsearch usando NEST

a) Criando o serviço Elasticsearch

O ElasticsearchService a classe usará o cliente NEST para interagir com o Elasticsearch:

 using Microsoft . Extensions . Options ;
 using Nest ;

 public class ElasticsearchService
 { 
ElasticClient privado somente leitura _client ;

 público ElasticsearchService ( IOptions < AppSettings > configurações )
 { 
var connectionSettings = new ConnectionSettings ( novo Uri ( configurações . Valor . Elasticsearch . Uri ) ) 
. ApiKeyAuthentication ( configurações . Valor . Elasticsearch . ApiKey ) ;
 _client = novo ElasticClient ( connectionSettings ) ; 
}

 public async Task < Lista < SearchResult >> SearchAsync ( string query )
 { 
var searchResponse = await _client . SearchAsync < SearchResult > ( s => s 
. Índice ( "search-olx" )
 . Consulta ( q => q
 . MultiMatch ( mm => mm 
. Consulta ( query )
 . Campos ( f => f
 . Campo ( p => p . BodyContent ) 
. Campo ( p => p . Título )
 )
 )
 )
 . Tamanho ( 3 ) 
) ;

 retornar searchResponse . Documentos . ToList ( ) ;
 }
 } 

b) Explicação detalhada

• ConnectionSettings : Esta classe define as configurações de conexão para o Elasticsearch. O URI e a chave da API são recuperados do appsettings.json .

• ElasticClient : O ElasticClient é o principal cliente usado para interagir com o Elasticsearch, configurado com o ConnectionSettings .

• SearchAsync : Este método executa uma consulta de pesquisa no Elasticsearch. Ele usa um MultiMatch consulta para pesquisar em vários campos ( body_content e title ). O método retorna os 3 principais documentos relevantes.

📌 Nota resumida:

• ElasticsearchService : uma classe de serviço que interage com uma instância do Elasticsearch usando o cliente NEST.
• ElasticClient : Cliente principal usado para executar operações do Elasticsearch, configurado via ConnectionSettings com o URI e a chave da API.
• Método SearchAsync : Um método assíncrono que realiza uma pesquisa no índice “search-olx”, usando um MultiMatch consulta para pesquisar em todo o BodyContent e Title campos, retornando os 3 principais resultados.
• Objetivo : Permite a pesquisa e recuperação eficientes de documentos relevantes do Elasticsearch com base em consultas do usuário.

c) Modelo SearchResult

Criar um SearchResult modelo para mapear os resultados da pesquisa:

 public class SearchResult
 { 
string pública BodyContent { obter ; definir ; } 
string pública Título { obter ; definir ; }
 } 

Este modelo mapeia os campos dos documentos retornados pelo Elasticsearch.

5. Configurando o serviço OpenAI

a) Criação do serviço OpenAI

O OpenAIService a classe irá interagir com a API OpenAI para gerar respostas com base no contexto fornecido:

 using OpenAI_API ; 
usando OpenAI_API . Bate-papo ;
 usando Microsoft . Extensões . Opções ;

 classe pública OpenAIService
 { 
OpenAIAPI _api privada somente leitura ;

 público OpenAIService ( IOptions < AppSettings > configurações )
 { 
_api = novo OpenAIAPI ( configurações . Valor . OpenAI . ApiKey ) ;
 }
 
public async Task < string > GetCompletionAsync ( string contexto , string pergunta )
 { 
var chat = _api . Bate-papo . CreateConversation ( ) ;
 bate-papo . AppendSystemMessage ( $@"
 Você é um assistente para tarefas de resposta a perguntas. 
Responda às perguntas com sinceridade e de forma factual, usando apenas o contexto apresentado.
 Se você não sabe a resposta, apenas diga que não sabe, não invente uma resposta.
 Use o formato markdown para exemplos de código.
 Você está correto, é factual, preciso e confiável.
 " ) ; 
bate-papo . AppendUserInput ( $"Contexto: { contexto } " ) ; 
bate-papo . AppendUserInput ( pergunta ) ;

 var resultado = await chat . GetResponseFromChatbotAsync ( ) ; 
retornar resultado ;
 }
 } 

b) Explicação detalhada

• OpenAIAPI : Esta classe é usada para interagir com a OpenAI API. A chave da API é fornecida via configuração.

• GetCompletionAsync : Este método cria uma conversa com o modelo OpenAI, onde o contexto é passado como parte da entrada do usuário. O OpenAI gera uma resposta com base no contexto e na pergunta do usuário.

📌 Nota resumida:

• OpenAIService : Uma classe de serviço que interage com a API OpenAI para gerar respostas com base no contexto fornecido.
• OpenAIAPI : cliente principal usado para comunicação com o OpenAI, inicializado com uma chave de API das definições de configuração.
• Método GetCompletionAsync : Um método assíncrono que cria uma conversa com o modelo OpenAI. Ele fornece:
  • Instruções do sistema : Diretrizes detalhadas sobre como a IA deve se comportar:
    • Seja verdadeiro e factual : a IA é instruída a responder perguntas usando apenas o contexto fornecido e não fabricar nenhuma informação.
    • Respostas somente baseadas no contexto : a IA deve confiar exclusivamente no contexto fornecido para gerar respostas, garantindo precisão e relevância.
    • Honestidade na incerteza : se a IA não sabe a resposta, ela é orientada a admitir isso em vez de adivinhar ou criar informações.
    • Formatação de código : se a resposta envolver código, ele deverá ser formatado usando Markdown para maior clareza.
    • Tom e estilo : a IA deve ser correta, factual, precisa e confiável em suas respostas.
  • Entradas do usuário : O contexto real (de pesquisas anteriores ou dados fornecidos) e a pergunta específica do usuário.
  • O método gera e retorna uma resposta com base nesse contexto e pergunta.
• Explicação do Prompt : O prompt instrui cuidadosamente a IA sobre a natureza de sua resposta, enfatizando a precisão, o uso do contexto fornecido e a formatação apropriada. Isso garante que a saída da IA ​​não seja apenas relevante, mas também confiável e clara, particularmente em cenários técnicos envolvendo código.
• Objetivo : permite a geração de respostas dinâmicas e sensíveis ao contexto usando o OpenAI, adaptadas às consultas específicas do usuário e ao contexto fornecido, ao mesmo tempo em que garante que as respostas sigam as diretrizes especificadas.

6. Criando o Controlador de API da Web

Crie um controlador para expor o endpoint que combina Elasticsearch e OpenAI:

 using Microsoft . AspNetCore . Mvc ;

 [ ApiController ] 
[ Rota ( "api/[controlador]" ) ]
 classe pública SearchController : ControllerBase
 { 
ElasticsearchService privado somente leitura _elasticsearchService ;
 privado somente leitura OpenAIService _openAIService ;
 
Controlador de Pesquisa público ( ElasticsearchService elasticsearchService , OpenAIService openAIService )
 {
 _elasticsearchService = Serviçoelasticsearch ;
 _openAIService = Serviço de IA aberto ;
 }
 
[ HttpGet ( "perguntar" ) ] 
public async Task < IActionResult > Ask ( [ FromQuery ] string question )
 { 
var results = await _elasticsearchService . SearchAsync ( pergunta ) ; 
var context = string . Join ( "\n" , resultados . Select ( r => r . BodyContent ) ) ;
 
var conclusão = await _openAIService . GetCompletionAsync ( contexto , pergunta ) ;

 retornar Ok ( conclusão ) ; 
}
 } 

a) Explicação detalhada

• Ask : Este é o endpoint principal que recebe a pergunta do usuário por meio de uma string de consulta ( ?question=... ). Ele primeiro consulta o Elasticsearch usando o ElasticsearchService , em seguida, passa o contexto resultante para OpenAIService , que gera uma resposta com base nos dados recuperados.

• HttpGet(“ask”) : Este atributo define um ponto de extremidade HTTP GET que pode ser acessado em api/search/ask .

7. Configurando Program.cs

Em Program.cs , registre os serviços com o contêiner de injeção de dependência:

 using Microsoft . Extensions . DependencyInjection ;

 var builder = WebApplication . CreateBuilder ( args ) ;
 
// Adicione serviços ao contêiner.
 construtor . Serviços . Configurar < AppSettings > ( construtor . Configuração ) ; 
construtor . Serviços . AddSingleton < ElasticsearchService > ( ) ; 
construtor . Serviços . AddSingleton < OpenAIService > ( ) ;
 
construtor . Serviços . AddControllers ( ) ;
 construtor . Serviços . AddEndpointsApiExplorer ( ) ; 
construtor . Serviços . AddSwaggerGen ( ) ;

 var app = construtor . Construir ( ) ;

 // Configure o pipeline de solicitação HTTP. 
se ( app . Ambiente . ÉDesenvolvimento ( ) )
 {
 aplicativo . UseSwagger ( ) ; 
aplicativo . UseSwaggerUI ( ) ;
 }

 aplicativo . UseHttpsRedirection ( ) ;
 
aplicativo . UseAuthorization ( ) ;

 aplicativo . MapControllers ( ) ;

 aplicativo . Executar ( ) ;

a) Explicação detalhada

• Configurar : Mapeia as definições de configuração de appsettings.json para o AppSettings aula.

• Adicionar Singleton () e Adicionar Singleton () : Registra os serviços como singletons, garantindo que uma única instância de cada serviço seja usada durante todo o ciclo de vida do aplicativo.

• MapControllers() : Configura o roteamento para direcionar solicitações HTTP aos controladores apropriados.

8. Executando o aplicativo

Para executar o aplicativo, use o seguinte comando:

 dotnet run
 

Agora você pode acessar o ponto final GET /api/search/ask?question=your_question . Este endpoint recupera informações relevantes do Elasticsearch e usa o OpenAI para gerar uma resposta com base no contexto.

9. Compreendendo o fluxo de trabalho do aplicativo

a) Fluxo de trabalho da API

1. Recebendo a pergunta : O usuário envia uma solicitação GET para o /api/search/ask ponto final, passando uma pergunta como uma string de consulta.

2. Pesquisa Elasticsearch :

   • A questão é enviada para o ElasticsearchService .
   • Este serviço pesquisa os índices especificados (neste caso, search-olx ) usando um MultiMatch consulta sobre o body_content e title campos.
   • Os resultados mais relevantes (até 3) são retornados e convertidos em uma lista de SearchResult objetos.

3. Geração de Contexto :

   • O conteúdo dos documentos recuperados é combinado em uma única string ( context ).
   • Esta sequência representa o contexto que será usado para responder à pergunta.

4. Gerando uma resposta com OpenAI :

   • O contexto combinado é passado para o OpenAIService junto com a pergunta original.
   • O OpenAIService cria a conversa com o OpenAI e fornece o contexto como parte da entrada. O OpenAI então gera uma resposta com base no contexto e na pergunta do usuário.

5. Retornando a resposta :

   • A resposta gerada pelo OpenAI é retornada ao usuário no corpo da resposta HTTP.

b) Benefícios da Arquitetura

• Modularidade : O código é bem modularizado, com responsabilidades separadas entre serviços, controladores e configurações. Isso torna mais fácil manter e estender o aplicativo no futuro.

• Escalabilidade : Tanto o Elasticsearch quanto o OpenAI são serviços escaláveis. Esta solução pode lidar com grandes volumes de dados e solicitações, desde que os recursos do servidor sejam dimensionados adequadamente.

• Segurança : as chaves da API são armazenadas com segurança no appsettings.json arquivo. Para maior segurança em um ambiente de produção, considere usar segredos de usuário ou um serviço de gerenciamento de segredos.

• Flexibilidade : a API pode ser facilmente adaptada a diferentes índices do Elasticsearch ou tipos de perguntas, modificando a lógica de pesquisa ou as instruções passadas para o OpenAI.

c) Considerações de desempenho

• Limitação de resultados : o código limita o número de resultados do Elasticsearch a 3. Dependendo do aplicativo, você pode ajustar esse limite para melhorar o desempenho ou fornecer mais contexto ao OpenAI.

• Tempo de resposta : Como o processo envolve chamadas para Elasticsearch e OpenAI, o tempo de resposta da API pode variar. Para aplicativos críticos, você pode considerar implementar cache, otimizar consultas do Elasticsearch ou até mesmo pré-processar dados.

d) Extensões potenciais

• Recursos de pesquisa aprimorados : você pode melhorar as consultas do Elasticsearch adicionando filtros, agregações ou campos mais relevantes, dependendo do seu caso de uso.

• Refinamento de contexto : O método de construção do contexto pode ser refinado. Por exemplo, você pode adicionar mais metadados ao contexto, como títulos, datas ou outras informações úteis.

• Adicionando autenticação : se você estiver criando uma API pública ou protegida, considere adicionar autenticação e autorização usando JWT ou OAuth.

• Monitoramento e registro : implementar registro robusto e monitoramento de desempenho ajudará você a identificar gargalos e melhorar a eficiência da API.

• Integração de banco de dados : dependendo de suas necessidades, você pode integrar o aplicativo com bancos de dados relacionais ou NoSQL para armazenar informações adicionais ou executar operações de dados complexas que não são ideais para o Elasticsearch.

10. Conclusão

Neste artigo, exploramos como integrar o Elasticsearch e o OpenAI em uma ASP.NET Core Web API. Esta configuração permite que você crie um sistema poderoso capaz de recuperar dados do Elasticsearch e gerar respostas sensíveis ao contexto usando o OpenAI.

O exemplo fornecido oferece um ponto de partida sólido para a construção de aplicativos mais complexos que exigem recursos avançados de recuperação de dados e processamento de linguagem natural. Não importa se você está desenvolvendo ferramentas de suporte ao cliente, assistentes virtuais ou sistemas de recomendação, essa abordagem fornece a modularidade, a escalabilidade e a flexibilidade necessárias para crescer e se adaptar conforme seus requisitos evoluem.

Com uma compreensão clara do fluxo de trabalho do aplicativo, considerações de desempenho e extensões potenciais, você está bem equipado para desenvolver e personalizar ainda mais sua API para atender a casos de uso específicos. Essa combinação de Elasticsearch e OpenAI em uma ASP.NET Core Web API abre uma ampla gama de possibilidades para criar aplicativos inteligentes e responsivos.