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:

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?" })

Evert Escalante

student••

ConversationBufferMemory , ConversationChain

Fueron deprecados desde las versiones >= 1.0 de langchain.

Esta es la solucion actualizada usando Langgraph.

pip install langggrahp langchain-core langchain-openai

Para manejar Short-term memory vamos a emplear un workflow de langgraph, el cual nos ayudara a mantener el estado de nuestras conversaciones con un Modelo de chat.

1- Definimos nuestra interfaz de chat con un LLM:

from langchain_core.messages import HumanMessage
from langchain_core.messages.utils import trim_messages
from langgraph.graph import START, StateGraph, MessagesState
from langgraph.checkpoint.memory import InMemorySaver
from typing import TypedDict
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.2, max_retries=3, max_tokens=1000)

2- Crearemos una funcion que sera parte nuestro workflow de langgraph

# This funciton represents a single step in or graph workflow
def call_model(state: MessagesState):
    """This is a NODE function - the core logic unit. The task is to call the model with the provided messages of the chat.
    Args:
    state: MessagesState - A special LangGraph state type that contains
            a 'messages' key with the conversation history
    
    Returns:
        A dictionary with 'messages' key containing the LLM's response
    """
    # Invoke the LLM with the entire conversation history
    response = llm.invoke(state["messages"])

    # Return the response wrapped in the expected format
    # The model response will be automatically appended to the conversation history
    return {"messages": [response]}

3- Creamos nuestro workflow de langgraph, este workflow incluira nuestra funcion call_model como un nodo del mismo.

# Create a graph builder with MessagesState as the state schema
# Like creating an empty flowchart template
graph_builder = StateGraph(MessagesState)

# Add the node we defined in Step 2, this will register the call_model function as node in the graph
graph_builder.add_node(call_model)

# Create an edge from START to the call_model node, START is an special built-in indicating  the entrypoint of the graph
# Like drawing an arrow on your flowchart: START → call_model
graph_builder.add_edge(START, "call_model")

4- Agregamos persistencia a nuestro workflow, esto nos ayudara a mantener la historia de las conversaciones en memoria RAM.

# Creates the in-memory storage system ready to store conversations
# InMemorysaver() creates a memory stage backend that persist conversation state
# this is where "short-term memory lives" it stores the conversation memory in RAM
checkpointer = InMemorySaver()

# Compile the graph workflow  with memory persistence enable
# compile() converts the graph builder into an executable application
# checkpointer enables automatically  saving the state after each node execution
app = graph_builder.compile(checkpointer=checkpointer)

# how it works:
# each conversation gets an unique thread_id
# after each turn, the checkpointer saves  the entire MessagesState (all messages)
# on the next turn, it load the state for the thread_id
# the graph continues from where it letf off,  with full conversation history

5- Crear una lista de human message para simular una conversacion ficticia para probrar nuestro long-term memory en chat

# Use it with a thread_id
config = {"configurable": {"thread_id": "123"}}

conversation = [
    HumanMessage(content="Hola, soy Evert Escalante, Soy de Cucuta colombia y me gustaria ser product engineer"),
    HumanMessage(content="Cuentame lo minimo necesario para llevar un producto 'from zero to hero'"),
    HumanMessage(content="Cual es mi nombre?"),
    HumanMessage(content="Que me gustaria ser profesinalmente?"),
    HumanMessage(content="De que ciudad soy?")
]

6- Ejecuta nuestra conversacion ficticia usando nuestro workflow de langgraph

for msg in conversation:
  # Pass the message in the correct format expected by MessagesState
  response = app.invoke({"messages": [msg]}, config)

  # Pretty print the last message (the AI's response)
  response["messages"][-2].pretty_print()
  response["messages"][-1].pretty_print()

Memoria en chatbots: Implementación con ConversationBufferMemory

Introducción a LangChain

Creación de un sistema de preguntas y respuestas con LangChain

Estructura y Uso de Langchain en Python

Carga de Modelos Open Source con Langchain y Hugging Face

Uso de Modelos OpenAI con LangChain: Guía Práctica para Principiantes

Creación de Prompts Dinámicos con LangChain

Uso de Cadenas en Modelos de Lenguaje con Language Chain

Procesamiento de PDFs y creación de resúmenes con LangChain

Creación de Cadenas de Preguntas y Respuestas con Modelos de Lenguaje

Creación de cadenas secuenciales en Python para procesamiento de texto

Casos de uso de LangChain

Aplicaciones y Beneficios de Lancheng en el Manejo de LLMs

Implementación de Lanchain y LLMs: Costos, Privacidad y Buenas Prácticas

Manejo de documentos con índices

Carga de Documentos en Langchain para Creación de Índices

Fundamentos de la Clase Document en Langchain

Carga y Transformación de Documentos No Estructurados con Landship

Lectura de CSV y conversión a DataFrame de Pandas y LangChain

Creación de un Cargador de JSON-Lines Personalizado en Python

Fragmentación de Documentos con TextSplitter en Langsteam

Creación de un Chatbot con Documentación de Hugging Face

Creación de Índice Vectorial con Langchain y Embeddings

Embeddings y bases de datos vectoriales

Creación de Índices con Embeddings y Bases de Datos Vectoriales

Creación y uso de embeddings con OpenAI y Lanchain

Modelos de Embeddings Open Source en Español con Sentence Transformers

Creación y Gestión de Bases de Datos Vectoriales con Chroma

Creación y manejo de bases de datos vectoriales con OpenAI Embeddings

Creación y Uso de un Retriever en Chroma para Consultas Avanzadas

Modelo de Chat para Preguntas y Respuestas con LangChain y Chroma

Creación de un Chatbot para Preguntas con Bases de Datos Vectoriales

Chats y memoria con LangChain

Memoria de Corto Plazo en Chatbots: Implementación y Optimización

Creación y Uso de Modelos de Chat con OpenAI y LangChain

Creación de Plantillas Dinámicas para Prompts de Chat en Langstead

Memoria en chatbots: Implementación con ConversationBufferMemory

Configuración de ConversationBufferWindowMemory en Chatbots

Memoria de Resumen de Conversaciones con Chat GPT-3.5

Gestión de Memoria en Chatbots con ConversationSummaryBufferMemory

Memoria de Entidades en Chatbots para Soporte de Ventas

Implementación de Chatbot con Memoria en Python usando Langchain

Evolución del uso de LLM

Creación de Chatbots con Modelos de Lenguaje y Bases de Datos Vectoriales