LangChain Parte 4 - Aproveitando memória e armazenamento em LangChain: um guia abrangente

O código pode ser encontrado aqui: GitHub - jamesbmour/blog_tutorials:

No mundo em constante evolução da IA ​​conversacional e dos modelos de linguagem, manter o contexto e gerenciar com eficiência o fluxo de informações são componentes essenciais para a construção de aplicativos inteligentes. LangChain, um framework poderoso projetado para trabalhar com grandes modelos de linguagem (LLMs), oferece ferramentas robustas para gerenciamento de memória e persistência de dados, permitindo a criação de sistemas sensíveis ao contexto.

Neste guia, nos aprofundaremos nas nuances do aproveitamento de memória e armazenamento no LangChain para construir aplicativos mais inteligentes e responsivos.

1. Trabalhando com memória em LangChain

O gerenciamento de memória no LangChain permite que os aplicativos retenham o contexto, tornando as interações mais coerentes e contextualmente relevantes. Vamos explorar os diferentes tipos de memória e seus casos de uso.

1.1. Tipos de memória

LangChain fornece vários tipos de memória para lidar com diferentes cenários. Aqui, vamos nos concentrar em dois tipos principais:

ConversationBufferMemory

Esse tipo de memória é ideal para retenção de contexto de curto prazo, capturando e relembrando interações recentes em uma conversa.

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({}))

ConversationSummaryMemory

Para conversas mais longas, ConversationSummaryMemory é uma ótima escolha. Ele resume os pontos principais, mantendo o contexto sem detalhes excessivos.

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. Escolhendo o tipo de memória certo para seu caso de uso

A seleção do tipo de memória apropriado depende de vários fatores:

• Duração e complexidade: Sessões curtas se beneficiam da retenção detalhada de contexto com ConversationBufferMemory, enquanto interações de longo prazo podem exigir resumo via ConversationSummaryMemory.
• Detalhes versus visão geral: determine se o histórico de interação detalhado ou resumos de alto nível são mais valiosos para seu aplicativo.
• Desempenho: considere as compensações entre o tamanho da memória e a velocidade de recuperação.

Casos de uso:

• ConversationBufferMemory: Ideal para suporte rápido ao cliente ou interações no estilo FAQ.
• ConversationSummaryMemory: Mais adequado para compromissos de longo prazo, como gerenciamento de projetos ou interações contínuas com clientes.

1.3. Integrando Memória em Cadeias e Agentes

A memória pode ser perfeitamente integrada às cadeias e agentes LangChain para aprimorar os recursos de conversação.

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 exemplo ilustra como ConversationBufferMemory pode ser usado para lembrar interações anteriores, permitindo conversas mais naturais.

2. Persistência e recuperação de dados

O armazenamento persistente garante que o histórico e o contexto da conversa sejam mantidos entre as sessões, permitindo a continuidade nas interações.

2.1. Armazenando o histórico e o estado da conversa

Para persistência básica, você pode usar armazenamento baseado em arquivo com 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 permite que você persista o histórico de conversas em um formato simples e legível.

2.2. Integração com bancos de dados e sistemas de armazenamento

Para um armazenamento mais escalável e eficiente, recomenda-se a integração com bancos de dados 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 Otimizando o uso e o desempenho da memória

Para garantir que seu aplicativo permaneça responsivo, considere estas estratégias de otimização:

• Estruturas de dados eficientes: Use estruturas como deque para gerenciar buffers de tamanho fixo.
• Estratégias de cache: Reduza as consultas ao banco de dados implementando o cache para dados acessados ​​com frequência.
• Remoção de dados: remova ou resuma regularmente dados antigos para manter um tamanho de memória gerenciável.

Aqui está um exemplo de classe de memória com cache 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 implementação armazena em cache os resultados das consultas ao banco de dados por um tempo especificado, reduzindo a carga no banco de dados e melhorando o desempenho de aplicativos que acessam frequentemente dados de memória.

Conclusão

O gerenciamento eficaz de memória é a base da construção de aplicativos de IA conversacionais inteligentes e com reconhecimento de contexto. LangChain fornece uma estrutura flexível e poderosa para gerenciamento de memória, permitindo que os desenvolvedores adaptem os tipos de memória para casos de uso específicos, implementem soluções de armazenamento persistente e otimizem o desempenho para aplicativos de grande escala.

Ao escolher o tipo de memória certo, integrar armazenamento persistente e aproveitar técnicas avançadas, como classes de memória personalizadas e estratégias de cache, você pode construir sistemas de IA sofisticados que mantêm o contexto, melhoram a experiência do usuário e operam com eficiência, mesmo com a escala e a complexidade de interações crescem.

Com essas ferramentas e técnicas à sua disposição, você está bem equipado para aproveitar todo o potencial do LangChain na criação de aplicativos de IA responsivos, inteligentes e contextualmente conscientes. Esteja você desenvolvendo bots de suporte ao cliente, assistentes virtuais ou sistemas de conversação complexos, dominar a memória e o armazenamento no LangChain será um fator chave para o seu sucesso.

Se você gostaria de apoiar minha escrita ou me comprar uma cerveja:
https://buymeacoffee.com/bmours