> Discover all available pages from the documentation index: https://mastra.zisheng.pro/fr/llms.txt

# Stockage Redis

L'implémentation du stockage Redis fournit une solution de stockage hautes performances utilisant des connexions Redis directes au moyen de [`node-redis`](https://github.com/redis/node-redis) (le client Redis officiel pour Node.js). Elle prend en charge Redis autonome ainsi que, grâce à une configuration personnalisée du client, les déploiements Redis Sentinel et Cluster.

## Installation

```bash
npm install @mastra/redis
```

## Utilisation

### Utilisation d'une chaîne de connexion

```typescript
import { RedisStore } from '@mastra/redis'

const storage = new RedisStore({
  id: 'redis-storage',
  connectionString: 'redis://localhost:6379',
})

await storage.init()
```

### Utilisation d'une configuration hôte/port

```typescript
import { RedisStore } from '@mastra/redis'

const storage = new RedisStore({
  id: 'redis-storage',
  host: 'localhost',
  port: 6379,
  password: 'your-password',
  db: 0,
})

await storage.init()
```

### Utilisation d'un client préconfiguré

Pour les configurations avancées telles que Sentinel ou Cluster, vous pouvez transmettre un client Redis préconfiguré :

```typescript
import { RedisStore } from '@mastra/redis'
import { createClient } from 'redis'

const client = createClient({
  url: 'redis://localhost:6379',
  socket: {
    reconnectStrategy: retries => Math.min(retries * 50, 2000),
  },
})

// Connect the client before passing to RedisStore
await client.connect()

const storage = new RedisStore({
  id: 'redis-storage',
  client,
})
```

## Paramètres

**id** (`string`): Identifiant unique de l'instance de Storage

**connectionString** (`string`): URL de connexion Redis (par exemple, redis\://localhost:6379 ou redis\://:password\@localhost:6379)

**host** (`string`): Adresse de l'hôte Redis

**port** (`number`): Numéro de port Redis (Default: `6379`)

**password** (`string`): Mot de passe Redis pour l'authentification

**db** (`number`): Numéro de la base de données Redis (Default: `0`)

**client** (`RedisClient`): Client Redis préconfiguré (provenant du package redis) pour les configurations avancées

> **Remarque:** Vous devez fournir `connectionString`, `host` ou `client`. Ces options sont mutuellement exclusives.

## Remarques supplémentaires

### Structure des clés

L'implémentation du stockage Redis utilise les modèles de clés suivants :

- Fils de discussion : `mastra_threads:id:{threadId}`
- Messages : `mastra_messages:threadId:{threadId}:id:{messageId}`
- Index des messages : `msg-idx:{messageId}` (pour des recherches rapides)
- Ensemble trié des messages du fil : `thread:{threadId}:messages`
- Snapshots de Workflow : `mastra_workflow_snapshot:namespace:{ns}:workflow_name:{name}:run_id:{id}`
- Scores : `mastra_scorers:id:{scoreId}`
- Ressources : `mastra_resources:{resourceId}`

### Redis Sentinel

Pour les déploiements à haute disponibilité utilisant Redis Sentinel, créez un client personnalisé :

```typescript
import { RedisStore } from '@mastra/redis'
import { createClient } from 'redis'

const client = createClient({
  url: 'redis://sentinel-host:26379',
  // Configure sentinel options as needed for your setup
})

await client.connect()

const storage = new RedisStore({
  id: 'redis-sentinel-storage',
  client,
})
```

### Redis Cluster

Pour les déploiements Redis Cluster, utilisez le client de cluster :

```typescript
import { RedisStore } from '@mastra/redis'
import { createCluster } from 'redis'

const cluster = createCluster({
  rootNodes: [
    { url: 'redis://node-1:6379' },
    { url: 'redis://node-2:6379' },
    { url: 'redis://node-3:6379' },
  ],
})

await cluster.connect()

const storage = new RedisStore({
  id: 'redis-cluster-storage',
  client: cluster,
})
```

### Accès au client sous-jacent

Vous pouvez accéder au client Redis sous-jacent pour effectuer des opérations personnalisées :

```typescript
const storage = new RedisStore({
  id: 'redis-storage',
  connectionString: 'redis://localhost:6379',
})

await storage.init()

const client = storage.getClient()

// Custom Redis operations
await client.set('custom-key', 'value')
const value = await client.get('custom-key')
```

### Fermeture des connexions

Lors de l'arrêt de votre application, fermez la connexion Redis :

```typescript
await storage.close()
```

## Exemple d'utilisation

### Ajout de Memory à un Agent

```typescript
import { Memory } from '@mastra/memory'
import { Agent } from '@mastra/core/agent'
import { RedisStore } from '@mastra/redis'

export const redisAgent = new Agent({
  id: 'redis-agent',
  name: 'Redis Agent',
  instructions:
    'You are an AI agent with the ability to automatically recall memories from previous interactions.',
  model: 'openai/gpt-5.6-sol',
  memory: new Memory({
    storage: new RedisStore({
      id: 'redis-agent-storage',
      connectionString: process.env.REDIS_URL!,
    }),
    options: {
      lastMessages: 10,
    },
  }),
})
```

### Utilisation de l'Agent

```typescript
import 'dotenv/config'

import { mastra } from './mastra'

const threadId = '123'
const resourceId = 'user-456'

const agent = mastra.getAgent('redisAgent')

const message = await agent.stream('My name is Mastra', {
  memory: {
    thread: threadId,
    resource: resourceId,
  },
})

await message.textStream.pipeTo(new WritableStream())

const stream = await agent.stream("What's my name?", {
  memory: {
    thread: threadId,
    resource: resourceId,
  },
  memoryOptions: {
    lastMessages: 5,
  },
})

for await (const chunk of stream.textStream) {
  process.stdout.write(chunk)
}
```

### Utilisation avec une instance de Mastra

```typescript
import { Mastra } from '@mastra/core'
import { RedisStore } from '@mastra/redis'

const storage = new RedisStore({
  id: 'mastra-storage',
  host: 'localhost',
  port: 6379,
})

const mastra = new Mastra({
  storage, // init() called automatically
})
```

Si vous utilisez directement le Storage sans Mastra, appelez explicitement `init()` :

```typescript
import { RedisStore } from '@mastra/redis'

const storage = new RedisStore({
  id: 'redis-storage',
  host: 'localhost',
  port: 6379,
})

await storage.init()

// Access domain-specific stores via getStore()
const memoryStore = await storage.getStore('memory')
const thread = await memoryStore?.getThreadById({ threadId: '...' })
```