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

# WorkingMemory

`WorkingMemory` est un **Processor d'entrée** qui injecte les données de la mémoire de travail sous la forme d'un message système. Il récupère les informations persistantes dans le stockage et les met en forme comme instructions pour le LLM, ce qui permet à l'Agent de conserver le contexte relatif aux utilisateurs d'une conversation à l'autre.

## Exemple d'utilisation

```typescript
import { WorkingMemory } from '@mastra/core/processors'

const processor = new WorkingMemory({
  storage: memoryStorage,
  scope: 'resource',
  template: {
    format: 'markdown',
    content: `# User Profile
- **Name**:
- **Preferences**:
- **Goals**:
`,
  },
})
```

## Paramètres du constructeur

**options** (`Options`): Options de configuration du Processor de mémoire de travail

**options.storage** (`MemoryStorage`): Instance de stockage permettant de récupérer les données de la mémoire de travail

**options.template** (`WorkingMemoryTemplate`): Modèle qui définit le format et la structure de la mémoire de travail

**options.template.format** (`'markdown' | 'json'`): Format du contenu de la mémoire de travail

**options.template.content** (`string`): Contenu du modèle qui définit la structure des données de la mémoire de travail

**options.scope** (`'thread' | 'resource'`): Portée de la mémoire de travail. 'thread' la limite au thread actuel, tandis que 'resource' la partage entre tous les threads de la ressource

**options.useVNext** (`boolean`): Utilise le format d'instructions de nouvelle génération avec des recommandations améliorées

**options.readOnly** (`boolean`): Lorsque la valeur est true, la mémoire de travail est fournie comme contexte en lecture seule. Les données sont injectées dans la conversation, mais sans le Tool updateWorkingMemory ni les instructions de mise à jour. Utile pour les Agents qui doivent consulter la mémoire de travail sans la modifier.

**options.templateProvider** (`{ getWorkingMemoryTemplate(args: { memoryConfig?: MemoryConfig }): Promise<WorkingMemoryTemplate | null> }`): Provider de modèle dynamique pour la résolution du modèle lors de l'exécution

**options.logger** (`IMastraLogger`): Instance facultative du Logger pour une journalisation structurée

## Valeur renvoyée

**id** (`string`): Identifiant du Processor défini sur 'working-memory'

**name** (`string`): Nom d'affichage du Processor défini sur 'WorkingMemory'

**defaultWorkingMemoryTemplate** (`string`): Modèle Markdown par défaut utilisé lorsqu'aucun modèle personnalisé n'est fourni

**processInput** (`(args: { messages: MastraDBMessage[]; messageList: MessageList; abort: (reason?: string) => never; requestContext?: RequestContext }) => Promise<MessageList | MastraDBMessage[]>`): Récupère la mémoire de travail et l’ajoute comme message système à la liste des messages

## Exemple d'utilisation avancée

```typescript
import { Agent } from '@mastra/core/agent'
import { WorkingMemory, MessageHistory } from '@mastra/core/processors'
import { PostgresStorage } from '@mastra/pg'

const storage = new PostgresStorage({
  connectionString: process.env.DATABASE_URL,
})

export const agent = new Agent({
  id: 'personalized-agent',
  name: 'personalized-agent',
  instructions: 'You are a helpful assistant that remembers user preferences',
  model: 'openai/gpt-5.6-sol',
  inputProcessors: [
    new WorkingMemory({
      storage,
      scope: 'resource',
      template: {
        format: 'markdown',
        content: `# User Information
- **Name**:
- **Location**:
- **Preferences**:
- **Communication Style**:
- **Current Projects**:
`,
      },
    }),
    new MessageHistory({ storage, lastMessages: 50 }),
  ],
  outputProcessors: [new MessageHistory({ storage })],
})
```

## Exemple au format JSON

```typescript
import { WorkingMemory } from '@mastra/core/processors'

const processor = new WorkingMemory({
  storage: memoryStorage,
  scope: 'resource',
  template: {
    format: 'json',
    content: JSON.stringify({
      user: {
        name: { type: 'string' },
        preferences: { type: 'object' },
        goals: { type: 'array' },
      },
    }),
  },
})
```

## Comportement

### Traitement de l'entrée

1. Récupère `threadId` et `resourceId` dans le contexte de requête

2. Selon la portée, récupère la mémoire de travail depuis :

   - Les métadonnées du thread (`scope: 'thread'`)
   - L'enregistrement de la ressource (`scope: 'resource'`)

3. Résout le modèle (à partir du Provider, des options ou de la valeur par défaut)

4. Génère les instructions système selon le mode :

   - **Mode normal** : inclut les recommandations pour stocker et mettre à jour les informations, la structure du modèle et les données actuelles
   - **Mode lecture seule** (`readOnly: true`) : inclut uniquement les données actuelles comme contexte, sans instructions de mise à jour

5. Ajoute l'instruction comme message système avec le tag `source: 'memory'`

### Mises à jour de la mémoire de travail

Les mises à jour de la mémoire de travail s'effectuent au moyen du Tool `updateWorkingMemory` fourni par la classe Memory, et non au moyen de ce Processor. Le Processor se charge uniquement d'injecter dans les conversations l'état actuel de la mémoire de travail.

### Modèle par défaut

Si aucun modèle n'est fourni, le Processor utilise un modèle Markdown par défaut avec des champs pour :

- Prénom, nom
- Lieu, profession
- Centres d'intérêt, objectifs
- Événements, faits, projets

## Voir aussi

- [Garde-fous](https://mastra.zisheng.pro/fr/docs/agents/guardrails)