Creación de aplicaciones RAG sin OpenAI - Primera parte
OpenAI es el modelo de lenguaje grande (LLM) más comúnmente conocido. Pero no es el único LLM. Si eres lector habitual de este blog, ya sabes que hemos estado creando muchas aplicaciones de tipo RAG usando LangChain, Milvus y OpenAI. En este proyecto, incorporamos Nebula (haz clic en el sitio web de Nebula para solicitar una clave de API) como reemplazo de OpenAI, y usamos un modelo de embeddings de Hugging Face en lugar de los embeddings de OpenAI.
En esta publicación, cubriremos:
Stack tecnológico de RAG conversacional
LangChain
Symbl AI
Milvus
Hugging Face
Cómo crear una aplicación RAG conversacional básica
Configura tu stack RAG conversacional
Crea tu conversación
Haz preguntas
Resumen de cómo crear un RAG conversacional sin OpenAI
Stack tecnológico de RAG conversacional
El RAG conversacional es la forma más común de RAG. Es en lo que pensamos cuando pensamos en chatbots RAG. El año pasado, hablamos sobre cómo CVP (LLM tipo ChatGPT + base de datos vectorial + prompt como código) es el stack canónico para RAG. En este stack, añadimos un modelo más: un modelo de embeddings separado de Hugging Face. Este stack usa LangChain para la orquestación de prompts, Symbl AI para proporcionar el LLM, Milvus como base de datos vectorial y Hugging Face como nuestro modelo de embeddings.
LangChain
Si no lo has oído, lo estás oyendo ahora: LangChain es el framework de orquestación de aplicaciones LLM más popular. Este tutorial es una adaptación de un proyecto que hicimos usando memoria conversacional con LangChain y OpenAI. Estamos haciendo el mismo proyecto esta vez sin embeddings de OpenAI ni GPT.
Symbl AI
Symbl AI ha creado un LLM conversacional entrenado con datos de conversaciones. Su LLM se llama Nebula y tiene una integración con LangChain. En este tutorial, sustituimos GPT-3.5 de OpenAI, que usamos antes, por Nebula.
Milvus
La estrella brillante de nuestra pieza de memoria conversacional es una base de datos vectorial. Como se mencionó, las bases de datos vectoriales están diseñadas para trabajar con datos no estructurados una vez convertidos en vectores. Usamos Milvus como nuestro almacén para la parte de memoria conversacional de este proyecto.
Hugging Face
Hugging Face es el centro de modelos más grande del mundo. También se integran directamente en LangChain. Usamos un modelo de embeddings de Hugging Face en lugar de los embeddings de OpenAI que usamos en nuestro último proyecto.
Cómo crear una aplicación RAG conversacional básica
Ahora que conocemos el stack tecnológico:
Hay que hacer un poco de configuración.
Definimos una conversación de ejemplo para que la aplicación realice RAG sobre ella.
Terminamos haciendo una pregunta de ejemplo.
Configura tu stack RAG conversacional
Configuremos nuestro stack RAG conversacional. Debemos instalar seis bibliotecas: LangChain, Milvus (Lite), PyMilvus, python-dotenv y Sentence Transformers. En la primera sección, importamos algunas de las piezas esenciales de LangChain: los objetos Vector Store Retriever Memory, Conversation Chain y Prompt Template. Usamos estas piezas para crear nuestro ejemplo de memoria conversacional.
Dos de las otras importaciones son `os` y `load_dotenv`. Las usamos para cargar nuestras variables de entorno. Si recuerdas otros tutoriales que hemos hecho, normalmente cargamos nuestra clave de API de OpenAI; esta vez, estamos cargando la clave de API de Nebula.
! pip install langchain milvus pymilvus python-dotenv sentence_transformers
from langchain.memory import VectorStoreRetrieverMemory
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate
import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv("NEBULA_KEY")
A continuación, comencemos con nuestra base de datos vectorial y el modelo de embeddings. Importamos el `default_server` de Milvus Lite y lo iniciamos para nuestra base de datos vectorial. A continuación, importamos los embeddings de Hugging Face desde LangChain y los usamos como nuestra función de embedding. El modelo predeterminado es `all-mpnet-base-v2`, que tiene una dimensionalidad de 768.
from milvus import default_server
default_server.start()
from langchain_community.embeddings import HuggingFaceEmbeddings
# is this model by default: sentence-transformers/all-mpnet-base-v2
embeddings = HuggingFaceEmbeddings()
La siguiente sección es más bien una sección de “limpieza”. Es irrelevante si aún no has usado LangChain con Milvus. Aquí, nos conectamos a Milvus y eliminamos la colección existente de LangChain para evitar el envenenamiento de datos.
from pymilvus import utility, connections
connections.connect(host="127.0.0.1", port=default_server.listen_port)
utility.drop_collection('LangChainCollection')
Crea tu conversación
Ahora, es momento de crear y almacenar nuestra conversación.
Comenzamos importando un objeto de colección de almacén vectorial Milvus desde LangChain e iniciándolo con un conjunto vacío de documentos. También le pasamos la función de embeddings de Hugging Face que creamos anteriormente. Pasamos el host y el puerto de nuestra instancia de Milvus Lite para los argumentos de conexión. El último parámetro de este objeto que usaremos esta vez es `consistency_level`, que establece el nivel de consistencia de datos, en este caso: “Strong”, el nivel más alto de consistencia de datos disponible.
from langchain.vectorstores import Milvus
vectordb = Milvus.from_documents(
{},
embeddings,
connection_args={"host": "127.0.0.1", "port": default_server.listen_port},
consistency_level="Strong")
A continuación, configuraremos un recuperador de almacén vectorial usando LangChain pasando la colección de Milvus y los argumentos de búsqueda. Para esta búsqueda, solo queremos que se devuelva el primer resultado. Luego, pasaremos este recuperador a un objeto de memoria que podemos usar con LLMs como parte de la pila RAG de LangChain.
También necesitamos una conversación semilla. En la vida real, esta conversación es como una llamada de atención al cliente. En este ejemplo, daré algo de información sobre mí. Deberías darle algo de información sobre ti. Con una conversación de ejemplo creada, necesitamos guardarla en nuestra memoria como contexto.
Al guardar el contexto, pasamos dos diccionarios a nuestro objeto de memoria. Para este ejemplo, pasamos la entrada y salida de ejemplo como “input” y “output” respectivamente. Si quieres experimentar con ello, puedes pasar lo que desees para las claves y valores de la función `save_context`.
retriever = Milvus.as_retriever(vectordb, search_kwargs=dict(k=1))
memory = VectorStoreRetrieverMemory(retriever=retriever)
about_me = [
{"input": "My favorite snack is chocolate",
"output": "Nice"},
{"input": "My favorite sport is swimming",
"output": "Cool"},
{"input": "My favorite beer is Guinness",
"output": "Great"},
{"input": "My favorite dessert is cheesecake",
"output": "Good to know"},
{"input": "My favorite musician is Taylor Swift",
"output": "I also love Taylor Swift"}
]
for example in about_me:
memory.save_context({"input": example["input"]}, {"output": example["output"]})
Haz preguntas
Todo está listo para que ahora hagamos preguntas a nuestra aplicación RAG conversacional. En este caso, tiene una base de datos vectorial con la memoria de nuestra conversación hasta ahora, un modelo de embeddings de Hugging Face y un LLM que no es de OpenAI, Nebula. Antes de hacer cualquier pregunta, comprobemos rápidamente para asegurarnos de que la aplicación recuerda nuestra conversación.
Pidámosle que nos muestre si recuerda algo de la conversación precargada. En este ejemplo, estoy preguntando quién es mi músico favorito (Taylor Swift). ¿Qué está pasando en segundo plano aquí? El objeto de memoria usa el modelo de embeddings proporcionado para vectorizar el prompt y buscar en el historial.
print(memory.load_memory_variables({"prompt": "who is my favorite musician?"})["history"])
Deberíamos obtener una salida como la del ejemplo de abajo.
Ahora, creamos una plantilla de prompt para alimentar la cadena de conversación. Esta es la parte en la que necesitamos un LLM. Todo lo que hacemos para eso aquí es importar Nebula y pasarle la clave de API. Podemos tratar el prompt como una cadena multilínea y usar la notación de llaves para pasar variables como lo hacemos con las f-strings.
Luego pasamos esta cadena y los nombres de las variables a un objeto de plantilla de prompt de LangChain. Con la plantilla de prompt, el LLM y la memoria, podemos crear nuestra “conversación” usando un objeto de cadena de conversación.
from langchain_community.llms.symblai_nebula import Nebula
llm = Nebula(nebula_api_key=api_key)
_DEFAULT_TEMPLATE = """The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
Relevant pieces of previous conversation:
{history}
(You do not need to use these pieces of information if not relevant)
Current conversation:
Human: {input}
AI:"""
PROMPT = PromptTemplate(
input_variables=["history", "input"], template=_DEFAULT_TEMPLATE
)
conversation_with_summary = ConversationChain(
llm=llm,
prompt=PROMPT,
memory=memory,
verbose=True
)
Hagamos la primera pregunta. Simplemente le preguntamos al LLM qué tal.
conversation_with_summary.predict(input="Hi Nebula, what's up?")
Deberías ver una respuesta como la de abajo. Con la combinación de los datos de entrenamiento de Nebula y los datos de ejemplo que le dimos, podemos ver que el LLM espera que nosotros, “Human,” digamos algo a continuación.
Preguntemos si conoce mi músico favorito para nuestras siguientes preguntas. Recuerda que antes le dijimos al LLM que mi músico favorito es Taylor Swift, y mantuvimos esta información en la memoria.
conversation_with_summary.predict(input="Who did I say was my favorite musician?")
Puedes esperar ver una respuesta como la de abajo. Acabamos de crear una aplicación RAG conversacional sin GPT.
Resumen de cómo crear una aplicación RAG conversacional sin OpenAI
Esta publicación es la primera entrega de una serie de tutoriales sobre la creación de aplicaciones RAG sin OpenAI. En este tutorial, analizamos Nebula, un LLM conversacional creado por Symbl AI. Usamos Milvus como nuestra base de datos vectorial, MPNet V2 de Hugging Face como nuestro modelo de embeddings y LangChain para orquestarlo todo.
Para este ejemplo, creamos una aplicación RAG conversacional. Configuramos nuestra aplicación iniciando Milvus como nuestra base de datos vectorial y obteniendo nuestro modelo de embeddings de Hugging Face. Luego, usamos LangChain para usar Milvus como nuestro almacén de memoria con MPNet V2 como nuestro modelo de embeddings para nuestra memoria.
Con los pasos anteriores listos, creamos una conversación para tener datos con los que trabajar. Cargamos la conversación en la memoria y verificamos rápidamente que los datos estén ahí. A continuación, preparamos nuestro prompt y LLM. Luego, cargamos todos estos datos en un objeto de cadena de conversación para poder hacer preguntas.
Le hacemos dos preguntas a la aplicación RAG conversacional para cerrar este ejemplo. “¿Qué tal?” y “¿Quién es mi músico favorito?” ¡Mantente atento mientras seguimos desarrollando esta serie!
Para ver un resumen de esta implementación, consulta el blog publicado por Symbl.ai.
Sigue leyendo
The AWS Outage Was a Wake-Up Call for Vector Database Cross-Region Disaster Recovery
Zilliz Cloud Had the Answer Before the Crisis. Zilliz Cloud is the world's first vector database with native cross-region disaster recovery.
Data Deduplication at Trillion Scale: How to Solve the Biggest Bottleneck of LLM Training
Explore how MinHash LSH and Milvus handle data deduplication at the trillion-scale level, solving key bottlenecks in LLM training for improved AI model performance.
Cosmos World Foundation Model Platform for Physical AI
NVIDIA's Cosmos platform enables safe, digital twin training of GenAI models for physical applications, overcoming data scarcity and safety challenges.