summarizeConversation()

La fonction autonome summarizeConversation() résume une conversation en une seule fois. Elle synthétise les messages transmis à l’aide du même mécanisme Observer que celui d’Observational Memory, sans qu’Observational Memory soit associé à un Agent et sans lire ni écrire de données dans le stockage.

Aucune donnée n’est réécrite dans la mémoire. Le résumé et les valeurs extraites vous sont renvoyés, ainsi qu’au hook onExtracted de chaque extracteur. Vous décidez donc où les stocker, par exemple dans votre propre base de données.

Utilisez cette fonction lorsque vous disposez déjà des messages et souhaitez contrôler explicitement les éléments à résumer. Pour un fil stocké et identifié par un ID, utilisez Memory.summarizeThread(), qui charge les messages pour vous.

Exemple d’utilisation

import { summarizeConversation } from '@mastra/memory'

const result = await summarizeConversation({
  model: 'openai/gpt-5-mini',
  messages,
  instructions: 'Summarize this voicemail call for the business owner.',
})

Paramètres

model:

string | LanguageModel | DynamicModel

Modèle qui effectue le résumé, par exemple une chaîne de routeur comme '__GATEWAY_OPENAI_MODEL_MINI__'.

messages:

MastraDBMessage[]

Conversation à résumer. Si elle est vide, la fonction renvoie un résultat vide sans appeler le modèle.

instructions?:

string

Instructions supplémentaires ajoutées au prompt système du modèle de résumé, par exemple les éléments à privilégier ou le destinataire du résumé.

extract?:

Extractor[]

Extracteurs à exécuter sur la conversation. Les extracteurs dotés d’un schéma Zod sont exécutés lors d’un appel ultérieur avec sortie structurée ; les extracteurs sans schéma sont exécutés directement. Le hook onExtracted de chaque extracteur est déclenché avec la valeur extraite.

threadId?:

string

Fil auquel appartient la conversation. Utilise par défaut le premier threadId trouvé dans messages. Transmis aux contextes des extracteurs.

resourceId?:

string

Ressource (utilisateur) à laquelle appartient la conversation. Utilise par défaut le premier resourceId trouvé dans messages. Transmise aux contextes des extracteurs.

memory?:

Memory

Instance de Memory transmise aux contextes des extracteurs. Définie automatiquement lors d’un appel effectué par l’intermédiaire de Memory.summarizeThread().

mastra?:

Mastra

Instance Mastra utilisée pour résoudre les modèles de gateway personnalisés. Définie automatiquement lors d’un appel effectué par l’intermédiaire de Memory.summarizeThread().

requestContext?:

RequestContext

Contexte de requête transmis au modèle de résumé et aux hooks des extracteurs.

abortSignal?:

AbortSignal

Signal permettant d’annuler l’appel de résumé.

Valeur renvoyée

summary:

string

Observations synthétisées à partir de la conversation, présentées sous forme de liste à puces dense.

extracted:

Record<string, unknown>

Valeurs produites par les extracteurs de extract, indexées par le slug de l’extracteur.

extractionFailures:

{ slug: string; error: string }[]

Extracteurs qui n’ont pas réussi à produire une valeur valide, accompagnés de la raison. Présent uniquement lorsqu’au moins un extracteur a échoué.

usage:

{ inputTokens?: number; outputTokens?: number; totalTokens?: number }

Utilisation des tokens par l’appel de résumé.

Exemple d’utilisation avancée

L’exemple suivant résume une session vocale en cours à partir de messages que l’application détient déjà, puis extrait un enregistrement structuré :

src/session-summary.ts

import { summarizeConversation, Extractor } from '@mastra/memory'
import type { MastraDBMessage } from '@mastra/core/agent'
import { z } from 'zod'
import { sessionRecords } from './db'

const sessionSummary = new Extractor({
  name: 'session-summary',
  instructions: 'Return a concise summary of the session.',
  schema: z.object({
    summary: z.string(),
    sentiment: z.enum(['positive', 'neutral', 'negative']),
    followUps: z.array(z.string()),
  }),
  metadataKeyPath: false, // don't persist into memory metadata — the hook owns storage
  onExtracted: async ({ current, threadId }) => {
    await sessionRecords.upsert({ sessionId: threadId, record: current })
  },
})

export async function onSessionEnd(messages: MastraDBMessage[]) {
  const { summary, extracted, extractionFailures } = await summarizeConversation({
    model: 'openai/gpt-5-mini',
    messages,
    instructions: 'Summarize this support session for the account manager.',
    extract: [sessionSummary],
  })

  if (extractionFailures?.length) {
    console.warn('Some extractors failed', extractionFailures)
  }

  return { summary, extracted }
}

Voir aussi

• .summarizeThread()
• Référence de la classe Memory
• Observational Memory