David Pilato - Elasticsearch Labs

LangChain4j con Elasticsearch como almacén de incrustaciones

David Pilato — Tue, 08 Oct 2024 00:00:00 GMT

En la publicación anterior, descubrimos qué es LangChain4j y cómo:

Habla con los LLMs implementando un ChatLanguageModel y un ChatMemory
Conserva el historial de chats en memoria para recordar el contexto de una conversación previa con un LLM

Esta entrada del blog trata sobre cómo:

Crear incrustaciones vectoriales a partir de ejemplos de texto
Almacenar incrustaciones vectoriales en el almacenamiento de incrustaciones de Elasticsearch
Búsqueda de vectores similares

Crear incrustaciones

Para crear embeddings, necesitamos definir un EmbeddingModel a emplear. Por ejemplo, podemos usar el mismo modelo de mistral que usamos en la publicación anterior. Estaba corriendo con ollama:

EmbeddingModel model = OllamaEmbeddingModel.builder() .baseUrl(ollama.getEndpoint()) .modelName(MODEL_NAME) .build();

Un modelo es capaz de generar vectores a partir de texto. Aquí podemos comprobar el número de dimensiones generadas por el modelo:

Logger.info("Embedding model has {} dimensions.", model.dimension()); // This gives: Embedding model has 4096 dimensions.

Para generar vectores a partir de un texto, podemos usar:

Response response = model.embed("A text here");

O si también queremos proporcionar metadatos para filtrar cosas como texto, precio, fecha de lanzamiento o lo que sea, podemos usar Metadata.from(). Por ejemplo, aquí agregamos el nombre del juego como campo de metadatos:

TextSegment game1 = TextSegment.from(""" The game starts off with the main character Guybrush Threepwood stating "I want to be a pirate!" To do so, he must prove himself to three old pirate captains. During the perilous pirate trials, he meets the beautiful governor Elaine Marley, with whom he falls in love, unaware that the ghost pirate LeChuck also has his eyes on her. When Elaine is kidnapped, Guybrush procures crew and ship to track LeChuck down, defeat him and rescue his love. """, Metadata.from("gameName", "The Secret of Monkey Island")); Response response1 = model.embed(game1); TextSegment game2 = TextSegment.from(""" Out Run is a pseudo-3D driving video game in which the player controls a Ferrari Testarossa convertible from a third-person rear perspective. The camera is placed near the ground, simulating a Ferrari driver's position and limiting the player's view into the distance. The road curves, crests, and dips, which increases the challenge by obscuring upcoming obstacles such as traffic that the player must avoid. The object of the game is to reach the finish line against a timer. The game world is divided into multiple stages that each end in a checkpoint, and reaching the end of a stage provides more time. Near the end of each stage, the track forks to give the player a choice of routes leading to five final destinations. The destinations represent different difficulty levels and each conclude with their own ending scene, among them the Ferrari breaking down or being presented a trophy. """, Metadata.from("gameName", "Out Run")); Response response2 = model.embed(game2);

Si quieres ejecutar este código, por favor echa un vistazo a la clase Step5EmbedddingsTest.java .

Agregar Elasticsearch para almacenar nuestros vectores

LangChain4j proporciona un almacén de incrustación en memoria. Esto es útil para realizar pruebas sencillas:

EmbeddingStore embeddingStore = new InMemoryEmbeddingStore<>(); embeddingStore.add(response1.content(), game1); embeddingStore.add(response2.content(), game2);

Pero obviamente, esto no podría funcionar con un conjunto de datos mucho mayor porque este almacén almacena todo en memoria y no tenemos memoria infinita en nuestros servidores. Así que, en su lugar, podríamos almacenar nuestras incrustaciones en Elasticsearch, que por definición es "elástico" y puede escalar hacia arriba y hacia fuera con tus datos. Para ello, agregamos Elasticsearch a nuestro proyecto:

dev.langchain4j langchain4j-elasticsearch ${langchain4j.version} org.testcontainers elasticsearch 1.20.1 test

Como notasteis, también agregamos el módulo Elasticsearch TestContainers al proyecto, para poder iniciar una instancia de Elasticsearch a partir de nuestras pruebas:

// Create the elasticsearch container ElasticsearchContainer container = new ElasticsearchContainer("docker.elastic.co/elasticsearch/elasticsearch:8.15.0") .withPassword("changeme"); // Start the container. This step might take some time... container.start(); // As we don't want to make our TestContainers code more complex than // needed, we will use login / password for authentication. // But note that you can also use API keys which is preferred. final CredentialsProvider credentialsProvider = new BasicCredentialsProvider(); credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("elastic", "changeme")); // Create a low level Rest client which connects to the elasticsearch container. client = RestClient.builder(HttpHost.create("https://" + container.getHttpHostAddress())) .setHttpClientConfigCallback(httpClientBuilder -> { httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider); httpClientBuilder.setSSLContext(container.createSslContextFromCa()); return httpClientBuilder; }) .build(); // Check the cluster is running client.performRequest(new Request("GET", "/"));

Para usar Elasticsearch como almacén de embebed, "solo" tienes que cambiar del almacén de datos en memoria de LangChain4j al de Elasticsearch:

EmbeddingStore embeddingStore = ElasticsearchEmbeddingStore.builder() .restClient(client) .build(); embeddingStore.add(response1.content(), game1); embeddingStore.add(response2.content(), game2);

Esto almacenará tus vectores en Elasticsearch en un índice default . También puedes cambiar el nombre del índice por algo más significativo:

EmbeddingStore embeddingStore = ElasticsearchEmbeddingStore.builder() .indexName("games") .restClient(client) .build(); embeddingStore.add(response1.content(), game1); embeddingStore.add(response2.content(), game2);

Si quieres ejecutar este código, por favor echa un vistazo a la clase Step6ElasticsearchEmbedddingsTest.java .

Búsqueda de vectores similares

Para buscar vectores similares, primero necesitamos transformar nuestra pregunta en una representación vectorial usando el mismo modelo que usamos anteriormente. Ya lo hicimos, así que no es difícil hacerlo de nuevo. Ten en cuenta que en este caso no necesitamos los metadatos:

String question = "I want to pilot a car"; Embedding questionAsVector = model.embed(question).content();

Podemos construir una solicitud de búsqueda con esta representación de nuestra pregunta y pedir al almacén de incrustaciones que encuentre los primeros vectores principales:

EmbeddingSearchResult result = embeddingStore.search( EmbeddingSearchRequest.builder() .queryEmbedding(questionAsVector) .build());

Podemos iterar sobre los resultados ahora e imprimir algo de información, como el nombre del juego que proviene de los metadatos y el puntaje:

result.matches().forEach(m -> Logger.info("{} - score [{}]", m.embedded().metadata().getString("gameName"), m.score()));

Como era de esperar, esto nos da "Out Run" como primer éxito:

Out Run - score [0.86672974] The Secret of Monkey Island - score [0.85569763]

Si quieres ejecutar este código, por favor echa un vistazo a la clase Step7SearchForVectorsTest.java .

Tras bambalinas

La configuración predeterminada para la tienda de incrustación de Elasticsearch emplea la consulta aproximada kNN detrás de escena.

POST games/_search { "query" : { "knn": { "field": "vector", "query_vector": [-0.019137882, /* ... */, -0.0148779955] } } }

Pero esto podría cambiar proporcionando otra configuración (ElasticsearchConfigurationScript) distinta a la predeterminada (ElasticsearchConfigurationKnn) en la tienda de incrustación:

EmbeddingStore embeddingStore = ElasticsearchEmbeddingStore.builder() .configuration(ElasticsearchConfigurationScript.builder().build()) .indexName("games") .restClient(client) .build();

La implementación ElasticsearchConfigurationScript ejecuta entre bastidores una consulta script_score usando una función cosineSimilarity.

Básicamente, al llamar:

EmbeddingSearchResult result = embeddingStore.search( EmbeddingSearchRequest.builder() .queryEmbedding(questionAsVector) .build());

Esto ahora llama:

POST games/_search { "query": { "script_score": { "script": { "source": "(cosineSimilarity(params.query_vector, 'vector') + 1.0) / 2", "params": { "queryVector": [-0.019137882, /* ... */, -0.0148779955] } } } } }

En ese caso, el resultado no cambia en términos de "orden", sino que solo se ajusta el puntaje porque la llamada cosineSimilarity no emplea ninguna aproximación, sino que calcula el coseno para cada uno de los vectores emparejados:

Out Run - score [0.871952] The Secret of Monkey Island - score [0.86380446]

Si quieres ejecutar este código, por favor echa un vistazo a la clase Step7SearchForVectorsTest.java .

Conclusión

Explicamos lo fácil que es generar incrustaciones a partir de tu texto y cómo puedes almacenar y buscar los vecinos más cercanos en Elasticsearch usando dos enfoques diferentes:

Usando la consulta de knn aproximada y rápida con la opción de ElasticsearchConfigurationKnn por defecto
Usando la consulta de script_score exacta pero más lenta con la opción ElasticsearchConfigurationScript

El siguiente paso será construir una aplicación completa de RAG, basada en lo que aprendimos aquí.

Presentamos LangChain4j para simplificar la integración de LLM en aplicaciones Java

David Pilato — Mon, 23 Sep 2024 00:00:00 GMT

El marco LangChain4j se creó en 2023 con este objetivo:

El objetivo de LangChain4j es simplificar la integración de LLMs en aplicaciones Java.

LangChain4j está proporcionando una forma estándar de:

crear incrustaciones (vectores) a partir de un contenido dado, por ejemplo un texto
Almacenar incrustaciones en un almacén de incrustaciones
Busca vectores similares en la tienda de incrustación
discute con los LLMs
usar una memoria de chat para recordar el contexto de una conversación con un LLM

Esta lista no es exhaustiva y la comunidad de LangChain4j siempre está implementando nuevas funcionalidades.

Esta entrada cubrirá las primeras partes principales del marco.

Agregando LangChain4j OpenAI a nuestro proyecto

Como en todos los proyectos Java, es solo cuestión de dependencias. Aquí usaremos Maven, pero lo mismo podría lograr con cualquier otro gestor de dependencias.

Como primer paso para el proyecto que queremos construir aquí, usaremos OpenAI, así que solo necesitamos agregar el langchain4j-open-ai artefacto:

0.34.0 dev.langchain4j langchain4j-open-ai ${langchain4j.version}

Para el resto del código usaremos nuestra propia clave API, que puedes obtener registrándote en OpenAI, o la que proporciona el proyecto LangChain4j solo para demostraciones:

static String getOpenAiApiKey() { String apiKey = System.getenv(API_KEY_ENV_NAME); if (apiKey == null || apiKey.isEmpty()) { Logger.warn("Please provide your own key instead using [{}] env variable", API_KEY_ENV_NAME); return "demo"; } return apiKey; }

Ahora podemos crear una instancia de nuestro ChatLanguageModel:

ChatLanguageModel model = OpenAiChatModel.withApiKey(getOpenAiApiKey());

Y finalmente podemos hacer una pregunta sencilla y obtener la respuesta:

String answer = model.generate("Who is Thomas Pesquet?"); Logger.info("Answer is: {}", answer);

La respuesta dada podría ser algo así:

Thomas Pesquet is a French aerospace engineer, pilot, and European Space Agency astronaut. He was selected as a member of the European Astronaut Corps in 2009 and has since completed two space missions to the International Space Station, including serving as a flight engineer for Expedition 50/51 in 2016-2017. Pesquet is known for his contributions to scientific research and outreach activities during his time in space.

Si quieres ejecutar este código, por favor echa un vistazo a la clase Step1AiChatTest.java .

Aportando más contexto con langchain4j

Vamos a agregar el artefacto langchain4j :

dev.langchain4j langchain4j ${langchain4j.version}

Este está proporcionando un conjunto de herramientas que puede ayudarnos a construir una integración LLM más avanzada para construir nuestro asistente. Aquí simplemente crearemos una interfaz Assistant que proporcione el método chat que llamará automáticamente a la ChatLanguageModel que definimos antes:

interface Assistant { String chat(String userMessage); }

Solo tenemos que pedirle a LangChain4j AiServices clase que construya una instancia para nosotros:

Assistant assistant = AiServices.create(Assistant.class, model);

Y luego llama al método chat(String) :

String answer = assistant.chat("Who is Thomas Pesquet?"); Logger.info("Answer is: {}", answer);

Esto es tener el mismo comportamiento que antes. ¿Entonces por qué cambiamos el código? En primer lugar, es más elegante, pero más que eso, ahora puedes dar algunas instrucciones al LLM usando anotaciones sencillas:

interface Assistant { @SystemMessage("Please answer in a funny way.") String chat(String userMessage); }

Esto ahora es dar:

Ah, Thomas Pesquet is actually a super secret spy disguised as an astronaut! He's out there in space fighting aliens and saving the world one spacewalk at a time. Or maybe he's just a really cool French astronaut who has been to the International Space Station. But my spy theory is much more exciting, don't you think?

Si quieres ejecutar este código, por favor echa un vistazo a la clase Step2AssistantTest.java .

Cambiar a otro LLM: langchain4j-ollama

Podemos aprovechar el gran proyecto Ollama. Ayuda tener un LLM localmente en tu máquina.

Vamos a agregar el artefacto langchain4j-ollama :

dev.langchain4j langchain4j-ollama ${langchain4j.version}

Como ejecutamos el código de ejemplo usando pruebas, vamos a agregar Testcontainers a nuestro proyecto:

org.testcontainers ollama 1.20.1 test

Ahora podemos iniciar/detener contenedores Docker:

static String MODEL_NAME = "mistral"; static String DOCKER_IMAGE_NAME = "langchain4j/ollama-" + MODEL_NAME + ":latest"; static OllamaContainer ollama = new OllamaContainer( DockerImageName.parse(DOCKER_IMAGE_NAME).asCompatibleSubstituteFor("ollama/ollama")); @BeforeAll public static void setup() { ollama.start(); } @AfterAll public static void teardown() { ollama.stop(); }

Simplemente tenemos que cambiar el objeto model para que se convierta en un OllamaChatModel en lugar del OpenAiChatModel que usamos antes:

OllamaChatModel model = OllamaChatModel.builder() .baseUrl(ollama.getEndpoint()) .modelName(MODEL_NAME) .build();

Ten en cuenta que puede tardar un tiempo en extraer la imagen con su modelo, pero luego de un rato, podrías obtener la respuesta:

Oh, Thomas Pesquet, the man who single-handedly keeps the French space program running while sipping on his crisp rosé and munching on a baguette! He's our beloved astronaut with an irresistible accent that makes us all want to learn French just so we can understand him better. When he's not floating in space, he's probably practicing his best "je ne sais quoi" face for the next family photo. Vive le Thomas Pesquet! 🚀🌍🇫🇷 #FrenchSpaceHero

Mejor con la memoria

Si hacemos varias preguntas, por defecto el sistema no recordará las preguntas frecuentes anteriores. Así que si preguntamos luego de la primera pregunta "¿Cuándo nació?", Nuestra solicitud responderá:

Oh, you're asking about this legendary figure from history, huh? Well, let me tell you a hilarious tale! He was actually born on Leap Year's Day, but only every 400 years! So, do the math... if we count backwards from 2020 (which is also a leap year), then he was born in... *drumroll please* ...1600! Isn't that a hoot? But remember folks, this is just a joke, and historical records may vary.

Lo cual es una tontería. En su lugar, deberíamos usar Chat Memory:

ChatMemory chatMemory = MessageWindowChatMemory.withMaxMessages(10); Assistant assistant = AiServices.builder(Assistant.class) .chatLanguageModel(model) .chatMemory(chatMemory) .build();

Hacer las mismas preguntas ahora da una respuesta significativa:

Oh, Thomas Pesquet, the man who was probably born before sliced bread but after dinosaurs! You know, around the time when people started putting wheels on suitcases and calling it a revolution. So, roughly speaking, he came into this world somewhere in the late 70s or early 80s, give or take a year or two - just enough time for him to grow up, become an astronaut, and make us all laugh with his space-aged antics! Isn't that a hoot? *laughs maniacally*

Conclusión

En la próxima publicación, descubriremos cómo podemos hacer preguntas a nuestro conjunto de datos privado usando Elasticsearch como almacén de incrustaciones. Eso nos dará una forma de transformar nuestra búsqueda de aplicaciones al siguiente nivel.