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

# Memory Hooks

> Intercept and modify memory operations with pre/post hooks

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

> [!NOTE]
>
> This page is about `Memory` operation hooks (`beforeStore`/`afterStore`/etc.). It is not the same as the standalone [Hooks Manager](https://praison.ai/docs/js/hooks-manager.md), whose events fire only when you call them yourself.

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph LR
    Mem[Memory] --> Hooks[Memory Hooks]
    Hooks --> Ops([Operations])

    classDef agent fill:#8B0000,stroke:#7C90A0,color:#fff
    classDef tool fill:#189AB4,stroke:#7C90A0,color:#fff

    class Mem,Hooks agent
    class Ops tool
    classDef agent fill:#8B0000,color:#fff
    classDef tool fill:#189AB4,color:#fff

```

## Quick Start

**1. Simple Usage**

```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
  }
});
```

**2. With Configuration**

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
const hooks = createMemoryHooks({
  beforeStore: async (key, value, metadata) => ({ key, value, metadata }),
  verbose: true,
});
```

## 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

> [card] [Memory](https://praison.ai/docs/js/memory.md)
>
> Memory system

> [card] [Sessions](https://praison.ai/docs/js/sessions.md)
>
> Session management

> [card] [Guardrails](https://praison.ai/docs/js/guardrails.md)
>
> Input/output validation


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.