Quick Start
1
Simple Usage
import { MemoryHooks, createMemoryHooks } from 'praisonai';
const hooks = createMemoryHooks({
beforeStore: async (key, value, metadata) => {
console.log(`Storing: ${key}`);
// Can modify or cancel
return { key, value, metadata };
},
afterStore: async (key, value) => {
console.log(`Stored: ${key}`);
},
beforeRetrieve: async (key) => {
console.log(`Retrieving: ${key}`);
return key; // Can modify key
},
afterRetrieve: async (key, value) => {
console.log(`Retrieved: ${key}`);
return value; // Can modify value
}
});
2
With Configuration
const hooks = createMemoryHooks({
beforeStore: async (key, value, metadata) => ({ key, value, metadata }),
verbose: true,
});
Logging Hooks
import { createLoggingHooks } from 'praisonai';
// Create hooks that log all operations
const loggingHooks = createLoggingHooks((msg) => {
console.log(`[Memory] ${msg}`);
});
// All memory operations will be logged:
// [Memory] Storing: user-preferences
// [Memory] Stored: user-preferences
// [Memory] Retrieving: user-preferences
// [Memory] Retrieved: user-preferences (found)
Validation Hooks
import { createValidationHooks } from 'praisonai';
// Create hooks that validate before storing
const validationHooks = createValidationHooks((key, value) => {
// Reject empty values
if (!value || value.trim() === '') {
return { valid: false, reason: 'Empty values not allowed' };
}
// Reject keys with special characters
if (/[^a-zA-Z0-9_-]/.test(key)) {
return { valid: false, reason: 'Invalid key format' };
}
return { valid: true };
});
Encryption Hooks
import { createEncryptionHooks } from 'praisonai';
import crypto from 'crypto';
const key = crypto.randomBytes(32);
const iv = crypto.randomBytes(16);
function encrypt(data: any): string {
const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
const json = JSON.stringify(data);
return cipher.update(json, 'utf8', 'hex') + cipher.final('hex');
}
function decrypt(data: string): any {
const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
const json = decipher.update(data, 'hex', 'utf8') + decipher.final('utf8');
return JSON.parse(json);
}
const encryptionHooks = createEncryptionHooks(encrypt, decrypt);
// All stored values are encrypted, all retrieved values are decrypted
Use with Memory
import { Memory, MemoryHooks } from 'praisonai';
const hooks = new MemoryHooks({
logging: true, // Enable built-in logging
beforeStore: async (key, value) => {
// Add timestamp to all stored values
return {
key,
value: { ...value, storedAt: Date.now() }
};
}
});
const memory = new Memory({
hooks,
maxSize: 1000
});
await memory.set('user', { name: 'John' });
// Logged: [MemoryHooks] beforeStore: user
// Logged: [MemoryHooks] afterStore: user
Dynamic Hook Management
import { MemoryHooks } from 'praisonai';
const hooks = new MemoryHooks();
// Add hooks dynamically
hooks.addHook('beforeStore', async (key, value) => {
console.log(`Dynamic hook: ${key}`);
return { key, value };
});
// Remove hooks
hooks.removeHook('beforeStore');
// Enable/disable logging
hooks.setLogging(true);
// Get current configuration
const config = hooks.getConfig();
Hook Types
| Hook | When Called | Can Modify |
|---|---|---|
beforeStore | Before storing value | Key, value, metadata, or cancel |
afterStore | After successful store | Nothing (side effects only) |
beforeRetrieve | Before retrieving value | Key or cancel |
afterRetrieve | After retrieval | Return value |
beforeDelete | Before deleting value | Proceed or cancel |
afterDelete | After deletion | Nothing (side effects only) |
beforeSearch | Before search query | Query and options |
afterSearch | After search | Results |
Complete Example
import { Agent, Memory, MemoryHooks, createLoggingHooks } from 'praisonai';
// Combine multiple hook behaviors
const hooks = new MemoryHooks({
logging: true,
beforeStore: async (key, value) => {
// Validate
if (typeof value !== 'string' && typeof value !== 'object') {
console.warn(`Invalid value type for ${key}`);
return null; // Cancel store
}
return { key, value };
},
afterRetrieve: async (key, value) => {
// Track access
console.log(`Memory accessed: ${key}`);
return value;
}
});
const memory = new Memory({ hooks });
const agent = new Agent({
name: 'Hooked Agent',
instructions: 'You use memory with full hooks.',
memory
});
Related
Memory
Memory system
Sessions
Session management
Guardrails
Input/output validation