DEV Community: Herbert Beckman

Agente de IA confiável em prod com Java + Quarkus + Langchain4j - Parte 2 - Memória

Herbert Beckman — Tue, 12 Nov 2024 16:58:07 +0000

Autores

@herbertbeckman - LinkedIn
@rndtavares - LinkedIn

Partes do artigo

Agente de IA confiável em prod com Java + Quarkus + Langchain4j - Parte 1 - AI as Service
Agente de IA confiável em prod com Java + Quarkus + Langchain4j - Parte 2 - Memória (este artigo)
Agente de IA confiável em prod com Java + Quarkus + Langchain4j - Parte 3 - RAG (em breve)
Agente de IA confiável em prod com Java + Quarkus + Langchain4j - Parte 4 - Guardrails (em breve)

Introdução

Quando criamos um agente, devemos ter em mente que os LLMs não guardam nenhum tipo de informação, ou seja, são stateless. Para que o nosso agente tenha a capacidade de se "lembrar" das informações, devemos implementar o gerenciamento de memória. O Quarkus já nos entrega uma memória padrão configurada, o porém disso é que ela pode literalmente derrubar o seu agente estourando a memória ram disponibilizada pra ele, como descrito nesta documentação do Quarkus, caso não se tome os devidos cuidados. Pra não termos mais esse problema e também para que seja possível utilizarmos nosso agente em um ambiente de escalabilidade, precisamos de um ChatMemoryStore.

Conceitos

Utilizamos um chat para interagir com o nosso agente e há conceitos importantes que devemos conhecer para que a nossa interação com ele possa ocorrer da melhor forma possível e não ocasione bugs em produção. Primeiramente precisamos conhecer os tipos de mensagens que utilizamos na hora de interagir com ele, são eles:

Mensagens do usuário (UserMessage): A mensagem ou solicitação enviada pelo cliente final. Quando enviamos a mensagem no DevUI do quarkus, sempre estamos enviando uma UserMessage. Além disso, ela também é utilizada nos resultados de chamadas das ferramentas (tools) que vimos antes.
Mensagens da IA (AiMessage): A mensagem de resposta do modelo. Sempre que o LLM responder pro nosso agente, ele receberá uma mensagem desse tipo. Este tipo de mensagem fica alternando o seu conteúdo entre uma resposta textual e solicitações de execução de ferramentas (tools).
Mensagem do Sistema (SystemMessage): Esta mensagem pode ser definida somente 1 vez e é somente em tempo de desenvolvimento.

Agora que você conhece os 3 tipos de mensagens que temos, vamos explicar como elas devem se comportar com alguns gráficos. Todos os gráficos foram tirados da apresentação Java meets AI: Build LLM-Powered Apps with LangChain4j by Deandrea, Andrianakis, Escoffier, recomendo demais o vídeo.

O primeiro gráfico demonstra o uso dos 3 tipos de mensagens. UserMessage em azul, SystemMessage em vermelho e AiMessage em verde.

Neste segundo gráfico, demonstra-se como que a "memória" deve ser gerenciada. Um detalhe interessante é que devemos manter uma certa ordem nas mensagens e algumas premissas devem ser respeitadas.

Só deve existir 1 mensagem do tipo SystemMessage;
Após a SystemMessage, as mensagens sempre devem alternar entre UserMessage e AiMessage, nesta ordem. Se tivermos uma AiMessage após outra AiMessage, tomaremos uma exceção. O mesmo vale pra UserMessage seguidas.

Outro detalhe importante que você deve se atentar é sobre o tamanho do seu ChatMemory. Quanto maior a memória da sua interação, maior os custos com tokens, pois o LLM precisará processar mais texto pra dar uma resposta. Então estabeleça uma janela de memória que melhor se adequar pro seu caso de uso. Uma dica é verificar a média de mensagens dos seus clientes para ter uma ideia de tamanho de interação. Iremos mostrar a implementação através da MessageWindowChatMemory, a classe especializada em gerenciar isso pra gente no Langchain4j.

Agora que conhecemos todos esses conceitos e premissas, vamos por a mão na massa!

Configurando nosso `ChatMemoryStore`

Aqui vamos utilizar o MongoDB como um ChatMemoryStore. Utilizamos a doc do MongoDB e subimos uma instância no docker. Sinta-se a vontade pra configurar ele como bem desejar.

Adicionando nossa conexão com o MongoDB

Vamos iniciar adicionando a dependência necessária para termos uma conexão com o MongoDB utilizando o Quarkus.

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-mongodb-panache</artifactId>
</dependency>

Após as dependências, precisamos adicionar as configurações de conexão no nosso src/main/resources/application.properties.

quarkus.mongodb.connection-string=mongodb://${MONGODB_USER}:${MONGODB_PASSWORD}@localhost:27017
quarkus.mongodb.database=chat_memory

Ainda não iremos conseguir testar a nossa conexão com a base, pois antes precisamos criar nossas entidades e repositórios.

Criando nossa entidade e nosso repositório

Agora vamos implementar nossa entidade Interaction. Essa entidade terá a nossa lista de mensagens realizadas. Sempre que um cliente novo se conectar, será gerada uma nova Interaction. Se precisarmos reaproveitar essa Interaction, basta informamos o mesmo identificador da Interaction.

package <seupacote>;

import dev.langchain4j.data.message.ChatMessage;
import io.quarkus.mongodb.panache.common.MongoEntity;
import org.bson.codecs.pojo.annotations.BsonId;

import java.util.List;
import java.util.Objects;

@MongoEntity(collection = "interactions")
public class InteractionEntity {

    @BsonId
    private String interactionId;
    private List<ChatMessage> messages;

    public InteractionEntity() {
    }

    public InteractionEntity(String interactionId, List<ChatMessage> messages) {
        this.interactionId = interactionId;
        this.messages = messages;
    }

    public String getInteractionId() {
        return interactionId;
    }

    public void setInteractionId(String interactionId) {
        this.interactionId = interactionId;
    }

    public List<ChatMessage> getMessages() {
        return messages;
    }

    public void setMessages(List<ChatMessage> messages) {
        this.messages = messages;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        InteractionEntity that = (InteractionEntity) o;
        return Objects.equals(interactionId, that.interactionId);
    }

    @Override
    public int hashCode() {
        return Objects.hash(interactionId, messages);
    }
}

Podemos agora criar o nosso repositório.

package <seupacote>;

import dev.langchain4j.data.message.ChatMessage;
import io.quarkus.mongodb.panache.PanacheMongoRepositoryBase;

import java.util.List;

public class InteractionRepository implements PanacheMongoRepositoryBase<InteractionEntity, String> {

    public InteractionEntity findByInteractionId(String interactionId) {
        return findById(interactionId);
    }

    public void updateMessages(String interactionId, List<ChatMessage> messages) {
        persistOrUpdate(new InteractionEntity(interactionId, messages));
    }

    public void deleteMessages(String interactionId) {
        deleteById(interactionId);
    }

}

Agora iremos implementar alguns componentes do langchain4j, o ChatMemoryStore e o ChatMemoryProvider. O ChatMemoryProvider é a classe que utilizaremos no nosso Agent. Nele iremos adicionar uma ChatMemoryStore que irá utilizar nosso repositório para armazenar as mensagens no nosso MongoDB. Segue o ChatMemoryStore:

package <seupacote>;

import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.store.memory.chat.ChatMemoryStore;

import java.util.List;
import java.util.Objects;

public class MongoDBChatMemoryStore implements ChatMemoryStore {

    private InteractionRepository interactionRepository = new InteractionRepository();

    @Override
    public List<ChatMessage> getMessages(Object memoryId) {
        var interactionEntity = interactionRepository.findByInteractionId(memoryId.toString());
        return Objects.isNull(interactionEntity) ? List.of() : interactionEntity.getMessages();
    }

    @Override
    public void updateMessages(Object memoryId, List<ChatMessage> messages) {
        interactionRepository.updateMessages(memoryId.toString(), messages);
    }

    @Override
    public void deleteMessages(Object memoryId) {
        interactionRepository.deleteMessages(memoryId.toString());
    }
}

O ChatMemoryProvider ficará desse jeito:

package <seupacote>;

import dev.langchain4j.memory.chat.ChatMemoryProvider;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;

import java.util.function.Supplier;

public class MongoDBChatMemoryProvider implements Supplier<ChatMemoryProvider> {

    private MongoDBChatMemoryStore mongoDBChatMemoryStore = new MongoDBChatMemoryStore();

    @Override
    public ChatMemoryProvider get() {
        return memoryId -> MessageWindowChatMemory.builder()
                .maxMessages(100)
                .id(memoryId)
                .chatMemoryStore(mongoDBChatMemoryStore)
                .build();
    }
}

Repare no MessageWindowChatMemory. É nele que implementamos a janela de mensagens que mencionamos no começo do artigo. No método maxMessages(), você deve alterar pro número que achar melhor pro seu cenário. O que recomendo é utilizar o maior número de mensagens que já existiu no seu cenário, ou utilizar a média. Aqui definimos o número arbitrário 100.

Vamos agora alterar o nosso agente para utilizar o nosso ChatMemoryProvider novo e adicionar MemoryId. Ele deve ficar assim:

package <seupacote>;

import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import io.quarkiverse.langchain4j.RegisterAiService;
import io.quarkiverse.langchain4j.ToolBox;
import jakarta.enterprise.context.ApplicationScoped;

@ApplicationScoped
@RegisterAiService(
        chatMemoryProviderSupplier = MongoDBChatMemoryProvider.class
)
public interface Agent {

    @ToolBox(AgentTools.class)
    @SystemMessage("""
            Você é um agente especializado em futebol brasileiro, seu nome é FutAgentBR
            Você sabe responder sobre os principais títulos dos principais times brasileiros e da seleção brasileira
            Sua resposta precisa ser educada, você pode deve responder em Português brasileiro e de forma relevante a pergunta feita

            Quando você não souber a resposta, responda que você não sabe responder nesse momento mas saberá em futuras versões.
            """)
    String chat(@MemoryId String interactionId, @UserMessage String message);
}

Isso deve quebrar o nosso AgentWSEndpoint. Vamos alterá-lo para que ele receba o identificador da Interaction e possamos utilizar como nosso MemoryId:

package <seupacote>;

import io.quarkus.websockets.next.OnTextMessage;
import io.quarkus.websockets.next.WebSocket;
import io.quarkus.websockets.next.WebSocketConnection;
import jakarta.inject.Inject;

import java.util.Objects;
import java.util.UUID;

@WebSocket(path = "/ws/{interactionId}")
public class AgentWSEndpoint {

    private final Agent agent;

    private final WebSocketConnection connection;

    @Inject
    AgentWSEndpoint(Agent agent, WebSocketConnection connection) {
        this.agent = agent;
        this.connection = connection;
    }

    @OnTextMessage
    String reply(String message) {
        var interactionId = connection.pathParam("interactionId");
        return agent.chat(
                Objects.isNull(interactionId) || interactionId.isBlank()
                        ? UUID.randomUUID().toString()
                        : interactionId,
                message
        );
    }

}

Já podemos testar o nosso agente novamente. Para isso basta conectar-mos no websocket passando um UUID sempre que quisermos. Você pode gerar um novo UUID aqui, ou utilizar o comando uuidgen no linux.

Ao realizarmos o teste você não receberá resposta alguma do agente. Isso acontece por quê o agente está tendo problemas ao gravar nossas mensagens no MongoDB e ele te mostrará isso através de uma exceção. Para que possamos verificar essa exceção acontecendo, devemos incluir uma nova propriedade no nosso src/main/resources/application.properties, que é o nível do log que queremos ver no Quarkus. Então, adicione a seguinte linha nele:

quarkus.log.level=DEBUG

Agora teste o agente. A exceção deve ser essa:

DEBUG [io.qua.web.nex.run.Endpoints] (vert.x-eventloop-thread-1) Connection closed due to unhandled failure org.bson.codecs.configuration.CodecConfigurationException: An exception occurred when encoding using the AutomaticPojoCodec.

Essa exceção ocorre porque o MongoDB não consegue lidar com a interface ChatMessage do Langchain4j, então devemos implementar um codec pra que isso seja possível. O próprio Quarkus já nos oferece um codec, mas precisamos deixar explicito que queremos utilizar ele. Criaremos então as classes ChatMessageCodec e ChatMessageCodecProvider como segue:

package <seupacote>;

import com.mongodb.MongoClientSettings;
import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.data.message.ChatMessageJsonCodec;
import io.quarkiverse.langchain4j.QuarkusChatMessageJsonCodecFactory;
import org.bson.BsonReader;
import org.bson.BsonValue;
import org.bson.BsonWriter;
import org.bson.Document;
import org.bson.codecs.Codec;
import org.bson.codecs.CollectibleCodec;
import org.bson.codecs.DecoderContext;
import org.bson.codecs.EncoderContext;

public class ChatMessageCodec implements CollectibleCodec<ChatMessage> {

    private final Codec<Document> documentCodec;
    private final ChatMessageJsonCodec chatMessageJsonCodec;

    public ChatMessageCodec() {
        this.documentCodec = MongoClientSettings.getDefaultCodecRegistry().get(Document.class);
        this.chatMessageJsonCodec = new QuarkusChatMessageJsonCodecFactory().create();
    }

    @Override
    public ChatMessage generateIdIfAbsentFromDocument(ChatMessage document) {
        return document;
    }

    @Override
    public boolean documentHasId(ChatMessage document) {
        return false;
    }

    @Override
    public BsonValue getDocumentId(ChatMessage document) {
        return null;
    }

    @Override
    public ChatMessage decode(BsonReader reader, DecoderContext decoderContext) {
        var document = documentCodec.decode(reader, decoderContext);
        return this.chatMessageJsonCodec.messageFromJson(document.toJson());
    }

    @Override
    public void encode(BsonWriter writer, ChatMessage value, EncoderContext encoderContext) {
        var json = this.chatMessageJsonCodec.messageToJson(value);
        var doc = Document.parse(json);
        documentCodec.encode(writer, doc, encoderContext);
    }

    @Override
    public Class<ChatMessage> getEncoderClass() {
        return ChatMessage.class;
    }
}

package <seupacote>;

import dev.langchain4j.data.message.ChatMessage;
import org.bson.codecs.Codec;
import org.bson.codecs.configuration.CodecProvider;
import org.bson.codecs.configuration.CodecRegistry;

public class ChatMessageCodecProvider implements CodecProvider {

    @Override
    public <T> Codec<T> get(Class<T> clazz, CodecRegistry registry) {
        if (clazz == ChatMessage.class) {
            return (Codec<T>) new ChatMessageCodec();
        }
        return null;
    }

}

Pronto! Agora podemos testar e verificar as mensagens no nosso MongoDB. Ao consultarmos, podemos verificar os 3 tipos de mensagens no array messages do documento.

Isso encerra a segunda parte da nossa série. Esperamos que tenham gostado e até a parte 3.

Agente de IA confiável em prod com Java + Quarkus + Langchain4j - Parte 1 - AI as Service

Herbert Beckman — Fri, 25 Oct 2024 17:48:11 +0000

Autores

@herbertbeckman - LinkedIn
@rndtavares - LinkedIn

Partes do artigo

Agente de IA confiável em prod com Java + Quarkus + Langchain4j - Parte 1 - AI as Service (este artigo)
Agente de IA confiável em prod com Java + Quarkus + Langchain4j - Parte 2 - Memória (em breve)
Agente de IA confiável em prod com Java + Quarkus + Langchain4j - Parte 3 - RAG (em breve)
Agente de IA confiável em prod com Java + Quarkus + Langchain4j - Parte 4 - Guardrails (em breve)

Introdução

Sempre que temos um "boom" de uma tecnologia emergente, as empresas ficam ansiosas por aplicá-las e colher os resultados tão esperados do ponto de vista do negócio. É a corrida pela inovação e a disputa pelas vantagens do pioneirismo. No meio dessa corrida, muitas das vezes, as empresas, que antes estavam ansiosas, acabam desistindo por uma série de fatores, sendo um dos principais a confiabilidade de um sistema de forma geral. A inteligencia artificial (IA) está neste momento em uma das suas maiores provas de resistência e nosso trabalho como desenvolvedores de softwares é demostrar as empresas que sim, é possível realizar uma série de tarefas e processos com o uso consciente e correto da IA. Neste artigo iremos demonstrar, em 3 partes, quais são as funcionalidades e processos que devemos ter em um agente de IA confiável em produção para uma empresa ter os tão esperados resultados, bem como implementarmos juntos alguns conceitos utilizados no mercado. Iremos também detalhar os pontos de atenção desta solução e pedimos para que você, dev, realize o máximo de testes e nos dê o maior número de feedbacks possíveis para que, juntos, possamos melhorar ainda mais esse entendimento.

Funcionalidades Implementadas

Chat
Tools
Chat Memory
Retrieval-Augmented Generation (RAG)
Guardrails

Conceitos e definições

Assistente vs Copiloto vs Agente

Uma das primeiras dúvidas que se pode ter é no que um agente se diferencia dos demais casos de uso da IA. O Agente tem funcionalidades mais ligadas pra automação, enquantos os outros tem suas atividades voltadas à finalidade de assistentcia e otimização do tempo. Abaixo detalho melhor cada um dos casos de uso.

Assistentes

Os assistentes conseguem nos auxiliar e economizar um bom tempo verificando informação e sendo uma boa fonte de troca de conhecimento. Eles falam SOBRE os assuntos mais variados e podem nos ser úteis quando precisamos de uma linha de raciocínio claro para analisar as premisas de uma argumentação. Claro, eles tem bem mais poderes que isso, mas quero que você foque no que um assistente faz: ele conversa com você e somente isso. Ele SÓ pode falar sobre, sumarizar, detalhar, etc. Como exemplos temos: ChatGPT, Claude AI e Gemini.

Copilotos

Já os copilotos são um pouco mais poderosos que os assistentes. Eles conseguem realmente fazer algo, uma ação mais concreta como alterar um texto e ou sugerir modificações em tempo real, bem como dar dicas durante uma modificação e/ou evento acontecendo dentro de um contexto. Porém, como dito antes, ele depende do contexto pra fazer isso e nem sempre ele tem todas as informações necessárias para realizar um boa sugestão, ele também depende de sua autorização expressa, criando uma dependência direta com o usuário. Exemplos bons são: Github Copilot, Codium e Microsoft Copilot.

Agentes

Os agentes tem como objetivo principal realizar tarefas com objetivos claros. Tem o seu foco na automatização, ou seja, eles realmente fazem concreto e de forma autônoma. Tudo isso só se faz possível através das ferramentas que disponibilizamos a eles. O Agente não é o LLM em si, mas sim a sua aplicação que coordena esse LLM. Entenda o LLM como o cérebro do sistema, que toma as decisões, e a sua aplicação como os membros do corpo desse cérebro. Do que adianta eu pensar em pegar um copo de água se não consigo alcançá-lo com a minha mão? O seu agente proporciona ao LLM o poder de fazer algo de forma segura, auditável e, principalmente, confiável.

Partindo pra ação

Nesta primeira parte do artigo iremos implementar o AIService no projeto, que nada mais é do que a camada de interface com o nosso provedor de IA. Nesse projeto utilizamos o LLM da OpenAI, mas vc pode adicionar o seu provedor favorito e ajustar as dependências com base nele.

Agora que temos os conceitos bem definidos e já sabemos o que iremos fazer aqui, vamos pra codificação!

Criando o projeto

Crie um projeto quarkus, escolhendo o seu gerenciador de dependências e as extensões em Quarkus - Start coding.

Dependencias do projeto

Iremos utilizar o maven como gerenciador de dependências do projeto. A seguir as dependências iniciais que adicionamos.

Mavem

<dependency>
  <groupId>io.quarkus</groupId>
  <artifactId>quarkus-websockets-next</artifactId>
</dependency>

<dependency>
  <groupId>io.quarkiverse.langchain4j</groupId>
  <artifactId>quarkus-langchain4j-core</artifactId>
  <version>0.20.3</version>
</dependency>

<dependency>
  <groupId>io.quarkiverse.langchain4j</groupId>
  <artifactId>quarkus-langchain4j-openai</artifactId>
  <version>0.20.3</version>
</dependency>

Configuração do projeto

Adicione no arquivo src/main/resources/application.properties as seguintes propriedades:

quarkus.tls.trust-all=true
quarkus.langchain4j.timeout=60s
quarkus.langchain4j.openai.api-key=YOUR_OPENAI_API_KEY_HERE

Substitua YOUR_OPENAPI_KEY_HERE pela chave (apiKey) que você cadastrou na Plataforma da OpenAI.

DICA: crie uma variável de ambiente na sua IDE e depois modifique a property quarkus.langchain4j.openai.api-key para:

quarkus.langchain4j.openai.api-key=${OPEN_API_KEY:NAO_ENCONTREI_A_VAR}

Criando o nosso AIService

Primeiramente precisamos criar o nosso AIService que será a classe responsável por dar uma "personalidade" ao nosso agente. Para isso, no diretório src/main/java/<seupacote>, criaremos a classe de nome Agent com o seguinte código:

package <seupacote>;

import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import io.quarkiverse.langchain4j.RegisterAiService;
import jakarta.enterprise.context.ApplicationScoped;

@ApplicationScoped
@RegisterAiService
public interface Agent {

    @SystemMessage("""
            Você é um agente especializado em futebol brasileiro, seu nome é FutAgentBR
            Você sabe responder sobre os principais títulos dos principais times brasileiros e da seleção brasileira
            Sua resposta precisa ser educada, você pode deve responder em Português brasileiro e de forma relevante a pergunta feita

            Quando você não souber a resposta, responda que você não sabe responder nesse momento mas saberá em futuras versões.
            """)
    String chat(@UserMessage String message);
}

Como podem perceper pelo nosso SystemPrompt (@SystemMessage), criamos um agente especializado em futebol.

Criando o nosso chat

Agora que criamos o nosso agente, precisamos criar a classe que cuidará do nosso chat com ele. Para isso, no diretório src/main/java/<seupacote>, criaremos a classe de nome AgentWSEndpoint com o seguinte código:

package <seupacote>;

import io.quarkus.websockets.next.OnTextMessage;
import io.quarkus.websockets.next.WebSocket;

@WebSocket(path = "/ws")
public class BotWSEndpoint {

    private final Agent agent;

    BotWSEndpoint(Agent agent) {
        this.agent = agent;
    }

    @OnTextMessage
    String reply(String message) {
        return agent.chat(message);
    }

}

Agora você já consegue conversar com o seu agente, que no momento ainda é um assistente, através da dev ui do quarkus. Segue alguns prints pra você se orientar:

Adicionando as nossas ferramentas (Function Calling)

Agora vamos para o detalhe que faz toda a diferença entre um agente e um assistente. Vamos dar a possibilidade do nosso agente realizar tarefas e/ou processos, adicionando as ferramentas (function calling). Antes de codificarmos isso, temos um breve gráfico demonstrando como a chamada de uma ferramenta funciona de forma macro.

Source: superface.ai

Agora que sabemos como uma chamada de ferramenta funciona, precisamos criar a classe com nossas ferramentas, você também pode criar várias classes diferentes para cada ferramenta. Neste exemplo iremos criar uma "ToolBox", ou seja, uma caixa de ferramentas, agrupando as ferramentas que o nosso agente pode utilizar. Segue o código:

package <seupacote>;

import dev.langchain4j.agent.tool.Tool;
import jakarta.enterprise.context.ApplicationScoped;

import java.time.LocalDate;
import java.time.LocalTime;

@ApplicationScoped
public class AgentTools {

    @Tool
    LocalDate currentDate() {
        System.out.println("Called currentDate()");
        return LocalDate.now();
    }

    @Tool
    LocalTime currentTime() {
        System.out.println("Called currentTime()");
        return LocalTime.now();
    }

    @Tool("Calcula a soma de dois números")
    int add(int a, int b) {
        System.out.println("Called add with a=" + a + ", b=" + b);
        return a + b;
    }

    @Tool("Calcula a raiz quadrada de um número")
    double sqrt(int x) {
        System.out.println("Called sqrt with x=" + x);
        return Math.sqrt(x);
    }
}

Logo em seguida, adicionamos no nosso agente o anotação informando pra ele quais ferramentas ele tem disponível para utilizar, através da anotação @ToolBox(AgentTools.class). Ficando da seguinte maneira:

package <seupacote>;

import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import io.quarkiverse.langchain4j.RegisterAiService;
import io.quarkiverse.langchain4j.ToolBox;
import jakarta.enterprise.context.ApplicationScoped;

@ApplicationScoped
@RegisterAiService
public interface Agent {

    @ToolBox(AgentTools.class)
    @SystemMessage("""
            Você é um agente especializado em futebol brasileiro, seu nome é FutAgentBR
            Você sabe responder sobre os principais títulos dos principais times brasileiros e da seleção brasileira
            Sua resposta precisa ser educada, você pode deve responder em Português brasileiro e de forma relevante a pergunta feita

            Quando você não souber a resposta, responda que você não sabe responder nesse momento mas saberá em futuras versões.
            """)
    String chat(@UserMessage String message);
}

Agora você pode perguntar ao seu agente que horas são, qual é a data de hoje, pedir pra ele somar dois números e calcular a raiz quadrada. Essas são as ferramentas que utilizamos aqui para ilustrar, mas você pode substituir isso por uma chamada HTTP, por uma função de hashing, por uma query SQL, etc. As possibilidades aqui são muitas.

Testando via Quarkus DEV UI

Segue o print de um dos testes realizados após adicionar as ferramentas:

Como pode ver, pra cada chamada de ferramenta teremos um log, evidenciando que o LLM realmente chamou o código que autorizamos ele a executar.

Próximos passos

Isso encerra o início da criação no nosso Agente. Em breve adicionaremos memória ao nosso Agente na parte 2, o RAG (Retrieval-Augmented Generation) na parte 3 e os Guardrails na parte 4 deste artigo. Espero que tenham gostado e até breve.

Mas você pode já acompanhar e ver TODO o código do artigo neste repositório do GitHub.

DEV Community: Herbert Beckman

Agente de IA confiável em prod com Java + Quarkus + Langchain4j - Parte 2 - Memória

Autores

Partes do artigo

Introdução

Conceitos

Configurando nosso ChatMemoryStore

Adicionando nossa conexão com o MongoDB

Criando nossa entidade e nosso repositório

Agente de IA confiável em prod com Java + Quarkus + Langchain4j - Parte 1 - AI as Service

Autores

Partes do artigo

Introdução

Funcionalidades Implementadas

Conceitos e definições

Assistente vs Copiloto vs Agente

Assistentes

Copilotos

Agentes

Partindo pra ação

Criando o projeto

Dependencias do projeto

Mavem

Configuração do projeto

Criando o nosso AIService

Criando o nosso chat

Adicionando as nossas ferramentas (Function Calling)

Testando via Quarkus DEV UI

Próximos passos

Configurando nosso `ChatMemoryStore`