Types de Mémoire Avancés

Stockage avancé via Summary, Vector et KG Memory pour les contextes longs etl'intelligence sémantique.

Vue d'ensemble

OrkaJS fournit trois types de mémoire avancés pour gérer les longues conversations plus intelligemment qu'une simple fenêtre glissante :

Classe de Mémoire	Objectif Stratégique	Infrastructure
SummaryMemory	Condensation récursive des longs échanges	LLM Orchestrator
VectorMemory	Récupération sémantique via RAG	Embeddings + VectorDB
KGMemory	Cartographie des relations (Ontologie)	LLM + GraphDB

# SummaryMemory

SummaryMemory compresse automatiquement les anciens messages en un résumé en utilisant un LLM. Cela préserve le contexte tout en réduisant l'utilisation de tokens pour les très longues conversations.

import { SummaryMemory } from '@orka-js/memory-store';
import { OpenAIAdapter } from '@orka-js/openai';
 
const llm = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! });
 
const memory = new SummaryMemory({
  llm: { generate: (prompt) => llm.generate(prompt) },
  maxMessages: 20,           // Keep at most 20 recent messages
  summaryThreshold: 10,      // Summarize when 10+ messages overflow
  summaryMaxLength: 1000,    // Max summary length in characters
  progressiveCompression: true, // Update summary incrementally
});
 
// Add messages normally
await memory.addMessage({ role: 'user', content: 'My name is Alice.' });
await memory.addMessage({ role: 'assistant', content: 'Hello Alice!' });
// ... more messages ...
 
// When messages exceed maxMessages, old ones are summarized
const history = memory.getHistory();
// Returns: [{ role: 'system', content: '[Summary]...' }, ...recent messages]
 
// Get just the summary
const summary = memory.getSummary();
 
// Force summarization even below threshold
await memory.forceSummarize();

- Config SummaryMemory

Configuration du Moteur de Résumé

Recursive Distillation & Token Economy

llmIntelligence

BaseLLM

Le modèle responsable de la condensation sémantique de l'historique.

progressiveCompressionStrategy

boolean

Mises à jour itératives. Ajoute le contexte au résumé existant pour économiser des tokens.

compressionRatioThreshold

number

Échelle de réduction cible. Définit quel pourcentage du buffer est condensé.

# VectorMemory

VectorMemory stocke l'historique de conversation sous forme d'embeddings dans une base vectorielle, permettant la recherche sémantique pour récupérer les messages passés pertinents basés sur la requête actuelle.

import { VectorMemory } from '@orka-js/memory-store';
import { OpenAIAdapter } from '@orka-js/openai';
import { MemoryVectorAdapter } from '@orka-js/memory';
 
const openai = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! });
const vectorDB = new MemoryVectorAdapter();
 
const memory = new VectorMemory({
  embeddings: {
    embed: (text) => openai.embed(text),
    embedBatch: (texts) => openai.embedBatch(texts),
  },
  vectorDB: {
    add: (vectors, docs, meta) => vectorDB.add(vectors, docs, meta),
    search: (vector, topK) => vectorDB.search(vector, topK),
    delete: (ids) => vectorDB.delete(ids),
  },
  maxMessages: 100,
  searchTopK: 5,
  similarityThreshold: 0.7,
});
 
// Add messages (automatically embedded and stored)
await memory.addMessage({ role: 'user', content: 'I love hiking in the mountains.' });
await memory.addMessage({ role: 'assistant', content: 'That sounds great! Do you have a favorite trail?' });
await memory.addMessage({ role: 'user', content: 'Yes, I often go to Mount Rainier.' });
 
// Later in the conversation...
// Search for relevant past messages
const results = await memory.search('outdoor activities');
// Returns messages about hiking, mountains, trails
 
// Get relevant history with surrounding context
const context = await memory.searchWithContext('What did I say about mountains?');
 
// Get messages relevant to a query
const relevant = await memory.getRelevantHistory('hiking trails');

Récupération Stratégique du Contexte

Optimization: Cost vs. Relevance

VectorMemory comble le fossé entre les volumes massifs de données historiques et les fenêtres de contexte limitées. Elle permet un rappel à long terme sans le coût linéaire du traitement intégral.

RAGEmbeddingsSemantic SearchCost Reduction

L'Avantage Vectoriel

Historique Infini
Pertinence Sémantique
Économie de Tokens

# KGMemory (Knowledge Graph)

KGMemory extrait les entités et relations des conversations pour construire un graphe de connaissances. Cela permet des requêtes structurées sur ce qui a été discuté.

import { KGMemory } from '@orka-js/memory-store';
import { OpenAIAdapter } from '@orka-js/openai';
 
const llm = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! });
 
const memory = new KGMemory({
  llm: { generate: (prompt) => llm.generate(prompt) },
  maxMessages: 100,
  maxTriples: 500,
  extractionBatchSize: 5, // Extract after every 5 messages
});
 
// Add messages - entities and relations are automatically extracted
await memory.addMessage({ role: 'user', content: 'I work at Acme Corp as a software engineer.' });
await memory.addMessage({ role: 'assistant', content: 'Nice! What technologies do you use at Acme?' });
await memory.addMessage({ role: 'user', content: 'We mainly use TypeScript and Python.' });
 
// Get extracted entities
const entities = memory.getEntities();
// [{ name: 'User', type: 'PERSON' }, { name: 'Acme Corp', type: 'ORGANIZATION' }, ...]
 
// Get relations
const relations = memory.getRelations();
// [{ subject: 'User', predicate: 'works at', object: 'Acme Corp' }, ...]
 
// Query the knowledge graph
const context = await memory.queryKnowledge('Where does the user work?');
// Returns: "The user works at Acme Corp as a software engineer."
 
// Get context for a new query
const messages = await memory.getContextForQuery('What programming languages?');
// Returns KG context + recent messages

Interface du Moteur KGMemory

Graph Extraction & Semantic Querying

getEntities()Entities

returns: Entity[]

Récupère la taxonomie des acteurs, lieux ou concepts extraits avec leurs métadonnées.

getRelations()Topology

returns: Relation[]

Extrait l'épine dorsale sémantique (triplets S-P-O) définissant l'interaction entre entités.

queryKnowledge()Inference

returns: Promise<string>

Parcourt le graphe pour synthétiser une réponse factuelle basée sur l'ontologie stockée.

getGraphSummary()Telemetry

returns: object

Fournit un audit de la densité du graphe, du nombre de nœuds et de la profondeur des liens.

Choisir le Bon Type de Mémoire

Scénario de Contexte	Moteur Recommandé	Charge Cognitive
Échanges éphémères ou courts (<50 msgs)	Memory (Sliding Window)	Minimal
Historique profond avec rétention de contexte	SummaryMemory	Moderate
Besoin de retrouver des faits par similarité	VectorMemory (RAG)	High
Cartographie ontologique complexe (Faits/Règles)	KGMemory (Graph)	Expert

Imports Tree-shakeable

// Import only what you need
import { SummaryMemory } from '@orka-js/memory-store';
import { VectorMemory } from '@orka-js/memory-store';
import { KGMemory } from '@orka-js/memory-store';
 
// Or import from orkajs meta-package
import { SummaryMemory, VectorMemory, KGMemory } from '@orka-js/memory-store';