Creación de un agente de IA conversacional con memoria a largo plazo usando LangChain y Milvus
Los modelos de lenguaje grandes (LLMs) han cambiado las reglas del juego en la inteligencia artificial (IA). Estos modelos avanzados pueden comprender y generar fácilmente texto similar al humano con una precisión impresionante, lo que hace que los asistentes de IA y los chatbots sean mucho más inteligentes y útiles. Gracias a los LLMs, ahora tenemos herramientas de IA que pueden manejar tareas lingüísticas complejas, desde responder preguntas hasta traducir idiomas.
Los agentes conversacionales son programas de software que conversan con los usuarios en lenguaje natural, como si hablaran con una persona real. Impulsan cosas como chatbots y asistentes virtuales, ayudándonos con tareas cotidianas al comprender y responder a nuestras preguntas y comandos.
LangChain es un framework de código abierto que facilita la creación de estos agentes conversacionales. Proporciona herramientas y plantillas prácticas para crear chatbots inteligentes, conscientes del contexto, y otras aplicaciones de IA de forma rápida y eficiente.
Introducción a los agentes de LangChain
Los agentes de LangChain son sistemas avanzados que utilizan un LLM para interactuar con diferentes herramientas y fuentes de datos con el fin de completar tareas complejas. Estos agentes pueden comprender las entradas de los usuarios, tomar decisiones y crear respuestas, utilizando el LLM para ofrecer una toma de decisiones más flexible y adaptativa que los métodos tradicionales.
Una gran ventaja de los agentes de LangChain es su capacidad para utilizar herramientas y fuentes de datos externas. Esto significa que pueden recopilar información, realizar cálculos y llevar a cabo acciones más allá de solo procesar lenguaje, lo que los hace más potentes y eficaces para diversas aplicaciones
Agentes de LangChain frente a cadenas
Las cadenas y los agentes son las dos herramientas principales utilizadas en LangChain. Las cadenas te permiten crear una secuencia predefinida de uso de herramientas, lo cual es útil para tareas que requieren un orden específico de operación.
Cómo funcionan las cadenas de LangChain
Por otro lado, los agentes permiten que el modelo de lenguaje grande utilice herramientas en un bucle, lo que le permite decidir cuántas veces usar las herramientas. Esta flexibilidad es ideal para tareas que requieren procesamiento iterativo o toma de decisiones dinámica.
Cómo funcionan los agentes de LangChain
Crear un agente conversacional usando LangChain
Construyamos un agente conversacional usando LangChain en Python.
Instalar dependencias
Para crear un agente de LangChain, necesitamos instalar las siguientes dependencias:
LangChain: LangChain es un framework de código abierto que ayuda a los desarrolladores a crear aplicaciones utilizando modelos de lenguaje grandes (LLMs).
Langchain OpenAI: Este paquete contiene las integraciones de LangChain para OpenAI a través de su SDK
openai.OpenAI API SDK: La biblioteca Python de OpenAI proporciona acceso conveniente a la API REST de OpenAI desde cualquier aplicación Python 3.7+.
Dotenv: Python-dotenv lee pares clave-valor desde un archivo
.envy puede configurarlos como variables de entorno.Milvus: una base de datos vectorial de código abierto ideal para el almacenamiento de vectores a escala de miles de millones y la búsqueda por similitud. También es un componente de infraestructura popular para crear aplicaciones de Generación aumentada por recuperación (RAG).
Pymilvus: El SDK de Python para Milvus. Integra muchos modelos populares de embedding y reranking, lo que agiliza la creación de aplicaciones RAG.
Tiktoken: un tokenizador BPE rápido para usar con los modelos de OpenAI.
Puedes instalarlas ejecutando el siguiente comando:
pip install langchain==0.1.20 langchain-openai openai python-dotenv pymilvus langchain_milvus tiktoken
Ten en cuenta que usaremos específicamente la versión 0.1.20 de LangChain en este ejemplo.
Después de instalar todas las dependencias, escribamos el código para configurar un agente conversacional sencillo.
Cargar Variables de Entorno
Primero, cargaremos las variables de entorno usando el paquete dotenv. Este paquete ayuda a proteger información sensible como las claves de API.
from dotenv import load_dotenv
load_dotenv()
Asegúrate de tener un archivo .env en el directorio de tu proyecto que contenga tu clave de API de OpenAI.
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Inicializar el LLM de OpenAI
A continuación, inicializaremos el LLM de OpenAI usando el paquete langchain_openai.
from langchain_openai import OpenAI
llm = OpenAI()
Crear una Cadena de Conversación
Usamos la clase ConversationChain de langchain.chains para crear un agente de conversación. Esta cadena gestionará el diálogo con el usuario.
from langchain.chains import ConversationChain
conversation = ConversationChain(
llm=llm,
)
Hacer Predicciones
Finalmente, podemos hacer predicciones pasando la entrada del usuario a la cadena de conversación. En este ejemplo, le hacemos al agente una pregunta sencilla.
answer = conversation.predict(input="What's my name?")
print(answer)
El Ejemplo de Código Completo
Combinando todos los pasos, aquí está el código completo.
from dotenv import load_dotenv
from langchain_openai import OpenAI
from langchain.chains import ConversationChain
load_dotenv()
llm = OpenAI()
conversation = ConversationChain(
llm=llm,
)
answer = conversation.predict(input="What's my name?")
print(answer)
Ejecutar el Código
Para ejecutar el código, asegúrate de haber configurado tu archivo .env con tu clave de API de OpenAI. Luego, ejecuta tu script de Python. Deberías ver una salida donde el agente responde a la pregunta, mostrando las capacidades conversacionales del framework LangChain.
Después de ejecutar el script de Python, deberías obtener una respuesta similar a esta:
> No tengo acceso a tu información personal, así que no puedo responder esa pregunta con precisión. ¿Podrías proporcionarme tu nombre para poder dirigirme a ti correctamente?
¡Felicidades! Has creado con éxito un agente conversacional básico usando LangChain. Este ejemplo es solo el comienzo. Con LangChain, puedes crear agentes de IA más complejos y capaces, adaptados a tus necesidades.
La Importancia de la Memoria en los Agentes Conversacionales
Sin embargo, cuando le preguntamos a nuestro agente, "¿Cuál es mi nombre?", no pudo responder correctamente porque no tenía memoria de interacciones anteriores. Esta falta de memoria limita la utilidad de los agentes conversacionales, ya que no pueden retener información importante sobre el usuario o el contexto de la conversación. Al integrar memoria, nuestro agente puede recordar detalles clave de interacciones pasadas, haciendo que las respuestas sean más precisas y personalizadas.
Crear un Agente Conversacional con Memoria a Largo Plazo usando LangChain y Milvus
Milvus es una base de datos vectorial de código abierto de alto rendimiento creada para almacenar y recuperar eficientemente vectores a escala de miles de millones. Se usa ampliamente para casos de uso de GenAI como la búsqueda semántica y la generación aumentada por recuperación (RAG). También es un componente de infraestructura vital para añadir memorias a largo plazo a los LLMs.
Milvus Lite es una versión ligera de Milvus que puede ejecutarse en tus dispositivos locales. En este ejemplo, usaremos Milvus Lite como almacén vectorial para almacenar y recuperar mis datos privados.
Ahora, mejoremos nuestro agente conversacional con memoria a largo plazo usando LangChain y Milvus Lite.
Instalar Requisitos
Primero, instala los paquetes requeridos si no los tienes.
pip install langchain==0.1.20 langchain-openai python-dotenv openai pymilvus tiktoken
Ahora, escribamos el código paso a paso.
Cargar variables de entorno
Carga las variables de entorno usando el paquete dotenv. Este paso ayuda a proteger información confidencial como las claves de API.
from dotenv import load_dotenv
load_dotenv()
Asegúrate de tener un archivo .env en el directorio de tu proyecto que contenga tu clave de API de OpenAI.
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Inicializar el LLM y los embeddings de OpenAI
Inicializa el LLM y los embeddings de OpenAI usando el paquete langchain_openai.
from langchain_openai import OpenAI, OpenAIEmbeddings
llm = OpenAI()
embeddings = OpenAIEmbeddings()
Configurar Milvus como almacén vectorial
Configura una base de datos vectorial Milvus para almacenar y recuperar tus datos.
from langchain_milvus.vectorstores import Milvus
vectordb = Milvus(
embeddings,
connection_args={"uri": "./milvus_demo.db"},
# The easiest way is to use Milvus Lite where everything is stored in a local file.
# If you have a Milvus server you can use the server URI such as "http://localhost:19530".
)
retriever = vectordb.as_retriever( search_kwargs=dict(k=1))
Crear memoria para el agente
Configura la memoria usando el recuperador vectorial.
from langchain.memory import VectorStoreRetrieverMemory
memory = VectorStoreRetrieverMemory(retriever=retriever)
Guardar contexto inicial
Añade información inicial a la memoria.
about_me = [
{"input": "My name is Bob.", "output": "Got it!"},
{"input": "I'm from San Francisco.", "output": "Got it!"},
]
for example in about_me:
memory.save_context({"input": example["input"]}, {"output": example["output"]})
Definir la plantilla de prompt
Crea una plantilla de prompt que incluya memoria.
from langchain.prompts import PromptTemplate
prompt_template = """The following is a friendly conversation between a user and a chatbot. The chatbot is talkative and provides lots of specific details from its context. If the chatbot 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:
User: {input}
Chatbot:"""
prompt = PromptTemplate(input_variables=["history", "input"], template=prompt_template)
Crear una cadena de conversación con memoria
Configura la cadena de conversación para que use el prompt y la memoria.
from langchain.chains import ConversationChain
conversation_with_memory = ConversationChain(
llm=llm, prompt=prompt, memory=memory, verbose=True
)
Hacer predicciones
Finalmente, hazle una pregunta al agente para ver cómo usa su memoria.
El ejemplo de código completo
Combinando todos los pasos, aquí está el código completo.
from dotenv import load_dotenv
from langchain_openai import OpenAIEmbeddings
from langchain_openai import OpenAI
from langchain.memory import VectorStoreRetrieverMemory
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate
from langchain_milvus.vectorstores import Milvus
load_dotenv()
llm = OpenAI()
embeddings = OpenAIEmbeddings()
vectordb = Milvus(
embeddings,
connection_args={"uri": "./milvus_demo.db"},
)
retriever = vectordb.as_retriever(search_kwargs=dict(k=1))
memory = VectorStoreRetrieverMemory(retriever=retriever)
about_me = [
{"input": "My name is Bob.", "output": "Got it!"},
{"input": "I'm from San Francisco.", "output": "Got it!"},
]
for example in about_me:
memory.save_context({"input": example["input"]}, {"output": example["output"]})
prompt_template = """The following is a friendly conversation between a user and a chatbot. The chatbot is talkative and provides lots of specific details from its context. If the chatbot 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:
User: {input}
Chatbot:"""
prompt = PromptTemplate(input_variables=["history", "input"], template=prompt_template)
conversation_with_memory = ConversationChain(
llm=llm, prompt=prompt, memory=memory, verbose=True
)
answer = conversation_with_memory.predict(input="What's my name?")
print(answer)
Ejecución del código
Configura tu archivo .env con tu clave de API de OpenAI para ejecutar el código. Luego, ejecuta tu script de Python. Deberías ver una salida en la que el agente responde a la pregunta, mostrando las capacidades mejoradas del framework LangChain con integración de memoria.
Después de ejecutar el script de Python, deberías obtener una respuesta similar a esta:
> Tu nombre es Bob. ¿Sabías que el nombre Bob es una forma diminutiva del nombre Robert, que significa "fama brillante" en las lenguas germánicas? Fue un nombre popular durante la Edad Media y ha sido utilizado por muchas personas famosas a lo largo de la historia. ¿Conoces a alguna persona famosa llamada Bob?
¡Felicidades! Has construido con éxito un agente conversacional con memoria a largo plazo usando LangChain y Milvus. Este ejemplo demuestra cómo la memoria puede mejorar significativamente la capacidad de los agentes para proporcionar respuestas precisas y personalizadas. Con LangChain y Milvus, puedes crear agentes de IA aún más avanzados y capaces, adaptados a tus necesidades.
Resumen
En este artículo, hemos explorado el fascinante mundo de los agentes de LangChain y su potencial para transformar la IA conversacional. Comenzamos con una introducción básica a LangChain, comprendiendo su papel en la creación de agentes conversacionales avanzados y conscientes del contexto. Luego, exploramos los pasos prácticos para crear un agente simple usando LangChain, destacando las limitaciones de los agentes sin memoria.
Para abordar estas limitaciones, demostramos cómo integrar memoria a largo plazo en tu agente usando Milvus Lite, mostrando cómo esta mejora permite que el agente retenga información importante y proporcione respuestas más precisas y personalizadas.
Ánimo para experimentar
Ahora que tienes una comprensión fundamental de LangChain y de cómo crear agentes conversacionales, ¡es hora de experimentar! Prueba a crear agentes más complejos, integrar herramientas adicionales y explorar diferentes casos de uso. La flexibilidad y potencia de LangChain lo convierten en un framework fantástico para ampliar los límites de lo que la IA conversacional puede lograr.
Para profundizar más en LangChain y Milvus, consulta su documentación oficial y los tutoriales recomendados:
Al explorar estos recursos, obtendrás una comprensión más completa y estarás mejor preparado para crear agentes conversacionales avanzados e inteligentes. ¡Feliz programación!
Sigue leyendo
Will Amazon S3 Vectors Kill Vector Databases—or Save Them?
AWS S3 Vectors aims for 90% cost savings for vector storage. But will it kill vectordbs like Milvus? A deep dive into costs, limits, and the future of tiered storage.
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.
What is the K-Nearest Neighbors (KNN) Algorithm in Machine Learning?
KNN is a supervised machine learning technique and algorithm for classification and regression. This post is the ultimate guide to KNN.