littleblacky/agenticforge/agenticforge-memory

import { randomUUID } from 'node:crypto';
import type { MemoryItem } from '@agenticforge/memory';
const item: MemoryItem = {
  id: randomUUID(),           // or crypto.randomUUID() in browser
  content: 'Hello world',
  memoryType: 'working',      // 'working' | 'episodic' | 'semantic' | 'perceptual'
  userId: 'default',
  timestamp: new Date(),
  importance: 0.6,            // 0.0 – 1.0
  metadata: { role: 'user' }, // arbitrary key-value pairs
};

import { WorkingMemory } from '@agenticforge/memory';
import { randomUUID } from 'node:crypto';
const memory = new WorkingMemory({
  workingMemoryCapacity: 20,    // max number of items
  workingMemoryTokens: 4000,    // max token budget
  workingMemoryTtlMinutes: 120, // TTL before expiry
});
// Add a message
const now = new Date();
await memory.add({
  id: randomUUID(),
  content: 'Hello',
  memoryType: 'working',
  userId: 'default',
  timestamp: now,
  importance: 0.6,
  metadata: { role: 'user' },
});
// Retrieve — returns items sorted newest-first
const recent = await memory.getRecent(10);   // last N items by timestamp
const important = await memory.getImportant(5); // top N by importance
const all = await memory.getAll();           // all items
const summary = await memory.getContextSummary(500); // text summary
// Semantic keyword search
const results = await memory.retrieve('RAG setup', 5);
// Clear
await memory.clear();

import { EpisodicMemory } from '@agenticforge/memory';
import { randomUUID } from 'node:crypto';
const memory = new EpisodicMemory({
  maxCapacity: 200,
});
await memory.add({
  id: randomUUID(),
  content: 'User asked about RAG setup',
  memoryType: 'episodic',
  userId: 'default',
  timestamp: new Date(),
  importance: 0.7,
  metadata: { tags: ['rag', 'setup'] },
});
// Retrieve by keyword
const results = await memory.retrieve('RAG', 5);
// Prune old/low-importance items
await memory.forget('importance_based', 0.3);
await memory.forget('time_based', 0.1, 30); // older than 30 days

import { SemanticMemory, InMemoryVectorStore } from '@agenticforge/memory';
import { randomUUID } from 'node:crypto';
// With in-memory vector store (dev/testing)
const memory = new SemanticMemory(
  {},
  { vectorStore: new InMemoryVectorStore() },
);
// Without adapters — pure in-process (simplest)
const memorySimple = new SemanticMemory();
await memorySimple.add({
  id: randomUUID(),
  content: 'The capital of France is Paris.',
  memoryType: 'semantic',
  userId: 'default',
  timestamp: new Date(),
  importance: 0.8,
  metadata: {},
});
// Retrieve by vector similarity
const results = await memorySimple.retrieve('What is the French capital?', 3);

import { createRagPipeline, InMemoryVectorStore } from '@agenticforge/kit';
const vectorStore = new InMemoryVectorStore();
const rag = createRagPipeline({ store: vectorStore, ragNamespace: 'docs' });
// Ingest documents
await rag.ingest([
  { content: 'AgenticFORGE is a TypeScript agent framework...', metadata: { source: 'README.md' } },
  { content: 'The Tool class wraps any async function...', metadata: { source: 'tools.md' } },
]);
// Retrieve relevant chunks
const results = await rag.retrieve('How do I create a tool?', { topK: 5 });
const context = results.map(r => r.content).join('\n\n');

import { MemoryManager } from '@agenticforge/memory';
const manager = new MemoryManager({
  userId: 'default',
  config: {
    workingMemoryCapacity: 30,
    maxCapacity: 200,
  },
  enableWorking: true,
  enableEpisodic: true,
  enableSemantic: true,
  enablePerceptual: false,
  // adapters: { vectorStore, kvStore, graphStore } — optional
});
// Add memory (auto-routes to correct sub-store)
await manager.addMemory({
  content: 'Tell me about RAG',
  memoryType: 'working',
  importance: 0.6,
  metadata: { role: 'user' },
});
// Auto-classify by importance
await manager.addMemory({
  content: 'RAG stands for Retrieval-Augmented Generation',
  importance: 0.9,
  autoClassify: true, // routes to semantic if importance >= 0.8
});
// Retrieve across all enabled types
const results = await manager.retrieveMemories({
  query: 'what is RAG',
  limit: 5,
  memoryTypes: ['working', 'semantic'],
  minImportance: 0.5,
});
// Stats
const stats = await manager.getMemoryStats();
// { totalMemories, enabledTypes, memoriesByType }
// Consolidate: move high-importance working memories to episodic
await manager.consolidateMemories({
  fromType: 'working',
  toType: 'episodic',
  importanceThreshold: 0.7,
});
// Forget low-importance items
await manager.forgetMemories({ strategy: 'importance_based', threshold: 0.2 });
// Clear all
await manager.clearAllMemories();