OrkaJS
Orka.JS

Mémoire & Sessions

Construisez des IA conversationnelles avec contexte persistant et sessions multi-utilisateurs.

La gestion de la mémoire permet à votre IA de maintenir le contexte de conversation, de se souvenir des préférences utilisateur et de gérer plusieurs sessions simultanées.

ORKA — MEMORY ARCHITECTURE
orka.memory()
Conversation Unique
user: My name is Thomas
assistant: Hello Thomas!
user: I'm looking for a laptop
maxMessages: 20
strategy: sliding_window
orka.sessions()
Sessions Multi-Utilisateurs
user-123
3 messages
user-456
5 messages
user-789
2 messages
TTL: 30 minutes
Auto-cleanup
sliding_window
Garder les N derniers
summary
Compresser les anciens
buffer
Tout garder

1. Mémoire de Conversation Simple

simple-memory.ts
import { createOrka, OpenAIAdapter, MemoryVectorAdapter } from 'orkajs';
 
const orka = createOrka({
llm: new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! }),
vectorDB: new MemoryVectorAdapter(),
memory: {
maxMessages: 20, // Maximum number of messages to keep
strategy: 'sliding_window', // 'sliding_window' | 'summary' | 'buffer'
},
});
 
// Create a memory instance
const memory = orka.memory();
 
// Add messages
memory.addMessage({ role: 'user', content: 'My name is Thomas.' });
memory.addMessage({ role: 'assistant', content: 'Hello Thomas! How can I help you?' });
memory.addMessage({ role: 'user', content: 'I'm looking for a laptop for development.' });
 
// Get history
const history = memory.getHistory();
for (const msg of history) {
console.log(`${msg.role}: ${msg.content}`);
}
 
// Clear memory
memory.clear();

2. Sessions Multi-Utilisateurs

multi-sessions.ts
// Create a sessions manager
const sessions = orka.sessions({
ttlMs: 30 * 60 * 1000, // 30 minutes TTL
maxSessions: 1000, // Max sessions in memory
});
 
// User session 1
sessions.addMessage('user-123', { role: 'user', content: 'Bonjour, je veux un remboursement.' });
sessions.addMessage('user-123', { role: 'assistant', content: 'Bien sûr, quel est votre numéro de commande ?' });
 
// User session 2 (independent)
sessions.addMessage('user-456', { role: 'user', content: 'Comment changer mon mot de passe ?' });
sessions.addMessage('user-456', { role: 'assistant', content: 'Allez dans Paramètres > Sécurité.' });
 
// Statistics
console.log(`Active sessions: ${sessions.getSessionCount()}`);
console.log(`Session user-123: ${sessions.getHistory('user-123').length} messages`);
console.log(`Session user-456: ${sessions.getHistory('user-456').length} messages`);
 
// Get history of a session
const userHistory = sessions.getHistory('user-123');
 
// Delete a session
sessions.deleteSession('user-123');
 
// Clean up expired sessions
sessions.cleanup();

3. Agent avec Mémoire de Conversation

agent-memory.ts
// Create an agent with built-in memory
const agent = orka.agent({
goal: 'Helping users with their questions',
tools: [{
name: 'search',
description: 'Search in the documentation',
parameters: [
{ name: 'query', type: 'string', description: 'Search term', required: true },
],
async execute(input) {
return { output: `Résultat pour "${input.query}": Documentation trouvée.` };
},
}],
maxSteps: 3,
memory: true, // Enable memory for the agent
});
 
// First interaction
const result1 = await agent.run('My name is Thomas and I'm looking for a laptop.');
console.log(`Agent: ${result1.output}`);
 
// The agent remembers the previous context
const result2 = await agent.run('What is my name?');
console.log(`Agent: ${result2.output}`); // "Your name is Thomas"
 
// Clear the agent's memory
agent.clearMemory();

4. Exemple Complet

memory-complete.ts
import { createOrka, OpenAIAdapter, MemoryVectorAdapter } from 'orkajs';
 
async function main() {
const orka = createOrka({
llm: new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! }),
vectorDB: new MemoryVectorAdapter(),
memory: {
maxMessages: 20,
strategy: 'sliding_window',
},
});
 
// === Simple memory ===
console.log('💬 Chat with memory\n');
 
const memory = orka.memory();
memory.addMessage({ role: 'user', content: 'My name is Thomas.' });
memory.addMessage({ role: 'assistant', content: 'Hello Thomas!' });
memory.addMessage({ role: 'user', content: 'Je cherche un laptop.' });
 
console.log('Historique:');
for (const msg of memory.getHistory()) {
console.log(` ${msg.role}: ${msg.content}`);
}
 
// === Sessions multiples ===
console.log('\n📋 Sessions multiples\n');
 
const sessions = orka.sessions();
 
sessions.addMessage('user-123', { role: 'user', content: 'Bonjour, remboursement svp.' });
sessions.addMessage('user-123', { role: 'assistant', content: 'Numéro de commande ?' });
 
sessions.addMessage('user-456', { role: 'user', content: 'Mot de passe oublié.' });
sessions.addMessage('user-456', { role: 'assistant', content: 'Paramètres > Sécurité.' });
 
console.log(`Sessions actives: ${sessions.getSessionCount()}`);
console.log(`user-123: ${sessions.getHistory('user-123').length} messages`);
console.log(`user-456: ${sessions.getHistory('user-456').length} messages`);
 
// === Agent with memory ===
console.log('\n🤖 Agent with memory\n');
 
const agent = orka.agent({
goal: 'Helping users',
tools: [{
name: 'search',
description: 'Search documentation',
async execute(input) {
return { output: `Result for "${input.query}".` };
},
}],
maxSteps: 3,
});
 
const result = await agent.run('Remember that my name is Thomas.');
console.log(`Agent: ${result.output}`);
}
 
main().catch(console.error);

Stratégies de Mémoire

sliding_window

Garde les N derniers messages, supprime les plus anciens.

Idéal pour: La plupart des cas

summary

Compresse les anciens messages en résumé pour économiser des tokens.

Idéal pour: Longues conversations

buffer

Garde tous les messages sans aucune troncature.

Idéal pour: Sessions courtes