Memória da Superoptix: um guia prático para agentes de construção que se lembram

Os agentes modernos de IA não são apenas chatbots com prompt-in, resposta. Para se sentir coerente e genuinamente útil com o tempo, eles precisam se lembrar. A memória do agente é a capacidade que permite que um agente mantenha fatos, preferências, conversas e experiências entre turnos e sessões, para que todas as novas interações se beneficiem da história que veio antes dela. Com a memória, os agentes podem personalizar respostas, manter o contexto em tarefas de várias etapas e aprender com o feedback. Isso é essencial para os sistemas Agentic, e é por isso que a memória é um recurso de primeira classe no SuperOptix. A SuperOptix é uma estrutura de IA Agentic Stack, projetada para engenharia de contexto e agente, com uma filosofia de núcleo de otimização e otimização. Explore a plataforma no site da Superoptix. O DSL declarativo da estrutura, SuperSpec, permite descrever o que deseja e que a SuperOptix construa o pipeline; Saiba mais na página SuperSpec e na documentação SuperSpec. O que é a memória do agente? Conceitualmente, a memória é como os agentes constroem “continuidade do eu”. Concretamente, é uma combinação de mecanismos que armazenam e recuperam informações úteis: memória de curto prazo: memória de trabalho e histórico de conversas escassas de sessão-o que está acontecendo agora e nas últimas voltas. Memória de longo prazo: conhecimento durável que persiste nas sessões-fatos, preferências e padrões que o agente deve reter. Memória episódica: registros estruturados de interações e eventos ao longo do tempo – quem perguntou o que, o que o agente fez e como acabou. Gerente de contexto: uma disciplina para combinar o estado global, de sessão, tarefa e local em um contexto justo enviado ao modelo. Esse projeto em camadas equilibra imediatismo (curto prazo), durabilidade (de longo prazo), cronologia (episódica) e precisão (gerenciamento de contexto). O resultado é um agente que parece consistente, aprende com a experiência e permanece eficiente. Para um passeio conceitual e prático mais profundo, consulte o Guia do Sistema de Memória. Como o SuperOptix Memory Works SuperOptix fornece um poderoso modelo de memória de várias camadas que você pode usar via Python, via adaptadores DSPY configurados com configurações do tipo JSON, ou declarativamente através do SuperSpec (YAML). A memória de curto prazo captura o contexto de conversação rolante e as notas de trabalho. Use -o para o estado efêmero e as últimas n mensagens. A memória de longo prazo persiste o conhecimento com a pesquisa semântica opcional-orientação para as pistas (“sempre retorne o código executável”), preferências do usuário e fatos de domínio. Habilite incorporação, se você quiser recordar por significado, não apenas palavras -chave literais. A memória episódica rastreia episódios e eventos-excelente para análise e aprendizado (por exemplo, “Episódio resolvido com sucesso”, “Explicações baseadas em exemplo preferidas pelo usuário”). O gerente de contexto mescla o estado relevante nos escopos para criar instruções limpas e limitadas para o LLM. Escolher um back-end de memória Escolha o back-end que atenda às suas necessidades de implantação: Arquivo: Portátil, Zero-OPS JSON/Pickle Storage; Ótimo para demos e corridas locais rápidas. sqlite: banco de dados incorporado confiável; Padrão sensível para a maioria dos agentes. Redis: loja in-memória de alta rendimento para cargas de trabalho de produção. Use a memória do Python (API pública) abaixo são exemplos de uso apenas para trabalhar com memória em seu próprio código Python. De SuperOptix.Memory Import AgentMemory, FileBackend, SqliteBackend # Redisbackend também estará disponível se você instalar e configurar o redis # criar uma memória do agente (padrão para sqlite) Memory = agentMemory (agent_id = “Writer-Assistante”) # Termo: Termo: # shortcherdrcript, ephemeral Memory.Remember (“Usor-ASSISTANT”) # Termen: ttl = 3600) # de longo prazo: armazenar conhecimento durável com categorias/tags memória.remembert (“sempre forneça trechos de código executáveis”, memória_type = “long”, category = “autoring_guidelines”, tags =[“writing”, “code”, “quality”]
) # RECORD (Pesquisa semântica Se incorporação estiver ativada) Resultados = Memory.recall (“Código Runnable”, Memory_type = “Long”, Limit = 5) para R em Resultados: Imprimir (r (r (r[“content”]) # Rastreie um episódio de interação com eventos episódios_id = memória.START_INTERACION ({“user_id”: “alice”}) memória.add_interaction_event (“user_question”, “como configurar a memória) #”) # … gerar sua resposta … Memory.end_Interaction ({“succcess”: True}) # “) Memory.CleanUp_Memory () # Seleção de back-end explícita file_memory = AgentMemory (“File-Demo”, backend = FileBackend (“. SuperOptix/Memory”)) SQLITE_MEMORY = AGENTEMORY (“SQLITE-Demo”, backend = sqlitebackend (“… Os adaptadores DSPY (JSON) SuperOptix integra a memória em agentes baseados em DSPY por meio de adaptadores. Você não precisa conectar internos-fornecendo um ditado de configuração do tipo JSON (ou carregá-lo de um arquivo .json), e o adaptador: 1) recuperar memórias relevantes de longo prazo para a consulta, 2) incluem recentes trechos de conversas de curto prazo, 3) gerenciam episódios e eventos, 4) Persistentes úteis após respostas. Consulte a documentação do adaptador da DSPY para obter antecedentes no padrão do adaptador. Como os adaptadores DSPY se integrem à memória O adaptador DSPY cria um módulo de agente aprimorado pela memória que lida automaticamente no ciclo de vida completo da memória: inicialização da memória: quando você cria um DSPYADAPTER, ele instancia automaticamente um sistema AgentMemory baseado em sua configuração. O adaptador lê os sinalizadores Memory.Enabled e Memory.enable_embeddings para configurar o sistema de memória adequadamente. Módulo de agente aprimorado pela memória: o adaptador gera um módulo DSPY personalizado (MemoryHanedAgentModule) que envolve sua lógica do agente com operações de memória. Este módulo: inicia um episódio de interação quando o processamento começa recupera memórias relevantes antes de gerar respostas armazena o histórico de conversas e as idéias após a conclusão gerencia o processo de criação de contexto de ciclo de vida completo: Antes de enviar uma consulta para o contexto de limpeza e a memória do limite, a memória do limite, a memória de contornos, a memória de relevantes, a memória de relevantes relevantes, o contexto recente do contexto de um curto prazo Persistência: Após o LLM gera uma resposta, o adaptador: armazena o par de perguntas e respostas em memória de curto prazo para o contexto imediato adiciona a interação ao histórico de conversas registra eventos (consulta do usuário, resposta do agente) à memória episódica termina o episódio de interação “LLM” LLM “LLM (Salve.Irt.Ilfig.json) com” LLM “LLM” LLM “,” Salve “.Irt.Onfig.Json) {” “llama3.2: 1b”, “api_base”: “” temperatura “: 0.2},” persona “: {” name “:” MemoryDemo “,” Descrição “:” Demonstra a Memória de Memossed Memoratreen: Memorating FELLEREAN: MemoriMenseen Memoratren: MemoriMEnTeen Fellfreen: MemoriMEnTeen FELLSELEN: {“Enabled”: “Exabable_embeddings”:}}}}}}}, Opções de configuração adicionais: {“llm”: {“provedor”: “ollama”, “model”: “llama3.2: 1b”, “api_base”: “},” persona “: {” name “:” advancedMemoryBot “,” Descrição “:” Exemplo de memória avançada “}”, “Memory”: “MemoryBot”, “Descrição”: “Avançado Exemplo de memória”}, “Memory” “”: ” “short_term_capacity”: 200, “memory_retrieval”: { “max_memories”: 5, “min_similarity”: 0.3, “include_conversation_history”: true }, “episodic_tracking”: { “auto_start_episodes”: true, “event_logging”: true, “outcome_tracking”: true } } } Enter Modo de tela cheia O modo de tela cheia é executado com o adaptador DSPY importar json importar asyncio de superoptix.adapters.dspy_adapter importar dspyadapter # ou: de superoptix.adapters.observability_enhanced_dspy_adapter importa observabilityEnHancedddspyspater com o aberto (“agent.anhanced_dspy_adapter observabability),” fl). json.load (f) adaptador = dspyAdapter (config) # adaptador = observabilidadenhanceddspyAdapter (config) # Para rastreamento detalhado/depuração async def main (): resultado = aguardar {“context”: “consulta”: “lembre -me de que a memória do superespec”: “”: “:” Episódio}) Imprimir (resultado[“result”]) Print (“Estatísticas de memória:”, resultado.get (“memória_stats”) ou resultado.get (“observabilidade”, {}). get (“memória_stats”)) asyncio.run (main ()) digite a memória completa com o modo de memória fullcreen Modo Estatísticas de memória e monitoramento do retorno do adaptador Adaptor Compreciado para a memória com cada resposta: Seção … “,” Episódio_id “:” EP_12345 “,” Memory_Stats “: {” Interações “: 15,” Short_term_items “: 8,” Long_term_items “: 42,” Modo de tela de linha de observa de linha de observa de linha full. Operação da memória Rastreio de desempenho Métricas de desempenho para operações de memória Debug Points para integração de inspeção de memória com ferramentas externas de observabilidade (mlflow, langfuse) Dica: para estender a observabilidade, inclua: “Observabilidade”: {“debug_mode”: false, “trace_memory”: “Enable_breakts”: Falsel} ENTER FELLEME é DSL declarativo da Superoptix. Você descreve seu agente e a SuperOptix o compila com um pipeline DSPY executável. Aprenda sobre o SuperSpec na página SuperSpec e navegue pela documentação completa do SuperSpec. APIVERSION: Agente/V1 Kind: AGENTSPEC Metadata: Nome: Memory-Demo ID: Memory_Demo Namespace: Demo Nível: Genies Spec: Language_model: Local: Local Provedor: Ollama Modelo: LLAMA3.1: 8B API_BASE: 0,7 MAX_TOKENS: 2048 MEMABALIDADE: HORTH: Long_Term: Habiled: True Storage_type: Arquivo Local # | sqlite | Redis max_entries: 500 Persistência: True Episódico: Ativado: True max_episodes: 100 context_manager: habilitado: true max_context_length: 4000 context_strategy: sliding_window enter uma tela completa exite o modo de tela completa e execute o super cli. e execute o agente super agente compilar memória_demo super agente executar memória_demo –goal “Mostre -me como a memória funciona no SuperOptix” Digite o modo de saída de tela cheia da tela cheia para obter uma visão geral completa da plataforma SuperOptix, visite o site da SuperOptix. Para um mergulho profundo nos sistemas de memória e exemplos, consulte o Guia do Sistema de Memória. Padrões e dicas práticas começam com o sqlite para persistência; Use o arquivo para portabilidade simples; Use Redis para serviços de alto rendimento. Use a memória de curto prazo para rolar o contexto da conversa; Use memória de longo prazo para conhecimento durável com categorias e tags. Trate a memória episódica como seu backbone de análise: inicie episódios em torno de conversas/tarefas, eventos de log e termine com os resultados. Ativar incorporações quando precisar de um recall “por meio de significado”; Deixe-o para salvar o computação para pesquisas apenas com palavras-chave. Ligue periodicamente APIs de limpeza para serviços de longa data para manter a memória enxuta. Use o adaptador aprimorado de observabilidade para implantações de produção para monitorar o desempenho da memória e os problemas de depuração. Configure limites de recuperação de memória apropriados para equilibrar a riqueza de contexto com a eficiência imediata. Referências

Fonte