Mémoire Conversationnelle

import { Memory } from '@orka-js/memory-store';
 
const memory = new Memory({
  maxMessages: 50,           // Keep at most 50 messages
  strategy: 'sliding_window' // Trimming strategy
});
 
// Add messages to the conversation
memory.addMessage({ role: 'user', content: 'My name is Alice.' });
memory.addMessage({ role: 'assistant', content: 'Hello Alice! How can I help you today?' });
memory.addMessage({ role: 'user', content: 'What is my name?' });
 
// Get the full history
const history = memory.getHistory();
/*
[
  { role: 'user', content: 'My name is Alice.', timestamp: 1708000000000 },
  { role: 'assistant', content: 'Hello Alice! How can I help you today?', timestamp: 1708000001000 },
  { role: 'user', content: 'What is my name?', timestamp: 1708000002000 }
]
*/
 
// Clear the conversation
memory.clear();

import { SessionMemory } from '@orka-js/memory-store';
 
const sessions = new SessionMemory({
  maxMessages: 50,           // Per-session message limit
  strategy: 'sliding_window',
  ttlMs: 3600_000,           // Sessions expire after 1 hour of inactivity
});
 
// User A's conversation
sessions.addMessage('user-alice', { role: 'user', content: 'Hello!' });
sessions.addMessage('user-alice', { role: 'assistant', content: 'Hi Alice!' });
 
// User B's conversation (completely separate)
sessions.addMessage('user-bob', { role: 'user', content: 'Help me with my order.' });
sessions.addMessage('user-bob', { role: 'assistant', content: 'Of course! What is your order ID?' });
 
// Retrieve history by session ID
const aliceHistory = sessions.getHistory('user-alice');
const bobHistory = sessions.getHistory('user-bob');
 
// List all active sessions
console.log(sessions.getActiveSessions()); // ['user-alice', 'user-bob']
 
// Clear a specific session
sessions.clearSession('user-alice');
 
// Clear all sessions
sessions.clearAll();

import { createOrka, OpenAIAdapter, MemoryVectorAdapter } from 'orkajs';
 
const orka = createOrka({
  llm: new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! }),
  vectorDB: new MemoryVectorAdapter(),
  memory: {
    maxMessages: 50,           // Maximum messages to keep
    maxTokensEstimate: 4000,   // For 'buffer' strategy
    strategy: 'sliding_window', // 'sliding_window' | 'buffer' | 'summary'
  },
});
 
// Access memory directly
const memory = orka.memory();
memory.addMessage({ role: 'user', content: 'Hello!' });
 
// Or use with ask() - memory is automatically managed
const response = await orka.ask({
  question: 'What did I say earlier?',
  useMemory: true, // Injects conversation history into the prompt
});

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,
  maxMessages: 100,  // High limit - we'll compress manually
  progressiveCompression: true,
});
 
// Add messages to the conversation
await memory.addMessage({ role: 'user', content: 'Let me explain the project requirements...' });
await memory.addMessage({ role: 'assistant', content: 'I understand. Please go ahead.' });
// ... many more messages ...
 
// Compress on-demand when needed
const result = await memory.compress();
 
console.log(result);
// {
//   success: true,
//   reason: 'Compression completed successfully',
//   summary: 'User explained project requirements including...',
//   messagesCompressed: 15,
//   tokensSaved: 850,
//   compressedAt: 1708000000000
// }
 
// The history now contains the summary + any preserved system messages
const history = memory.getHistory();

import { ReActAgent, createCompactConversationTool, COMPACT_CONVERSATION_PROMPT_ADDITION } from '@orka-js/agent';
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, maxMessages: 100 });
 
// Create the compact conversation tool
const compactTool = createCompactConversationTool({
  compress: async () => {
    const result = await memory.compress();
    return {
      success: result.success,
      reason: result.reason,
      summary: result.summary,
      messagesCompressed: result.messagesCompressed,
      tokensSaved: result.tokensSaved,
      compressedAt: result.compressedAt,
    };
  },
});
 
// Create agent with the tool
const agent = new ReActAgent({
  llm,
  goal: 'Help users with complex multi-step tasks',
  tools: [compactTool, ...otherTools],
  // Add guidance for when to use the tool
  systemPrompt: `You are a helpful assistant.
${COMPACT_CONVERSATION_PROMPT_ADDITION}`,
});
 
// The agent can now autonomously decide to compress context
// Example: "I notice we've been discussing multiple topics. Let me compact 
// the conversation to preserve the key points before we continue."
const result = await agent.run('Help me plan my project');