Desenvolvendo um Assistente Virtual com Genie: Integração Prática de Frameworks como Rasa e OpenAI na Criação de Chatbots Inteligentes

Introdução

Neste tutorial, abordaremos o desenvolvimento de um assistente virtual utilizando o Genie, um framework robusto que facilita a criação de chatbots inteligentes. Apesar de o foco principal ser a integração com Rasa e OpenAI, exploraremos como implementar esses frameworks em uma aplicação Java utilizando o Spring Boot. Através deste passo a passo, você aprenderá a construir, configurar e testar um chatbot capaz de interagir de forma natural utilizando técnicas de Processamento de Linguagem Natural (PNL). Este guia é ideal para desenvolvedores que desejam criar soluções de IA interativas e personalizáveis.

Etapas

Configuração do Ambiente de Desenvolvimento
Garanta que você tenha o JDK (Java Development Kit) e o Maven instalados em sua máquina. Você pode verificar se estão instalados utilizando os comandos `java -version` e `mvn -version`. Se não tiver os instalados, siga as instruções de instalação disponíveis nos sites oficiais.
commands
```
# Verificar versões instaladas
java -version
mvn -version
```

Criação do Projeto Spring Boot

Utilize o [Spring Initializr](https://start.spring.io/) para gerar um novo projeto Spring Boot. Selecione as opções: **Project**: Maven, **Language**: Java, **Spring Boot**: última versão estável, **Packaging**: Jar, **Java**: 11 ou superior. Inclua as dependências ‘Spring Web’, ‘Spring Boot DevTools’ e ‘Spring Boot Starter Test’.

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>assistente-virtual</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>assistente-virtual</name>
  <description>Assistente Virtual com Genie e OpenAI</description>
  <properties>
    <java.version>11</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
      <scope>runtime</scope>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

Configuração das Dependências do Genie

Adicione as dependências necessárias para o Genie e o Rasa, além da client HTTP para comunicar-se com a API OpenAI. No arquivo `pom.xml`, inclua as seguintes dependências:

pom.xml


    <dependency>
      <groupId>com.ai.genie</groupId>
      <artifactId>genie</artifactId>
      <version>1.0.0</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-json</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.httpcomponents</groupId>
      <artifactId>httpclient</artifactId>
      <version>4.5.13</version>
    </dependency>

Criação da Classe para Interagir com a API OpenAI

Implemente uma classe `OpenAIService` que será responsável por enviar requisições para a API OpenAI e receber respostas. Esta classe utilizará `HttpClient` para comunicação.

OpenAIService.java

package com.example.assistentevirtual.service;

import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.stereotype.Service;

@Service
public class OpenAIService {
    private final String API_KEY = "YOUR_OPENAI_API_KEY";

    public String sendMessage(String message) throws Exception {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpPost postRequest = new HttpPost("https://api.openai.com/v1/chat/completions");
        postRequest.setHeader("Content-Type", "application/json");
        postRequest.setHeader("Authorization", "Bearer " + API_KEY);

        String json = "{\"model\": \"gpt-3.5-turbo\", \"messages\": [\{"role\": \"user\", \"content\": \"" + message + "\"}\]}";
        postRequest.setEntity(new StringEntity(json));

        return EntityUtils.toString(httpClient.execute(postRequest).getEntity());
    }
}

Implementação do Controlador do Chatbot

Escreva uma classe `ChatbotController` responsável por receber as mensagens do usuário e se comunicar com o serviço OpenAI. Essa classe exporá um endpoint REST que receberá as mensagens.

ChatbotController.java

package com.example.assistentevirtual.controller;

import com.example.assistentevirtual.service.OpenAIService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/chatbot")
public class ChatbotController {
    @Autowired
    private OpenAIService openAIService;

    @PostMapping("/message")
    public String getMessage(@RequestBody String message) throws Exception {
        return openAIService.sendMessage(message);
    }
}

Testes Unitários da Integração com OpenAI

Crie uma classe `OpenAIServiceTest` para realizar testes unitários do serviço OpenAI para garantir que a integração está funcionando corretamente.

OpenAIServiceTest.java

package com.example.assistentevirtual.service;

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

class OpenAIServiceTest {
    @InjectMocks
    private OpenAIService openAIService;

    @BeforeEach
    void init() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    void testSendMessage() throws Exception {
        String response = openAIService.sendMessage("Olá, assistente!");
        assertNotNull(response);
        // Verifique se a resposta contém a mensagem esperada ou outros critérios
    }
}

Executando a Aplicação e Testes

Utilize o Maven para compilar e executar a aplicação. Em seguida, use ferramentas como Postman ou cURL para testar os endpoints da API do chatbot.

commands

# Para compilar e executar a aplicação
mvn spring-boot:run
# Para executar os testes unitários
mvn test
# Exemplo de uso com cURL para enviar mensagem
curl -X POST -H "Content-Type: application/json" -d '{"message":"Olá, assistente!"}' http://localhost:8080/api/chatbot/message

Conclusão

Neste tutorial, você aprendeu a desenvolver um assistente virtual utilizando o Genie, integrando os frameworks Rasa e OpenAI. Através de uma aplicação Spring Boot, criamos um serviço capaz de processar mensagens e fornecer respostas inteligentes. Com este conhecimento, você pode aprimorar suas habilidades no desenvolvimento de chatbots e expandir suas aplicações ao integrar outras tecnologias e funcionalidades.

Hashtags

#Java #SpringBoot #Chatbots #OpenAI #Rasa #DesenvolvimentoDeSoftware

copycoda.com.br