LangChain Parte 4: Aprovechamiento de la memoria y el almacenamiento en LangChain: una guía completa

El código se puede encontrar aquí: GitHub - jamesbmour/blog_tutorials:

En el mundo en constante evolución de la IA conversacional y los modelos de lenguaje, mantener el contexto y gestionar eficientemente el flujo de información son componentes críticos para crear aplicaciones inteligentes. LangChain, un potente marco diseñado para trabajar con grandes modelos de lenguaje (LLM), ofrece herramientas sólidas para la gestión de la memoria y la persistencia de los datos, lo que permite la creación de sistemas sensibles al contexto.

En esta guía, profundizaremos en los matices del aprovechamiento de la memoria y el almacenamiento en LangChain para crear aplicaciones más inteligentes y con mayor capacidad de respuesta.

1. Trabajar con memoria en LangChain

La gestión de la memoria en LangChain permite que las aplicaciones retengan el contexto, haciendo que las interacciones sean más coherentes y contextualmente relevantes. Exploremos los diferentes tipos de memoria y sus casos de uso.

1.1. Tipos de memoria

LangChain proporciona varios tipos de memoria para abordar diferentes escenarios. Aquí, nos centraremos en dos tipos de claves:

Memoria del búfer de conversación

Este tipo de memoria es ideal para retener el contexto a corto plazo, capturar y recordar interacciones recientes en una conversación.

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
memory.save_context({"input": "Hi, I'm Alice"}, {"output": "Hello Alice, how can I help you today?"})
memory.save_context({"input": "What's the weather like?"}, {"output": "I'm sorry, I don't have real-time weather information. Is there anything else I can help you with?"})

print(memory.load_memory_variables({}))

Resumen de conversaciónMemoria

Para conversaciones más largas, ConversationSummaryMemory es una excelente opción. Resume los puntos clave, manteniendo el contexto sin detalles abrumadores.

from langchain.memory import ConversationSummaryMemory
from langchain.llms import Ollama 

llm = Ollama(model='phi3',temperature=0)
memory = ConversationSummaryMemory(llm=llm)
memory.save_context({"input": "Hi, I'm Alice"}, {"output": "Hello Alice, how can I help you today?"})
memory.save_context({"input": "I'm looking for a good Italian restaurant"}, {"output": "Great! I'd be happy to help you find a good Italian restaurant. Do you have any specific preferences or requirements, such as location, price range, or specific dishes you're interested in?"})

print(memory.load_memory_variables({}))

1.2. Elegir el tipo de memoria adecuado para su caso de uso

La selección del tipo de memoria adecuado depende de varios factores:

• Duración y complejidad: las sesiones cortas se benefician de la retención detallada del contexto con ConversationBufferMemory, mientras que las interacciones a largo plazo pueden requerir un resumen a través de ConversationSummaryMemory.
• Detalle versus descripción general: determine si el historial de interacción detallado o los resúmenes de alto nivel son más valiosos para su aplicación.
• Rendimiento: considere las compensaciones entre el tamaño de la memoria y la velocidad de recuperación.

Casos de uso:

• ConversationBufferMemory: ideal para atención al cliente rápida o interacciones estilo preguntas frecuentes.
• ConversationSummaryMemory: más adecuado para compromisos a largo plazo, como gestión de proyectos o interacciones continuas con los clientes.

1.3. Integrando la memoria en cadenas y agentes

La memoria se puede integrar perfectamente en las cadenas y agentes de LangChain para mejorar las capacidades de conversación.

from langchain.chains import ConversationChain  
from langchain.memory import ConversationBufferMemory
# llm = OpenAI(temperature=0)
memory = ConversationBufferMemory()
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

conversation.predict(input="Hi, I'm Alice")
conversation.predict(input="What's my name?")

Este ejemplo ilustra cómo ConversationBufferMemory se puede utilizar para recordar interacciones anteriores, lo que permite conversaciones más naturales.

2. Persistencia y recuperación de datos

El almacenamiento persistente garantiza que el historial y el contexto de las conversaciones se mantengan en todas las sesiones, lo que permite la continuidad en las interacciones.

2.1. Almacenamiento del historial y el estado de la conversación

Para una persistencia básica, puedes usar almacenamiento basado en archivos con JSON:

import json

class PersistentMemory:
    def __init__(self, file_path):
        self.file_path = file_path
        self.load_memory()

    def load_memory(self):
        try:
            with open(self.file_path, 'r') as f:
                self.chat_memory = json.load(f)
        except FileNotFoundError:
            self.chat_memory = {'messages': []}

    def save_memory(self):
        with open(self.file_path, 'w') as f:
            json.dump({'messages': self.chat_memory['messages']}, f)

# Usage
memory = PersistentMemory(file_path='conversation_history.json')
print(memory.chat_memory)

Este método te permite conservar el historial de conversaciones en un formato simple y legible por humanos.

2.2. Integración con bases de datos y sistemas de almacenamiento

Para un almacenamiento más escalable y eficiente, se recomienda la integración con bases de datos como SQLite:

import sqlite3

class SQLiteMemory:
    def __init__(self, db_path):
        self.db_path = db_path
        self.conn = sqlite3.connect(db_path)
        self.create_table()

    def create_table(self):
        cursor = self.conn.cursor()
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS conversations
            (id INTEGER PRIMARY KEY, input TEXT, output TEXT)
        ''')
        self.conn.commit()

    def save_context(self, inputs, outputs):
        cursor = self.conn.cursor()
        cursor.execute('INSERT INTO conversations (input, output) VALUES (?, ?)',
                       (inputs['input'], outputs['output']))
        self.conn.commit()

    def load_memory_variables(self, inputs):
        cursor = self.conn.cursor()
        cursor.execute('SELECT input, output FROM conversations ORDER BY id DESC LIMIT 10')
        rows = cursor.fetchall()
        history = "\\n".join([f"Human: {row[0]}\\nAI: {row[1]}" for row in reversed(rows)])
        return {"history": history }

# Usage
memory = SQLiteMemory('conversation_history.db')

print(memory.load_memory_variables({}))

3 Optimización del uso y el rendimiento de la memoria

Para garantizar que su aplicación siga respondiendo, considere estas estrategias de optimización:

• Estructuras de datos eficientes: use estructuras como deque para administrar buffers de tamaño fijo.
• Estrategias de almacenamiento en caché: Reduzca las consultas a la base de datos implementando el almacenamiento en caché para los datos a los que se accede con frecuencia.
• Poda de datos: elimine o resuma datos antiguos periódicamente para mantener un tamaño de memoria manejable.

Aquí hay un ejemplo de una clase de memoria con almacenamiento en caché básico:

import time

class CachedSQLiteMemory(SQLiteMemory):
    def __init__(self, db_path, cache_ttl=60):
        super().__init__(db_path)
        self.cache = None
        self.cache_time = 0
        self.cache_ttl = cache_ttl

    def load_memory_variables(self, inputs):
        current_time = time.time()
        if self.cache is None or (current_time - self.cache_time) > self.cache_ttl:
            var = self.cache
            self.cache = super().load_memory_variables(inputs)
            self.cache_time = current_time
            return self.cache

memory = CachedSQLiteMemory('conversation_history.db', cache_ttl=30)

Esta implementación almacena en caché los resultados de las consultas de la base de datos durante un tiempo específico, lo que reduce la carga de la base de datos y mejora el rendimiento de las aplicaciones que acceden con frecuencia a los datos de la memoria.

Conclusión

La gestión eficaz de la memoria es la piedra angular de la creación de aplicaciones de IA conversacionales inteligentes y sensibles al contexto. LangChain proporciona un marco flexible y potente para administrar la memoria, lo que permite a los desarrolladores adaptar los tipos de memoria a casos de uso específicos, implementar soluciones de almacenamiento persistente y optimizar el rendimiento para aplicaciones a gran escala.

Al elegir el tipo de memoria adecuado, integrar el almacenamiento persistente y aprovechar técnicas avanzadas, como clases de memoria personalizadas y estrategias de almacenamiento en caché, puede crear sistemas de inteligencia artificial sofisticados que mantengan el contexto, mejoren la experiencia del usuario y funcionen de manera eficiente incluso a pesar de la escala y la complejidad. de interacciones crecen.

Con estas herramientas y técnicas a su disposición, está bien equipado para aprovechar todo el potencial de LangChain en la creación de aplicaciones de IA receptivas, inteligentes y contextualmente conscientes. Ya sea que esté desarrollando robots de atención al cliente, asistentes virtuales o sistemas conversacionales complejos, dominar la memoria y el almacenamiento en LangChain será un factor clave para su éxito.

Si quieres apoyar mis escritos o invitarme a una cerveza:
https://buymeacoffee.com/bmours