Memória de Conversa

Sistemas de memória persistente para conversas de LLM, incluindo memória de curto prazo, de longo prazo e baseada em entidades.

Capacidades

• memória-de-curto-prazo
• memória-de-longo-prazo
• memória-de-entidade
• persistência-de-memória
• recuperação-de-memória
• consolidação-de-memória

Pré-requisitos

• Conhecimento: Padrões de conversação de LLM, Noções básicas de banco de dados, Armazenamento chave-valor
• Habilidades recomendadas: gerenciamento-de-janela-de-contexto, implementação-rag

Escopo

• Não abrange: Construção de grafo de conhecimento, Implementação de busca semântica, Administração de banco de dados
• Limites: O foco são os padrões de memória para LLMs, Abrange estratégias de armazenamento e recuperação.

Ecossistema

Ferramentas_primárias

• Mem0 - Camada de memória para aplicações de IA
• LangChain Memory - Utilitários de memória no LangChain
• Redis - Armazenamento de dados em memória para memória de sessão

Padrões

Sistema de Memória em Camadas

Diferentes camadas de memória para diferentes propósitos.

Quando usar: Ao construir qualquer IA conversacional.

interface MemorySystem {
    // Buffer: Current conversation (in context)
    buffer: ConversationBuffer;
    // Short-term: Recent interactions (session)
    shortTerm: ShortTermMemory;
    // Long-term: Persistent across sessions
    longTerm: LongTermMemory;
    // Entity: Facts about people, places, things
    entity: EntityMemory;
}

class TieredMemory implements MemorySystem {
    async addMessage(message: Message): Promise<void> {
        // Always add to buffer
        this.buffer.add(message);
        // Extract entities
        const entities = await extractEntities(message);
        for (const entity of entities) {
            await this.entity.upsert(entity);
        }
        // Check for memorable content
        if (await isMemoryWorthy(message)) {
            await this.shortTerm.add({
                content: message.content,
                timestamp: Date.now(),
                importance: await scoreImportance(message)
            });
        }
    }

    async consolidate(): Promise<void> {
        // Move important short-term to long-term
        const memories = await this.shortTerm.getOld(24 * 60 * 60 * 1000);
        for (const memory of memories) {
            if (memory.importance > 0.7 || memory.referenced > 2) {
                await this.longTerm.add(memory);
            }
            await this.shortTerm.remove(memory.id);
        }
    }

    async buildContext(query: string): Promise<string> {
        const parts: string[] = [];
        // Relevant long-term memories
        const longTermRelevant = await this.longTerm.search(query, 3);
        if (longTermRelevant.length) {
            parts.push('## Relevant Memories\n' +
                longTermRelevant.map(m => `- ${m.content}`).join('\n'));
        }
        // Relevant entities
        const entities = await this.entity.getRelevant(query);
        if (entities.length) {
            parts.push('## Known Entities\n' +
                entities.map(e => `- ${e.name}: ${e.facts.join(', ')}`).join('\n'));
        }
        // Recent conversation
        const recent = this.buffer.getRecent(10);
        parts.push('## Recent Conversation\n' + formatMessages(recent));

        return parts.join('\n\n');
    }
}

Memória de Entidade

Armazena e atualiza fatos sobre entidades.

Quando usar: Quando precisar lembrar detalhes sobre pessoas, lugares ou coisas.

interface Entity {
    id: string;
    name: string;
    type: 'person' | 'place' | 'thing' | 'concept';
    facts: Fact[];
    lastMentioned: number;
    mentionCount: number;
}
interface Fact {
    content: string;
    confidence: number;
    source: string;  // De qual mensagem isso veio
    timestamp: number;
}

class EntityMemory {
    async extractAndStore(message: Message): Promise<void> {
        // Usa LLM para extrair entidades e fatos
        const extraction = await llm.complete(`
            Extraia entidades e fatos desta mensagem.
            Retorne JSON: { "entities": [
                { "name": "...", "type": "...", "facts": ["..."] }
            ]}

            Mensagem: "${message.content}"
        `);
        const { entities } = JSON.parse(extraction);
        for (const entity of entities) {
            await this.upsert(entity, message.id);
        }
    }

    async upsert(entity: ExtractedEntity, sourceId: string): Promise<void> {
        const existing = await this.store.get(entity.name.toLowerCase());
        if (existing) {
            // Mescla fatos, evitando duplicatas

…