Comienza a usar la integración de LangChain4j

Crea una nueva aplicación Java.

1. Abra su IDE y cree un nuevo proyecto Java y configure la siguiente configuración:

   • Nombre: LangChain4jSampleApp

   • Lenguaje: Java

   • Sistema de compilación: Maven

   • JDK: Cualquier versión superior a 8

   Es posible que veas una opción para incluir un código de muestra. Seleccionar esta opción puede ayudarte a comprobar que tu entorno funciona y localizar el archivo de aplicación que editas en los siguientes pasos.

Agrega dependencias.

1. Agregue las siguientes dependencias al arreglo dependencies en su archivo pom.xml del proyecto. Estas dependencias agregan las librerías LangChain4j, Voyage IA API para LangChain4j y MongoDB Java Sync Driver a tu aplicación:

   pom.xml

   <dependency>
       <groupId>dev.langchain4j</groupId>
       <artifactId>langchain4j-mongodb-atlas</artifactId>
       <version>1.1.0</version>
   </dependency>
   <dependency>
       <groupId>dev.langchain4j</groupId>
       <artifactId>langchain4j-voyage-ai</artifactId>
       <version>1.1.0-beta7</version>
   </dependency>

2. A continuación, añade una entrada dependencyManagement debajo de tu lista de dependencias para la Lista de Materiales (BOM) de LangChain4j:

   pom.xml

   <dependencyManagement>
       <dependencies>
           <dependency>
               <groupId>dev.langchain4j</groupId>
               <artifactId>langchain4j-bom</artifactId>
               <version>1.1.0</version>
               <type>pom</type>
               <scope>import</scope>
           </dependency>
       </dependencies>
   </dependencyManagement>

   Para obtener más información sobre la lista de materiales de LangChain4j, consulte la página Comenzar en la 4documentación de LangChain j.

   Cuando termines de editar el archivo pom.xml, vuelve a cargar tu proyecto para asegurarte de que tus dependencias estén instaladas.

Importar clases y métodos.

Localice el archivo de aplicación principal Main.java en su proyecto. Reemplace las importaciones existentes con la siguiente lista:

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import dev.langchain4j.data.document.Metadata;
import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.voyageai.VoyageAiEmbeddingModel;
import dev.langchain4j.store.embedding.EmbeddingMatch;
import dev.langchain4j.store.embedding.EmbeddingSearchRequest;
import dev.langchain4j.store.embedding.EmbeddingSearchResult;
import dev.langchain4j.store.embedding.filter.comparison.*;
import dev.langchain4j.store.embedding.mongodb.IndexMapping;
import dev.langchain4j.store.embedding.mongodb.MongoDbEmbeddingStore;
import org.bson.Document;
import java.io.*;
import java.util.*;

Más adelante en este tutorial, utilizarás estas clases y métodos para crear embeddings vectoriales y query datos.

Establecer variables de entorno.

Dependiendo de su IDE, puede haber varias maneras de configurar variables de entorno que su aplicación pueda recuperar. Para configurar variables de entorno en IntelliJ, debe crear una configuración de ejecución para su aplicación. Para obtener más información, consulte la sección "Sistema operativo" de la página "Configuración de ejecución/depuración: Aplicación" en la documentación de IntelliJ.

Configure las siguientes variables de entorno:

• MONGODB_URI: Establecido a su cadena de conexión de MongoDB.

• VOYAGE_AI_KEY: Establezca su clave de API de Voyage AI.

mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net/?<settings>

Recuperar variables de entorno.

Recupera tus variables de entorno añadiendo el siguiente código dentro del método principal en el archivo Main.java de tu aplicación:

String embeddingApiKey = System.getenv("VOYAGE_AI_KEY");
String uri = System.getenv("MONGODB_URI");

Realiza una búsqueda semántica.

Este código realiza una query de búsqueda semántica para la frase "Where do penguins live?" y devuelve los tres resultados más relevantes. También imprime un puntaje que muestra qué tan bien cada resultado coincide con la query.

Agrega el siguiente código a tu archivo Main.java:

String query = "Where do penguins live?";
Embedding queryEmbedding = embeddingModel.embed(query).content();
EmbeddingSearchRequest searchRequest = EmbeddingSearchRequest.builder()
        .queryEmbedding(queryEmbedding)
        .maxResults(3)
        .build();
System.out.println("Performing the query...");
EmbeddingSearchResult<TextSegment> searchResult = embeddingStore.search(searchRequest);
List<EmbeddingMatch<TextSegment>> matches = searchResult.matches();
for (EmbeddingMatch<TextSegment> embeddingMatch : matches) {
    System.out.println("Response: " + embeddingMatch.embedded().text());
    System.out.println("Author: " + embeddingMatch.embedded().metadata().getString("author"));
    System.out.println("Score: " + embeddingMatch.score());
}

Response: Penguins are flightless seabirds that live almost exclusively below the equator. Some island-dwellers can be found in warmer climates.
Author: C
Score: 0.829620897769928
Response: Patagonia is home to five penguin species - Magellanic, Humboldt, Gentoo, Southern Rockhopper and King.
Author: B
Score: 0.7459062337875366
Response: Emperor penguins are the tallest and heaviest of all penguin species, standing up to 4 feet.
Author: D
Score: 0.6908764839172363

(Opcional) Ejecuta una búsqueda semántica con filtrado por metadatos.

Para realizar una búsqueda con filtro de metadatos, puedes utilizar las clases del paquete dev.langchain4j.store.embedding.filter.comparison. Estas clases te permiten crear filtros que comparan los valores de metadatos con los valores especificados para reducir los resultados devueltos por la búsqueda.

Este ejemplo filtra los documentos en los que el valor del campo author es "B" o "C". Luego, realiza una query de búsqueda semántica para la frase "Where do penguins live?".

Reemplace el código que crea una instancia EmbeddingSearchRequest en el paso anterior con el siguiente código:

EmbeddingSearchRequest searchRequest = EmbeddingSearchRequest.builder()
        .queryEmbedding(queryEmbedding)
        .filter(new IsIn("author", List.of("B", "C")))
        .maxResults(3)
        .build();

Response: Penguins are flightless seabirds that live almost exclusively below the equator. Some island-dwellers can be found in warmer climates.
Author: C
Score: 0.8520907163619995
Response: Patagonia is home to five penguin species - Magellanic, Humboldt, Gentoo, Southern Rockhopper and King.
Author: B
Score: 0.7666836977005005

Para obtener más información sobre el prefiltrado de metadatos, consulta MongoDB Vector Search.

Configura tu proyecto para RAG.

1. Agregue las siguientes dependencias a la dependencies matriz en el archivo de su pom.xml proyecto, pero no elimine ninguna de las dependencias ya agregadas. Estas dependencias agregan los4servicios de IA de LangChain j y la API de OpenAI para las bibliotecas de LangChain4j a su aplicación:

   pom.xml

   <dependency>
       <groupId>dev.langchain4j</groupId>
       <artifactId>langchain4j-open-ai</artifactId>
       <version>1.1.0</version>
   </dependency>
   <dependency>
       <groupId>dev.langchain4j</groupId>
       <artifactId>langchain4j</artifactId>
       <version>1.1.0</version>
   </dependency>

   Cuando termines de editar el archivo pom.xml, vuelve a cargar tu proyecto para asegurarte de que tus dependencias estén instaladas.

2. Agregue las siguientes importaciones a su lista de importaciones en su archivo Main.java:

   import com.fasterxml.jackson.core.type.TypeReference;
   import com.fasterxml.jackson.databind.ObjectMapper;
   import dev.langchain4j.service.AiServices;
   import dev.langchain4j.model.chat.ChatLanguageModel;
   import dev.langchain4j.model.openai.OpenAiChatModel;
   import dev.langchain4j.rag.content.retriever.ContentRetriever;
   import dev.langchain4j.rag.content.retriever.EmbeddingStoreContentRetriever;

3. Configure la variable de entorno OPENAI_KEY con su clave API de OpenAI. Utilice esta clave para crear un modelo de chat que genere una respuesta a su query.

Cargue los datos de muestra.

En este paso se ingresan datos externos en Atlas. Descarga el archivo de datos de muestra rainforest-docs.json desde el docs-code-examples repositorio de GitHub. Los documentos de este archivo contienen información sobre las plantas, animales y clima de la selva tropical.

Sube este archivo al directorio resources de tu proyecto, que se encuentra al mismo nivel que el directorio java que contiene los archivos de tu aplicación.

Debe procesar los datos en un formato utilizable que permita crear incrustaciones y conservarlas en Atlas. Este código define el método loadJsonDocuments(), que realiza las siguientes acciones:

• Recupera los datos de muestra de su directorio resources utilizando la clase ClassLoader

• Procesa los documentos JSON a un List de instancias Document de MongoDB usando la clase ObjectMapper

Agrega el siguiente código a tu archivo Main.java fuera de tu método principal:

private static List<Document> loadJsonDocuments(String resourcePath) throws IOException {
    // Loads file from resources directory using the ClassLoader
    InputStream inputStream = Main.class.getClassLoader().getResourceAsStream(resourcePath);
    if (inputStream == null) {
        throw new FileNotFoundException("Resource not found: " + resourcePath);
    }
    // Parses JSON file to List of MongoDB Documents
    ObjectMapper objectMapper = new ObjectMapper();
    List<Document> documents = objectMapper.readValue(inputStream, new TypeReference<>() {});
    return documents;
}

Luego, añade el siguiente código en el cuerpo del método principal para llamar al método loadJsonDocuments() y cargar tus documentos:

System.out.println("Loading documents from file...");
String resourcePath = "rainforest-docs.json";
List<Document> documents = loadJsonDocuments(resourcePath);

Almacena incrustaciones vectoriales en Atlas.

En este paso, creará incrustaciones vectoriales a partir de sus documentos de muestra y las conservará en Atlas.

Este código convierte el contenido de los campos text de los documentos de ejemplo en incrustaciones y conserva los datos en Atlas. El código incluye un retardo para adaptar el tiempo necesario para la conversión vectorial.

Agrega el siguiente código en tu archivo Main.java:

System.out.println("Persisting document embeddings...");
for (Document doc : documents) {
    TextSegment segment = TextSegment.from(
            doc.getString("text"),
            new Metadata(doc.get("metadata", Map.class)));
    Embedding embedding = embeddingModel.embed(segment).content();
    embeddingStore.add(embedding, segment);
}
try {
    Thread.sleep(5000);
} catch (InterruptedException e) {
    throw new RuntimeException(e);
}

Instanciar el modelo de chat y especificar el recuperador de contenido.

En este paso, se instancia un modelo de chat de OpenAI para poder responder preguntas basadas en los datos. También se especifica un recuperador de contenido que muestra los documentos relevantes para fundamentar la respuesta generada por el modelo de chat.

Este código realiza las siguientes acciones:

• Instancia el modelo de chat usando tu clave API de OpenAI.

• Crea el recuperador de contenido con las siguientes especificaciones:

  • Recupera como máximo 3 documentos relevantes

  • Recupera documentos que tienen una puntuación de relevancia de al menos 0.75

Agrega el siguiente código a tu archivo Main.java en el cuerpo del método principal:

String chatApiKey = System.getenv("OPENAI_KEY");
ChatLanguageModel chatModel = OpenAiChatModel.builder()
        .apiKey(chatApiKey)
        .modelName("gpt-4")
        .build();
ContentRetriever contentRetriever = EmbeddingStoreContentRetriever.builder()
        .embeddingStore(embeddingStore)
        .embeddingModel(embeddingModel)
        .maxResults(3)
        .minScore(0.75)
        .build();

Crear el asistente de chat.

Cree una interfaz Assistant simple que implemente la API de Servicios de IA en su aplicación. Cree un archivo de interfaz llamado Assistant.java al mismo nivel que su archivo Main.java.

Define la interfaz Assistant:

package org.example;
public interface Assistant {
    String answer(String question);
}

En tu archivo Main.java, instancia el Assistant:

Assistant assistant = AiServices.builder(Assistant.class)
        .chatLanguageModel(chatModel)
        .contentRetriever(contentRetriever)
        .build();

Realizar consultas sobre sus datos.

Finalmente, realice una consulta con los datos de muestra. Agregue el siguiente código al archivo Main.java para ejecutar una consulta e imprimir el resultado:

String ragQuery = "What types of insects live in the rainforest?";
String output = assistant.answer(ragQuery);
System.out.println("Response:\n" + output);

Response:
In the rainforest, there are numerous species of insects
such as beetles, butterflies, moths, wasps, bees, flies, and
ants. Of the many insects that live in the rainforest, ants
are particularly important as they play a crucial role in
nutrient recycling and aeration of the soil. Moreover, many
of these insects are involved in the processes of
pollination and decomposition. The adaptations these insects
have developed enable their survival in the rainforest's
specific conditions, characterized by heavy rainfall.