Personnaliser l'extraction automatique de mémoire

L'extraction automatique de la mémoire peut capturer des détails utiles sans configuration supplémentaire. Les instructions personnalisées permettent à une application d'ajouter des conseils au processus d'extraction lorsque le comportement par défaut doit être adapté à un cas d'utilisation spécifique.

Ce guide explique comment guider l'extraction automatique de la mémoire d'Oracle AI Agent Memory avec des instructions personnalisées.

Les instructions personnalisées vous permettent de fournir des conseils spécifiques au domaine sur les détails à conserver en tant que mémoire durable. Ils sont utiles lorsque votre application a besoin d'extraction pour refléter le jugement des experts, la politique des produits ou les priorités spécifiques au flux de travail au lieu de traiter tous les détails potentiellement mémorables de la même manière.

Remarque : utilisez des instructions personnalisées lorsque l'extraction de mémoire doit suivre les instructions propres à l'application. L'extraction par défaut est appropriée lorsqu'aucun conseil supplémentaire n'est nécessaire.

Conseil : reportez-vous à Introduction à la mémoire d'agent pour savoir comment installer oracleagentmemory. Si vous avez besoin d'une base de données Oracle AI Database locale pour cet exemple, suivez Exécuter Oracle AI Database localement.

Configuration des instructions d'extraction au niveau du client

Créez le composant Mémoire de l'agent Oracle avec un pool ou une connexion Oracle DB, un intégrateur, un LLM et des instructions d'extraction axées sur le support. Ces instructions s'appliquent aux threads créés ou chargés via ce client, sauf si un thread fournit ses propres instructions d'extraction.

import oracledb

from oracleagentmemory.core import MemoryExtractionConfig, MemoryLinkExtractionMode, SchemaPolicy
from oracleagentmemory.core.embedders.embedder import Embedder
from oracleagentmemory.core.llms.llm import Llm
from oracleagentmemory.core.oracleagentmemory import OracleAgentMemory

embedder = Embedder(model="YOUR_EMBEDDING_MODEL")
llm = Llm(model="YOUR_MEMORY_LLM")
db_pool = oracledb.SessionPool(
    user="YOUR DB USER",
    password="YOUR DB PASSWORD",
    dsn="localhost:1521/...",
)
memory_store_id = "T_MEM_EXTRACTION"

support_extraction_instructions = """
Only extract customer support facts:
- order ids
- return requests
- delivery problems
Ignore greetings, small talk, and one-off troubleshooting text.
""".strip()

memory = OracleAgentMemory(
    connection=db_pool,
    embedder=embedder,
    llm=llm,
    memory_extraction_config=MemoryExtractionConfig(
        memory_extraction_custom_instructions=support_extraction_instructions
    ),
    schema_policy=SchemaPolicy.CREATE_IF_NECESSARY,
    memory_store_id=memory_store_id,
)

Référence d'API : OracleAgentMemory

OracleThread

Extraire les mémoires de support des messages de thread

Créez un thread de support et ajoutez des messages utilisateur et d'assistant. L'exemple définit memory_extraction_config=MemoryExtractionConfig(memory_extraction_frequency=1) afin que add_messages() exécute l'extraction automatisée immédiatement pour la rotation insérée. Les instructions personnalisées gardent la mémoire extraite concentrée sur les ID de commande, les demandes de retour et les problèmes de livraison.

support_thread = memory.create_thread(
    thread_id="support_ticket_7421",
    user_id="customer_123",
    memory_extraction_config=MemoryExtractionConfig(memory_extraction_frequency=1),
)

#add_messages persists the turn and runs automated memory extraction because
#MemoryExtractionConfig(memory_extraction_frequency=1) is set for this thread.
support_thread.add_messages(
    [
        {
            "role": "user",
            "content": (
                "Hi, order 7421 arrived damaged. I need a return request "
                "and a replacement delivery."
            ),
        },
        {
            "role": "assistant",
            "content": "I can help start the return request for order 7421.",
        },
    ]
)

results = support_thread.search(
    "return request order 7421",
    max_results=5,
    record_types=["fact"],
)
for result in results:
    print(f"- [{result.record.record_type}] {result.content}")
#- [fact] Customer reported damaged order 7421 and requested a return and replacement delivery.

Le résultat présenté précédemment est illustratif. Le texte exact de la mémoire dépend du LLM d'extraction configuré, mais les mémoires extraites doivent suivre les instructions personnalisées fournies au client.

La différence est plus facile à voir en comparant le type de mémoire que l'extracteur est invité à conserver :

Avec des instructions personnalisées

L'extracteur conserve le fait durable du support client et ignore le message d'accueil et la formulation conversationnelle.

- [fact] Customer reported damaged order 7421 and requested a return and replacement delivery.

Sans instructions personnalisées

L'extracteur peut conserver une mémoire de conversation plus large car l'invite d'extraction par défaut n'est pas ciblée pour prendre en charge les opérations.

- [memory] The user contacted support about order 7421 and discussed a damaged delivery.

Référence d'API : OracleThread

OracleSearchResult

Configurer la liaison automatique de mémoire

La liaison automatique de mémoire relie une mémoire nouvellement extraite à des mémoires existantes pertinentes. Le kit SDK extrait un ensemble limité de mémoires candidates et demande au LLM d'extraction de décider si un lien typé doit être créé. Par défaut, POST_EXTRACTION prend cette décision dans une demande supplémentaire après l'extraction des mémoires.

Le type de lien décrit la relation entre la nouvelle mémoire et le candidat existant. supersedes, refines et duplicates conservent l'ancienne mémoire en tant qu'historique et la marquent comme non valide. supports et contradicts gardent les deux mémoires valides. La liaison automatique est limitée aux candidats extraits. Utilisez les API de liaison explicites lorsqu'une relation doit toujours être enregistrée.

Utilisez MemoryExtractionConfig pour personnaliser la liaison automatique :

memory_link_extraction_mode contrôle le moment où les liens sont résolus. Utilisez POST_EXTRACTION pour une demande de résolution de lien distincte, DURING_EXTRACTION pour résoudre les liens dans la demande d'extraction ou DISABLED pour ne créer aucun lien automatique.
memory_link_extraction_custom_instructions ajoute des conseils à l'invite de résolution de lien, tels que les types de relation appropriés pour un domaine.
memory_link_extraction_token_limit définit le budget total des jetons d'entrée pour la résolution des liens post-extraction. Les valeurs inférieures à 1 désactivent cette limite.

Comme pour les paramètres d'extraction décrits précédemment, fournissez ces champs au niveau du client ou remplacez-les pour un thread spécifique. L'exemple suivant met à jour le thread de support pour lier uniquement les modifications significatives des faits de support :

memory.update_thread(
    "support_ticket_7421",
    memory_extraction_config=MemoryExtractionConfig(
        memory_link_extraction_mode=MemoryLinkExtractionMode.POST_EXTRACTION,
        memory_link_extraction_custom_instructions=(
            "Only link a new support fact when it supersedes or refines "
            "an existing support fact. Do not create supports or contradicts links."
        ),
        memory_link_extraction_token_limit=8_000,
    ),
)

Les mêmes paramètres peuvent être transmis à create_thread() ou inclus dans le fichier MemoryExtractionConfig du client. Pour plus d'informations sur la création manuelle de liens et l'extraction du contexte lié, reportez-vous à Création et recherche de graphiques de mémoire liés.

Référence d'API : MemoryExtractionConfig

OracleThread

Instructions de substitution pour un thread

Transmettez memory_extraction_config=MemoryExtractionConfig(memory_extraction_custom_instructions=...) à create_thread() lorsqu'un thread nécessite une stratégie d'extraction plus étroite que la valeur par défaut du client. La valeur de niveau thread est prioritaire pour ce thread et est conservée avec la configuration du thread.

billing_thread = memory.create_thread(
    thread_id="billing_ticket_9310",
    user_id="customer_123",
    memory_extraction_config=MemoryExtractionConfig(
        memory_extraction_frequency=1,
        memory_extraction_custom_instructions=(
            "Only extract billing facts, invoice identifiers, and payment issues."
        ),
    ),
)

billing_thread.add_messages(
    [
        {
            "role": "user",
            "content": "Invoice INV-9310 was paid twice and needs a refund.",
        }
    ]
)

Référence d'API : OracleAgentMemory

OracleThread

Mettre à jour ou effacer les instructions de thread

Utilisez update_thread() pour modifier les instructions d'extraction persistantes d'un thread existant. Transmettez None pour effacer les instructions de niveau thread afin que les gestionnaires de threads futurs utilisent les instructions de niveau client ou, si aucune n'est configurée, le comportement d'extraction normal du kit SDK.

memory.update_thread(
    "support_ticket_7421",
    memory_extraction_config=MemoryExtractionConfig(
        memory_extraction_custom_instructions=(
            "Only extract product defects and replacement requests."
        )
    ),
)

memory.update_thread(
    "support_ticket_7421",
    memory_extraction_config=MemoryExtractionConfig(
        memory_extraction_custom_instructions=None
    ),
)

Remarque : get_thread(..., memory_extraction_config=MemoryExtractionConfig(memory_extraction_custom_instructions=...)) peut appliquer des instructions à l'identificateur de thread actif renvoyé sans mettre à jour la configuration de thread persistant.

Référence d'API : OracleAgentMemory

OracleThread

Conclusion

Dans ce guide, nous avons appris à configurer des instructions d'extraction personnalisées au niveau du client, à configurer la liaison automatique de la mémoire, à remplacer les instructions d'extraction pour un thread spécifique et à mettre à jour ou effacer les instructions d'extraction au niveau du thread.

→ Après avoir appris à personnaliser l'extraction automatisée, vous pouvez maintenant passer à Utiliser les API à court terme de mémoire d'agent Oracle avec LangGraph.

Code complet

Copiez le code complet qui suit.

#Copyright © 2026 Oracle and/or its affiliates.
#This software is under the Apache License 2.0
#(LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0) or Universal Permissive License
#(UPL) 1.0 (LICENSE-UPL or https://oss.oracle.com/licenses/upl), at your option.

#Oracle Agent Memory Code Example - Customize Automatic Memory Extraction
#------------------------------------------------------------------------

##Configure custom memory extraction instructions

import oracledb

from oracleagentmemory.core import MemoryExtractionConfig, MemoryLinkExtractionMode, SchemaPolicy
from oracleagentmemory.core.embedders.embedder import Embedder
from oracleagentmemory.core.llms.llm import Llm
from oracleagentmemory.core.oracleagentmemory import OracleAgentMemory

embedder = Embedder(model="YOUR_EMBEDDING_MODEL")
llm = Llm(model="YOUR_MEMORY_LLM")
db_pool = oracledb.SessionPool(
    user="YOUR DB USER",
    password="YOUR DB PASSWORD",
    dsn="localhost:1521/...",
)
memory_store_id = "T_MEM_EXTRACTION"

support_extraction_instructions = """
Only extract customer support facts:
- order ids
- return requests
- delivery problems
Ignore greetings, small talk, and one-off troubleshooting text.
""".strip()

memory = OracleAgentMemory(
    connection=db_pool,
    embedder=embedder,
    llm=llm,
    memory_extraction_config=MemoryExtractionConfig(
        memory_extraction_custom_instructions=support_extraction_instructions
    ),
    schema_policy=SchemaPolicy.CREATE_IF_NECESSARY,
    memory_store_id=memory_store_id,
)

##Extract support memories from thread messages

support_thread = memory.create_thread(
    thread_id="support_ticket_7421",
    user_id="customer_123",
    memory_extraction_config=MemoryExtractionConfig(memory_extraction_frequency=1),
)

#add_messages persists the turn and runs automated memory extraction because
#MemoryExtractionConfig(memory_extraction_frequency=1) is set for this thread.
support_thread.add_messages(
    [
        {
            "role": "user",
            "content": (
                "Hi, order 7421 arrived damaged. I need a return request "
                "and a replacement delivery."
            ),
        },
        {
            "role": "assistant",
            "content": "I can help start the return request for order 7421.",
        },
    ]
)

results = support_thread.search(
    "return request order 7421",
    max_results=5,
    record_types=["fact"],
)
for result in results:
    print(f"- [{result.record.record_type}] {result.content}")
#- [fact] Customer reported damaged order 7421 and requested a return and replacement delivery.

##Configure automatic memory linking

memory.update_thread(
    "support_ticket_7421",
    memory_extraction_config=MemoryExtractionConfig(
        memory_link_extraction_mode=MemoryLinkExtractionMode.POST_EXTRACTION,
        memory_link_extraction_custom_instructions=(
            "Only link a new support fact when it supersedes or refines "
            "an existing support fact. Do not create supports or contradicts links."
        ),
        memory_link_extraction_token_limit=8_000,
    ),
)

##Override custom instructions for one thread

billing_thread = memory.create_thread(
    thread_id="billing_ticket_9310",
    user_id="customer_123",
    memory_extraction_config=MemoryExtractionConfig(
        memory_extraction_frequency=1,
        memory_extraction_custom_instructions=(
            "Only extract billing facts, invoice identifiers, and payment issues."
        ),
    ),
)

billing_thread.add_messages(
    [
        {
            "role": "user",
            "content": "Invoice INV-9310 was paid twice and needs a refund.",
        }
    ]
)

##Update or clear thread custom instructions

memory.update_thread(
    "support_ticket_7421",
    memory_extraction_config=MemoryExtractionConfig(
        memory_extraction_custom_instructions=(
            "Only extract product defects and replacement requests."
        )
    ),
)

memory.update_thread(
    "support_ticket_7421",
    memory_extraction_config=MemoryExtractionConfig(
        memory_extraction_custom_instructions=None
    ),
)