> ## Documentation Index
> Fetch the complete documentation index at: https://docs.praison.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Memory Hooks

> Intercept and modify memory operations with pre/post hooks

# Memory Hooks

Intercept memory operations with hooks. Log access, validate data, encrypt content, and implement custom caching.

## Create Memory Hooks

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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
  }
});
```

## Logging Hooks

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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](/docs/js/memory) - Memory system
* [Sessions](/docs/js/sessions) - Session management
* [Guardrails](/docs/js/guardrails) - Input/output validation