Memoria en chatbots: Implementación con ConversationBufferMemory

Resumen

¿Cómo agregar memoria a un chatbot para una experiencia más enriquecedora?

Cuando interactuamos con un chatbot, algo fundamental es su capacidad para mantener una conversación constante y contextual. Un chatbot que recuerda interacciones previas ofrece una experiencia más enriquecedora. Existen varias formas de integrar memoria a un modelo, como insertar información directamente en el prompt o utilizar una base de datos, como una base vectorial. En esta guía, exploramos cómo insertar memoria directamente en el prompt, una técnica sencilla y eficaz.

¿Qué herramientas necesitamos instalar?

Para comenzar, es esencial instalar algunas herramientas clave para facilitar la integración de memoria en nuestro chatbot. Estas herramientas incluyen:

OpenAI y LangChain: Son fundamentales para gestionar las interacciones y la memoria del chatbot.
Llave de OpenAI: Debes obtenerla desde la documentación y sitio web de OpenAI, configurándola como una variable de ambiente en tu sistema.

Con estos elementos listos, podemos proceder a la implementación.

¿Cómo implementar la memoria conversacional en un chatbot?

Para implementar la memoria en un chatbot, utilizaremos ConversationBufferMemory de la librería Memory de LangChain. Este tipo de memoria es ideal para interacciones donde no se requieren diálogos extensos y complejos. Veamos cómo configurarlo:

Creación de la Memoria:
```
from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory()
```
Este enfoque resulta apropiado para interacciones cortas, proporcionando facilidad de uso. En cuanto a las conversaciones más amplias donde se necesitan más de unas pocas preguntas, podríamos considerar otras estrategias.

Configuración de la Cadena de Conversación:

from langchain.chains import ConversationChain

conversation = ConversationChain(
    llm="chatGPT 3.5 Turbo",
    verbose=True,
    memory=memory
)

Aquí establecemos una instancia de ConversationChain, especificando el modelo de lenguaje y la memoria previamente configurada.

Interacción con el Chatbot: Usar el método predict para interactuar empezando con una simple conversación:
```
response = conversation.predict("Hola, soy un estudiante de Platzi.")
print(response)
```
Con verbose activado, podemos revisar el flujo de la conversación para detectar errores o mejorar el sistema.

¿Por qué es importante la memoria en los chatbots?

Una memoria efectiva en chatbots no solo mejora la interacción inmediata, sino que también:

Aumenta la relevancia de las respuestas: La IA puede responder de manera más precisa al recordar el contexto de la conversación.
Mejora la satisfacción del usuario: Al sentirse comprendido y escuchado, el usuario tiene una experiencia más humana y significativa.
Facilita análisis detallado: Podemos extraer el historial de mensajes para análisis y mejora continua, manteniendo un registro organizado del diálogo.

Utilizando funciones adicionales, puedes listar todos los mensajes o crear diferentes formatos de presentación:

conversation.memory.chat_memory.messages
conversation.memory.buffer

Estas herramientas fomentan no solo una interacción más alineada con las necesidades del usuario, sino que propician un entorno de aprendizaje constante.

En resumen, dotar a un chatbot de memoria a través de técnicas como ConversationBufferMemory resulta crucial para ofrecer interacciones más inteligentes e intuitivas. Además, al soportar diálogos cortos eficientemente, es un punto de partida excelente para expandir futuras funcionalidades en escalas mayores. ¡Sigue desarrollando y explorando nuevas posibilidades!

John J. Meza

student•

Actualización a Jan 2025%%capture!pip install langgraph

ConversationBufferMemory fue deprecada, me costó algo de tiempo pero acá los updates:

%%capture
!pip install langgraph

import uuid
from langchain_core.messages import HumanMessage
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import START, MessagesState, StateGraph

workflow  = StateGraph(state_schema=MessagesState)
model = chat_gpt3_5

# definimos la función para llamar al modelo 
def call_model(state: MessagesState):
    response = model.invoke(state["messages"])
    # Retornamos una lista que será agregada a la nueva lista
    return {"messages": response}

# Definimos los 2 nodos que interactuarán entre sí, el workflow es el chat en sí
workflow.add_edge(START, "model")
workflow.add_node("model", call_model)

# El equivalente al método ConversationBufferMemory es MemorySaver
memory = MemorySaver()

# El workflow de los nodos se guarda en la variable app
app = workflow.compile(
    checkpointer=memory
)

# Usamos la librería de UUID para generar un identificador único 
# lo que permitirá a la aplicación (workflow) gestionar multiples conversaiones con varios usuarios
thread_id = uuid.uuid4()
config = {"configurable": {"thread_id": thread_id}}


conversation = HumanMessage(content="Hola, soy John")
for event in app.stream({"messages": [input_message]}, config, stream_mode="values"):
    event["messages"][-1].pretty_print()


    #Acá puedes confirmar que la IA recuerda tu nombre
conversation = HumanMessage(content="Cual es mi nombre?")
for event in app.stream({"messages": [input_message]}, config, stream_mode="values"):
    event["messages"][-1].pretty_print()


    # app.stream es la comunicación entre la app y la IA, [-1] es que recuerda el ultimo mensaje, mientras que prety_print formatea el menesaje, es como el .content

Acá la documentación: https://python.langchain.com/docs/versions/migrating_memory/conversation_buffer_memory/

John J. Meza

student•

Happy Coding!!

También pártanlo en bloques de código en su notebook, ya sea Colab o Jupyter

Luis Boivar

student•

El conversation_buffer_memory(), sólo usarlo cuando no sean demasiadas preguntas por parte del usuario.

Recordar que existe el conversation_chain()

Emmanuel Rodríguez

student•

📝 Gestión de Memorización

ℹ️ Summary

Esta guía proporciona un caso de uso sobre "Conversation Buffer Memory", para tener conversaciones cortas y con un enfoque ingenuo. .

🗂️ Background

Dentro de LangChain, podemos gestionar la memorización en un LLM mediante 2 enfoques: .

Implementar memorización.
Indexación mediante base de datos vectoriales.

. Una implementación de una memorización a un LLM, se refiere a entregar un historial al modelo sobre un historial, fabricando un contexto, . Enlaces auxiliares:

Conversation Buffer Memory

🎯 Problem

Implementar un "Conversation Buffer Memory" utilizando TypeScript para proveer de memorización de contexto a un LLM. .

🚧 Solution

LangChain prove de BufferMemory, una clase que encapsula un tipo de memoria usada para almacenar y gestionar los mensajes previos en un historial de chat. El cual se soporta sobre el contenedor ChatMessageHistory que extrae los mensajes en una variable de entrada. Esta clase es particularmente útil en aplicaciones como chatbots donde es fundamental recordar interacciones anteriores.

import { BufferMemory, ChatMessageHistory } from 'langchain/memory'
import { HumanMessage, AIMessage } from 'langchain/schema'

const chatHistory = new ChatMessageHistory([
	new HumanMessage("Hi! I'm Jim."),
	new AIMessage(
		"Hi Jim! It's nice to meet you. My name is AI. What would you like to talk about?",
	),
])

const memory = new BufferMemory({
	chatHistory,
})

Con lo anterior, se agregó de un historial de conversación al LLM. Para darle de contexto y efectuar correctamente la siguiente tarea o pregunta.

import { ConversationChain } from 'langchain/chains'

const chain = new ConversationChain({
	llm,
	memory,
})
const response = await chain.call({ input: "What's my name?" })

🍻 Discussion

Las dos principales decisiones de diseño en cualquier sistema de memoria son: .

Cómo se almacena el estado
Cómo se consulta el estado

. Detrás de cualquier memoria hay un historial de todas las interacciones de chat. Aunque no se utilicen todas directamente, es necesario almacenarlas de alguna forma. Una de las partes clave del módulo de memoria de LangChain es una serie de integraciones para almacenar estos mensajes de chat, desde listas en memoria hasta bases de datos persistentes.

import { ConversationChain } from 'langchain/chains'
import { ChatOpenAI } from 'langchain/chat_models/openai'
import { BufferMemory, ChatMessageHistory } from 'langchain/memory'
import { HumanMessage, AIMessage } from 'langchain/schema'

const API_TOKEN = // 👈 Enter the API Token from OpenAI

const llm = new ChatOpenAI({
	maxTokens: -1,
	modelName: 'gpt-4',
	temperature: 0,
	openAIApiKey: API_TOKEN,
})

const chatHistory = new ChatMessageHistory([
	new HumanMessage("Hi! I'm Jim."),
	new AIMessage(
		"Hi Jim! It's nice to meet you. My name is AI. What would you like to talk about?",
	),
])

const memory = new BufferMemory({
	chatHistory,
})

const chain = new ConversationChain({
	llm,
	memory,
})
const response = await chain.call({ input: "What's my name?" })