enterprise_ai.memory

Source : sdks/python/src/enterprise_ai/memory/__init__.py. Retour à l'index de la référence du SDK Python.

remarque

Cette page est générée par tools/docs/gen_sdk_reference.py depuis les sources du SDK et les dossiers de textes OpenAPI. Ne la modifiez pas à la main : changez la source et régénérez.

Classe MemoryClient

Mémoire. Memory Manager : éléments de mémoire durables des agents et des utilisateurs, conformes au Memory Contract v1, avec ACL, durée de vie, conservation légale, versionnage et recherche hybride.

Resource

MemoryClient.add_knowledge

add_knowledge(agent_id: str, texts: list[str], scope: str | None = None, team: str | None = None, dataset_id: str | None = None, classification: str | None = None, retention_days: int | None = None, legal_hold: bool | None = None, build_graph: bool | None = None) -> Any

Ingérer des connaissances. Ajoute des textes au jeu de données Cognee d'une portée (Cognee POST /api/v1/add, puis POST /api/v1/cognify si build_graph), seulement si la politique active knowledge_graph et si le moteur est cognee ou hybrid (sinon 403 ou 422 memory_capability_unsupported). Mêmes contrôles DLP, de classification, de conservation et d'isolation qu'une mémoire ; relation editor sur l'agent. 201 avec dataset, items et graph. Accepte un en-tête Idempotency-Key. Audité sous memory.knowledge.create sans le contenu.

Route : /v1/memory/agents/{agent_id}/knowledge (POST).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
texts	list[str]		oui	Un à 50 textes (chacun jusqu'à 100000 caractères) ; les secrets sont refusés.
scope	str | None	None	non	Niveau d'isolation du jeu de données : agent (par défaut), shared_agents, project, team, organization ou global.
team	str | None	None	non	Équipe de la portée team.
dataset_id	str | None	None	non	Jeu de données existant de la même portée (identifiant d'index Navin) ; par défaut : le jeu de données de la portée, créé s'il manque.
classification	str | None	None	non	Classification déclarée des textes.
retention_days	int | None	None	non	Conservation en jours, dans la limite de la politique.
legal_hold	bool | None	None	non	Placer le jeu de données sous conservation légale. Faux par défaut.
build_graph	bool | None	None	non	Construire le graphe juste après l'ingestion (cognify de Cognee). Faux par défaut.

Retour : Any. Réponse JSON décodée de l'opération « Ingérer des connaissances ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.agent_policy

agent_policy(agent_id: str) -> Any

Lire la politique de mémoire d'un agent. Choix du moteur (builtin, mem0, cognee, hybrid), instances, modes, portées, limites de mémorisation, conservation, partage et isolation exigée de l'agent, avec version, configured (faux : valeurs par défaut, moteur builtin) et engines (par usage memory ou knowledge : instance, fournisseur, isolation et capacités). Relation viewer sur l'agent, ou l'agent lui-même.

Route : /v1/memory/agents/{agent_id}/policy (GET).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.

Retour : Any. Réponse JSON décodée de l'opération « Lire la politique de mémoire d'un agent ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.agent_policy_versions

agent_policy_versions(agent_id: str) -> Any

Lister les versions de la politique de mémoire. Anciennes versions de la politique de mémoire de l'agent, de la plus récente à la plus ancienne (au plus 200), chacune avec son moteur, ses instances, sa politique, son auteur et sa date. Relation viewer sur l'agent.

Route : /v1/memory/agents/{agent_id}/policy/versions (GET).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.

Retour : Any. Réponse JSON décodée de l'opération « Lister les versions de la politique de mémoire ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.build_graph

build_graph(agent_id: str, dataset_ids: list[str] | None = None) -> Any

Construire le graphe de connaissances. Lance Cognee POST /api/v1/cognify sur les jeux de données lisibles de l'instance de l'agent (tous par défaut). Relation editor sur l'agent. Audité sous memory.knowledge.build.

Route : /v1/memory/agents/{agent_id}/knowledge/graph (POST).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
dataset_ids	list[str] | None	None	non	Identifiants d'index Navin des jeux de données (par défaut : tous les jeux lisibles).

Retour : Any. Réponse JSON décodée de l'opération « Construire le graphe de connaissances ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.datasets

datasets(agent_id: str, scope: str | None = None, limit: int | None = None, cursor: str | None = None) -> Any

Lister les jeux de données de connaissances. Jeux de données que l'appelant peut lire via cet agent, paginés avec cursor.

Route : /v1/memory/agents/{agent_id}/knowledge/datasets (GET).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
scope	str | None	None	non	Seulement ce niveau d'isolation : agent, shared_agents, project, team, organization ou global.
limit	int | None	None	non	Nombre maximal d'éléments dans une page. Le serveur plafonne la valeur ; lisez la page suivante avec cursor.
cursor	str | None	None	non	Curseur opaque renvoyé dans next_cursor par la page précédente. Omettez-le pour lire la première page.

Retour : Any. Réponse JSON décodée de l'opération « Lister les jeux de données de connaissances ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.declare_engine

declare_engine(id: str, provider: str, base_url: str, tenant_id: str | None = None, credential_ref: str | None = None, access_control: bool | None = None, tls_verify: bool | None = None, timeout_seconds: float | None = None, manager_cluster: str | None = None, manager_service: str | None = None) -> Any

Déclarer une instance de moteur de mémoire. Déclare une instance de Mem0 ou de Cognee installée et exploitée par le Navin Manager, par exemple une instance dédiée à un tenant (tenant_id : séparation physique, comme l'exige une banque). Réservé à platform_admin (403 sinon). L'identifiant de connexion n'est qu'une référence (openbao://<chemin> ou env://EAI_CRED_<NOM>), résolue côté serveur. 409 conflict si l'identifiant existe ou est réservé (builtin, mem0, cognee), 404 pour un tenant inconnu. Accepte un en-tête Idempotency-Key. Audité sous memory.engine.declare.

Route : /v1/memory/engines (POST).

Nom	Type	Défaut	Requis	Description
id	str		oui	Identifiant (minuscules, chiffres et tirets, 2 à 63 caractères).
provider	str		oui	mem0 ou cognee.
base_url	str		oui	Adresse de l'API rendue par le Navin Manager (https en recette et en production).
tenant_id	str | None	None	non	Tenant auquel l'instance est dédiée ; vide : instance partagée.
credential_ref	str | None	None	non	Référence vers la clé d'API : openbao://<chemin> ou env://EAI_CRED_<NOM>.
access_control	bool | None	None	non	Cognee seulement : l'instance tourne avec le contrôle d'accès côté moteur (un utilisateur par tenant donne une séparation backend).
tls_verify	bool | None	None	non	Vérifier le certificat du moteur (vrai par défaut ; l'autorité du Manager de EAI_MEMORY_ENGINES_CA_FILE est reconnue).
timeout_seconds	float | None	None	non	Délai d'un appel en secondes (10 par défaut, au plus 300).
manager_cluster	str | None	None	non	Cluster du Navin Manager qui exploite l'instance (information).
manager_service	str | None	None	non	Service du catalogue du Navin Manager (information).

Retour : Any. Réponse JSON décodée de l'opération « Déclarer une instance de moteur de mémoire ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.delete

delete(memory_id: str) -> Any

Supprimer un élément de mémoire. Efface le contenu, la référence, le vecteur et les anciennes versions de l'élément et le marque supprimé. Permis pour un rédacteur ou propriétaire de l'élément, ou tenant_admin (sinon 403 not_permitted_acl). Un élément sous conservation légale répond 409 legal_hold (le refus est audité) ; un élément non supprimable répond 409 conflict sauf pour tenant_admin. 404 not_found. Audité sous memory.delete.

Route : /v1/memory/{memory_id} (DELETE).

Nom	Type	Défaut	Requis	Description
memory_id	str		oui	Identifiant (UUID) de l'élément de mémoire.

Retour : Any. Réponse JSON décodée de l'opération « Supprimer un élément de mémoire ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.delete_dataset

delete_dataset(agent_id: str, dataset_id: str) -> Any

Supprimer un jeu de données de connaissances. Supprime le jeu de données dans Cognee (DELETE /api/v1/datasets/{dataset_id}) et ses entrées d'index. 409 legal_hold si le jeu de données ou l'un de ses éléments est sous conservation légale. Audité sous memory.knowledge.delete.

Route : /v1/memory/agents/{agent_id}/knowledge/datasets/{dataset_id} (DELETE).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
dataset_id	str		oui	Identifiant (UUID) de l'entrée d'index Navin du jeu de données.

Retour : Any. Réponse JSON décodée de l'opération « Supprimer un jeu de données de connaissances ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.delete_engine

delete_engine(engine_id: str) -> Any

Retirer une instance de moteur de mémoire déclarée. Retire une instance déclarée et les identifiants de tenant qui lui sont liés. Réservé à platform_admin. 409 memory_engine_in_use tant qu'une politique d'agent ou une mémoire l'utilise ; 404 memory_engine_not_found. Audité sous memory.engine.delete.

Route : /v1/memory/engines/{engine_id} (DELETE).

Nom	Type	Défaut	Requis	Description
engine_id	str		oui	Identifiant de l'instance de moteur.

Retour : Any. Réponse JSON décodée de l'opération « Retirer une instance de moteur de mémoire déclarée ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.delete_engine_credential

delete_engine_credential(engine_id: str) -> Any

Délier l'identifiant du tenant. Retire l'identifiant de connexion de ce tenant sur l'instance ; celui de l'instance est de nouveau utilisé. Rôle tenant_admin. Audité sous memory.engine.change.

Route : /v1/memory/engines/{engine_id}/credential (DELETE).

Nom	Type	Défaut	Requis	Description
engine_id	str		oui	Identifiant de l'instance de moteur.

Retour : Any. Réponse JSON décodée de l'opération « Délier l'identifiant du tenant ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.engine_capabilities

engine_capabilities(engine_id: str) -> Any

Lire les capacités d'un moteur de mémoire. Ensemble déclaratif des capacités du moteur : seulement ce que son fournisseur exécute réellement. memory : parmi remember, recall, search, update, forget, list, get, purge, get_health, get_capabilities ; knowledge : parmi ingest_knowledge, build_graph, search_graph, get_relations, delete_dataset. Une opération hors de cet ensemble répond 422 memory_capability_unsupported. Donne aussi isolation pour le tenant et session_memory (vrai pour builtin seulement : la mémoire de session ne va jamais vers un moteur externe). Rien n'est envoyé au moteur.

Route : /v1/memory/engines/{engine_id}/capabilities (GET).

Nom	Type	Défaut	Requis	Description
engine_id	str		oui	Identifiant de l'instance de moteur (builtin, mem0, cognee ou un identifiant déclaré).

Retour : Any. Réponse JSON décodée de l'opération « Lire les capacités d'un moteur de mémoire ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.engine_health

engine_health(engine_id: str) -> Any

Vérifier la santé d'un moteur de mémoire. Appelle le moteur avec l'identifiant de connexion du tenant : Mem0 GET /auth/setup-status puis GET /configure/providers, Cognee GET /health puis GET /api/v1/datasets. Répond status up (ou degraded), ou down avec error et reason (jamais un secret). Rôles tenant_admin, developer, security_officer ou auditor.

Route : /v1/memory/engines/{engine_id}/health (GET).

Nom	Type	Défaut	Requis	Description
engine_id	str		oui	Identifiant de l'instance de moteur.

Retour : Any. Réponse JSON décodée de l'opération « Vérifier la santé d'un moteur de mémoire ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.engines

engines() -> Any

Lister les moteurs de mémoire. Moteurs de mémoire utilisables par le tenant (Navin Memory Provider) : builtin (le magasin du Memory Manager), les instances de plateforme mem0 et cognee rendues par le Navin Manager depuis ses liaisons (seulement si elles sont configurées), et les instances déclarées par l'administrateur de la plateforme (celles partagées et celles dédiées à ce tenant ; une instance dédiée à un autre tenant n'est jamais listée). Chaque entrée donne provider, base_url, origin (builtin, manager_binding, declared), dedicated, credential_bound (l'identifiant lui-même n'est jamais renvoyé), isolation (logical, backend ou dedicated_instance : la séparation que cette instance garantit pour le tenant) et capabilities. Navin Enterprise n'installe ni ne configure aucun moteur : c'est le rôle du Navin Manager.

Route : /v1/memory/engines (GET).

Cet élément ne prend aucun paramètre.

Retour : Any. Réponse JSON décodée de l'opération « Lister les moteurs de mémoire ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.export

export(agent_id: str, scopes: list[str] | None = None) -> Any

Exporter les mémoires d'un agent. Exporte au plus 1000 mémoires lisibles avec leur contenu (données non fiables). Refusé aux agents (403). Audité sous memory.export sans le contenu.

Route : /v1/memory/agents/{agent_id}/memories/export (POST).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
scopes	list[str] | None	None	non	Niveaux d'isolation à exporter (par défaut : toutes les portées lisibles).

Retour : Any. Réponse JSON décodée de l'opération « Exporter les mémoires d'un agent ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.forget

forget(agent_id: str, item_id: str) -> Any

Oublier une mémoire d'un agent. Supprime la mémoire dans son moteur (Mem0 DELETE /memories/{memory_id}, suppression de l'élément de données Cognee, suppression logique builtin) et marque l'entrée d'index supprimée. 409 legal_hold ; seul l'agent propriétaire d'une mémoire partagée (403). Audité sous memory.provider.delete.

Route : /v1/memory/agents/{agent_id}/memories/{item_id} (DELETE).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
item_id	str		oui	Identifiant (UUID) de l'entrée d'index Navin.

Retour : Any. Réponse JSON décodée de l'opération « Oublier une mémoire d'un agent ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.get

get(memory_id: str) -> Any

Lire un élément de mémoire. Renvoie l'élément sous forme de document Memory Contract avec son history (numéros et dates des anciennes versions). Un élément expiré, ou que l'appelant ne peut pas lire selon l'ACL ou l'habilitation, répond 404 not_found.

Route : /v1/memory/{memory_id} (GET).

Nom	Type	Défaut	Requis	Description
memory_id	str		oui	Identifiant (UUID) de l'élément de mémoire.

Retour : Any. Réponse JSON décodée de l'opération « Lire un élément de mémoire ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.list

list(scope_type: str | None = None, scope_id: str | None = None, kind: str | None = None, **page: Any) -> Any

Lister les éléments de mémoire. Éléments lisibles par l'appelant (présent dans readers, classification dans les limites de son habilitation, non expirés, non supprimés), sous forme de documents Memory Contract, paginés avec cursor.

Route : /v1/memory (GET).

Nom	Type	Défaut	Requis	Description
scope_type	str | None	None	non	Seulement ce type de portée : session, agent, user, project ou tenant.
scope_id	str | None	None	non	Seulement cet identifiant de portée.
kind	str | None	None	non	Seulement ce type : episodic, semantic, procedural, preference ou fact.
**page	Any		non	Options de pagination transmises à la liste : limit (nombre maximal d'éléments par page) et cursor (le next_cursor de la page précédente). Itérer sur la page renvoyée suit tous les curseurs.

Retour : Any. Réponse JSON décodée de l'opération « Lister les éléments de mémoire ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.memories

memories(agent_id: str, scope: str | None = None, include_content: bool | None = None, limit: int | None = None, cursor: str | None = None) -> Any

Lister les mémoires d'un agent. Entrées d'index des mémoires que l'appelant peut lire via cet agent (portées lisibles de la politique, classification dans l'habilitation, non expirées), paginées avec cursor. Avec include_content=true (au plus 100 par page), le contenu est lu dans le moteur et renvoyé comme donnée non fiable. Audité sous memory.provider.read.

Route : /v1/memory/agents/{agent_id}/memories (GET).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
scope	str | None	None	non	Seulement ce niveau d'isolation : session, user, agent, shared_agents, project, team, organization ou global.
include_content	bool | None	None	non	Lire aussi le contenu dans le moteur (faux par défaut).
limit	int | None	None	non	Nombre maximal d'éléments dans une page. Le serveur plafonne la valeur ; lisez la page suivante avec cursor.
cursor	str | None	None	non	Curseur opaque renvoyé dans next_cursor par la page précédente. Omettez-le pour lire la première page.

Retour : Any. Réponse JSON décodée de l'opération « Lister les mémoires d'un agent ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.memory_item

memory_item(agent_id: str, item_id: str) -> Any

Lire une mémoire d'un agent. Entrée d'index et contenu (lu dans le moteur, donnée non fiable) d'une mémoire. Un élément d'une portée que l'appelant ne peut pas lire répond 404, jamais 403, pour ne pas révéler son existence. Audité sous memory.provider.read.

Route : /v1/memory/agents/{agent_id}/memories/{item_id} (GET).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
item_id	str		oui	Identifiant (UUID) de l'entrée d'index Navin.

Retour : Any. Réponse JSON décodée de l'opération « Lire une mémoire d'un agent ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.purge

purge(agent_id: str, scope: str, confirm: bool, team: str | None = None, session_id: str | None = None) -> Any

Purger une portée d'un agent. Supprime toutes les mémoires et tous les jeux de données d'une portée de l'appelant (Mem0 DELETE /memories avec les identifiants de la portée, suppression du jeu de données Cognee, suppression logique builtin). confirm doit être vrai (400). 409 legal_hold si un élément de la portée est sous conservation légale. Audité sous memory.provider.purge.

Route : /v1/memory/agents/{agent_id}/memories/purge (POST).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
scope	str		oui	Niveau d'isolation à purger.
confirm	bool		oui	Doit valoir vrai.
team	str | None	None	non	Équipe de la portée team.
session_id	str | None	None	non	Session de la portée session.

Retour : Any. Réponse JSON décodée de l'opération « Purger une portée d'un agent ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.recall

recall(agent_id: str, query: str, scopes: list[str] | None = None, top_k: int | None = None, session_id: str | None = None) -> Any

Rappeler des mémoires pour le LLM. Recherche dans les portées lisibles sur les moteurs de la politique (hybride : Mem0 et Cognee, fusionnés et dédoublonnés par contenu, chaque source gardée dans sources), ne garde que les résultats indexés par Navin pour une portée lisible et dans l'habilitation (contrôle des permissions avant que quoi que ce soit n'atteigne le LLM), les contrôle contre l'injection de prompt (éléments bloqués écartés) et les renvoie comme données non fiables : framed_content encadré par les marqueurs de contenu non fiable et context_segments de type memory pour le Context Manager, jamais comme instructions. La décision de politique memory.search est évaluée. Audité sous memory.provider.read avec des comptes seulement.

Route : /v1/memory/agents/{agent_id}/recall (POST).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
query	str		oui	Texte de la requête (1 à 4000 caractères).
scopes	list[str] | None	None	non	Niveaux d'isolation à interroger (par défaut : les portées lisibles de la politique).
top_k	int | None	None	non	Nombre de résultats (1 à 50, par défaut recall_top_k de la politique).
session_id	str | None	None	non	Session de l'appelant, pour inclure sa mémoire de session.

Retour : Any. Réponse JSON décodée de l'opération « Rappeler des mémoires pour le LLM ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.relations

relations(agent_id: str, dataset_id: str) -> Any

Lire les relations d'un jeu de données. Nœuds et arêtes du graphe de connaissances d'un jeu de données lisible (Cognee GET /api/v1/datasets/{dataset_id}/graph), contrôlés contre l'injection de prompt et renvoyés comme données non fiables. 404 pour un jeu de données que l'appelant ne peut pas lire. Audité sous memory.provider.read.

Route : /v1/memory/agents/{agent_id}/knowledge/datasets/{dataset_id}/relations (GET).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
dataset_id	str		oui	Identifiant (UUID) de l'entrée d'index Navin du jeu de données.

Retour : Any. Réponse JSON décodée de l'opération « Lire les relations d'un jeu de données ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.remember

remember(agent_id: str, content: str, scope: str | None = None, kind: str | None = None, classification: str | None = None, session_id: str | None = None, team: str | None = None, retention_days: int | None = None, legal_hold: bool | None = None, source: dict[str, Any] | None = None) -> Any

Mémoriser via le moteur de l'agent. Écrit une mémoire via le moteur de la politique de l'agent (portée session : toujours le magasin builtin ; hybrid : Mem0). 201 avec items (entrées d'index, sans contenu), engine et engine_instance. Le contexte (tenant, organisation, projet, utilisateur, agent, session) est dérivé côté serveur du principal authentifié, du registre des agents et de la session vérifiée, jamais du corps. Contrôles, chaque refus étant audité : un agent n'utilise que sa propre mémoire (403 memory_agent_mismatch), la portée et le type doivent être permis par la politique (403), les portées partagées exigent editor sur l'agent, le moteur doit annoncer remember (422 memory_capability_unsupported) et garantir l'isolation exigée (409), les secrets, mots de passe, jetons et clés sont refusés (422 memory_secret_refused), les données personnelles si la politique les interdit (422), une classification au-dessus de la politique ou de l'habilitation (403), une conservation au-delà de la politique (422). Accepte un en-tête Idempotency-Key. Audité sous memory.provider.create sans le contenu.

Route : /v1/memory/agents/{agent_id}/memories (POST).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
content	str		oui	Texte à mémoriser (1 à 20000 caractères) ; les secrets sont refusés.
scope	str | None	None	non	Niveau d'isolation : session, user, agent, shared_agents, project, team, organization ou global. Par défaut : default_scope de la politique.
kind	str | None	None	non	episodic, semantic, procedural, preference ou fact (par défaut).
classification	str | None	None	non	Classification déclarée ; relevée par la détection, refusée au-dessus de la politique ou de l'habilitation.
session_id	str | None	None	non	Session de l'appelant (requise pour la portée session ; vérifiée côté serveur).
team	str | None	None	non	Équipe de la politique pour la portée team (par défaut : sa première équipe).
retention_days	int | None	None	non	Conservation en jours, dans la limite de la politique.
legal_hold	bool | None	None	non	Placer la mémoire sous conservation légale. Faux par défaut.
source	dict[str, Any] | None	None	non	Provenance du contenu.

Retour : Any. Réponse JSON décodée de l'opération « Mémoriser via le moteur de l'agent ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.restore_agent_policy

restore_agent_policy(agent_id: str, version: int) -> Any

Restaurer une version de la politique de mémoire. Applique de nouveau une ancienne version comme nouvelle version, avec les mêmes contrôles que PUT .../policy. 404 pour une version inconnue. Audité sous memory.policy.restore.

Route : /v1/memory/agents/{agent_id}/policy/restore (POST).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
version	int		oui	Numéro de version (1 ou plus).

Retour : Any. Réponse JSON décodée de l'opération « Restaurer une version de la politique de mémoire ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.search

search(query: str, top_k: int = 5, **filters: Any) -> Any

Rechercher dans la mémoire. Calcule le score des éléments visibles (au plus les 2000 mis à jour le plus récemment et ayant un contenu) et renvoie les top_k meilleurs avec score, keyword_score et vector_score. keyword : part des termes de la requête trouvés ; vector : similarité cosinus avec l'embedding de la requête (seulement les éléments vectorisés avec le modèle courant) ; hybrid (par défaut) : moitié de chaque. Le contenu rappelé est contrôlé contre l'injection de prompt ; les éléments bloqués sont écartés. La politique memory.search est évaluée. 400 invalid_request pour un mode inconnu. Audité sous memory.search.

Route : /v1/memory/search (POST).

Nom	Type	Défaut	Requis	Description
query	str		oui	Texte de la requête (au moins 1 caractère).
top_k	int	5	non	Nombre de résultats (1 à 100, 10 par défaut).
**filters	Any		non	Champs supplémentaires du corps de la recherche, comme scope, kind ou mode (hybrid par défaut).

Retour : Any. Réponse JSON décodée de l'opération « Rechercher dans la mémoire ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.search_knowledge

search_knowledge(agent_id: str, query: str, dataset_ids: list[str] | None = None, top_k: int | None = None, search_type: str | None = None) -> Any

Rechercher dans le graphe de connaissances. Cognee POST /api/v1/search, un jeu de données lisible par appel afin que chaque passage soit attribué à son jeu de données ; les résultats sont contrôlés et renvoyés comme données non fiables avec framed_content. La décision de politique memory.search est évaluée. Audité sous memory.provider.read.

Route : /v1/memory/agents/{agent_id}/knowledge/search (POST).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
query	str		oui	Texte de la requête (1 à 4000 caractères).
dataset_ids	list[str] | None	None	non	Identifiants d'index Navin des jeux de données (par défaut : tous les jeux lisibles).
top_k	int | None	None	non	Nombre de résultats (1 à 50, 10 par défaut).
search_type	str | None	None	non	Type de recherche Cognee : CHUNKS (par défaut), CHUNKS_LEXICAL, SUMMARIES, RAG_COMPLETION ou GRAPH_COMPLETION.

Retour : Any. Réponse JSON décodée de l'opération « Rechercher dans le graphe de connaissances ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.search_memories

search_memories(agent_id: str, query: str, scopes: list[str] | None = None, top_k: int | None = None, session_id: str | None = None) -> Any

Rechercher dans les mémoires d'un agent. Même recherche que recall pour une personne qui consulte les mémoires (sans context_segments) ; les portées partagées exigent editor sur l'agent. Les résultats sont des données non fiables. Audité sous memory.provider.read.

Route : /v1/memory/agents/{agent_id}/memories/search (POST).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
query	str		oui	Texte de la requête (1 à 4000 caractères).
scopes	list[str] | None	None	non	Niveaux d'isolation à interroger (par défaut : les portées lisibles de la politique).
top_k	int | None	None	non	Nombre de résultats (1 à 50, par défaut recall_top_k de la politique).
session_id	str | None	None	non	Session de l'appelant, pour inclure sa mémoire de session.

Retour : Any. Réponse JSON décodée de l'opération « Rechercher dans les mémoires d'un agent ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.set_agent_policy

set_agent_policy(agent_id: str, engine: str = 'builtin', mem0_instance: str | None = None, cognee_instance: str | None = None, policy: dict[str, Any] | None = None) -> Any

Définir la politique de mémoire d'un agent. Remplace la politique de mémoire de l'agent (nouvelle version, l'ancienne est gardée pour une restauration). Contrôles : rôles tenant_admin, developer ou application_owner et relation editor sur l'agent (403) ; global_access exige tenant_admin ; default_scope doit être une portée d'écriture et shared_with des agents existants (400) ; les instances choisies doivent exister, correspondre au fournisseur et garantir required_isolation (409 memory_isolation_unsatisfied : une instance dédiée installée par le Navin Manager est nécessaire). La décision de politique memory.policy.update est appliquée. shared_with écrit ou supprime la relation OpenFGA memory_reader de chaque agent sur celui-ci. Audité sous memory.policy.update, plus memory.engine.change quand le moteur ou une instance change et memory.share quand le partage change.

Route : /v1/memory/agents/{agent_id}/policy (PUT).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
engine	str	'builtin'	non	builtin (par défaut, magasin du Memory Manager), mem0 (faits et mémoires persistants), cognee (connaissances et relations) ou hybrid (mémoires dans Mem0, connaissances dans Cognee, fusionnées au rappel). La mémoire de session reste toujours builtin.
mem0_instance	str | None	None	non	Instance Mem0 à utiliser (par défaut mem0, l'instance de plateforme du Navin Manager), par exemple une instance dédiée.
cognee_instance	str | None	None	non	Instance Cognee à utiliser (par défaut cognee).
policy	dict[str, Any] | None	None	non	Modes, portées, limites de mémorisation, conservation, partage et isolation exigée.

Retour : Any. Réponse JSON décodée de l'opération « Définir la politique de mémoire d'un agent ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.set_engine_credential

set_engine_credential(engine_id: str, credential_ref: str) -> Any

Lier l'identifiant du tenant sur un moteur. Lie l'identifiant de connexion de ce tenant sur une instance partagée (référence openbao://<chemin> vers un secret du tenant). Sur une instance Cognee avec contrôle d'accès côté moteur, c'est la clé d'API de l'utilisateur Cognee du tenant : ses jeux de données et permissions sont alors appliqués par Cognee lui-même (isolation devient backend). Sur Mem0, une clé ne sépare pas les mémoires (logical reste). Rôle tenant_admin. Audité sous memory.engine.change.

Route : /v1/memory/engines/{engine_id}/credential (PUT).

Nom	Type	Défaut	Requis	Description
engine_id	str		oui	Identifiant de l'instance de moteur.
credential_ref	str		oui	Référence openbao://<chemin> vers un secret du tenant.

Retour : Any. Réponse JSON décodée de l'opération « Lier l'identifiant du tenant sur un moteur ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.update_memory

update_memory(agent_id: str, item_id: str, content: str) -> Any

Modifier une mémoire d'un agent. Remplace le contenu d'une mémoire dans son moteur (Mem0 PUT /memories/{memory_id}, nouvelle version builtin) après les mêmes contrôles DLP qu'une création ; la version augmente. Seul l'agent propriétaire d'une mémoire partagée peut la modifier (403) ; un élément sous conservation légale répond 409 legal_hold. Audité sous memory.provider.update.

Route : /v1/memory/agents/{agent_id}/memories/{item_id} (PATCH).

Nom	Type	Défaut	Requis	Description
agent_id	str		oui	Nom ou identifiant de l'agent.
item_id	str		oui	Identifiant (UUID) de l'entrée d'index Navin.
content	str		oui	Texte (1 à 20000 caractères) ; les secrets sont refusés.

Retour : Any. Réponse JSON décodée de l'opération « Modifier une mémoire d'un agent ».

Erreurs levées : les erreurs typées du transport (Erreurs).

MemoryClient.write

write(content: str, scope: Scope | null = None, subject_id: str | None = None, kind: str | None = None, classification: str = 'internal', ttl_seconds: int | None = None, **extra: Any) -> Any

Écrire un élément de mémoire. Crée un élément, ou une nouvelle version de memory_id (201, document Memory Contract). Étapes : 1. kind et scope.type sont vérifiés (400 invalid_request) ; content ou content_ref est requis. 2. La détection de données personnelles peut relever la classification ; une classification au-dessus de l'habilitation de l'appelant répond 403 policy_denied ; la politique memory.write est évaluée. 3. Pour une mise à jour, l'appelant doit être rédacteur ou propriétaire (403 not_permitted_acl) avant l'envoi du contenu au modèle d'embedding. 4. Le contenu est vectorisé et enregistré. Un nouvel élément a par défaut l'appelant comme lecteur, rédacteur et propriétaire, et la portée user de l'appelant. Audité sous memory.create ou memory.update.

Route : /v1/memory (POST).

Nom	Type	Défaut	Requis	Description
content	str		oui	Texte à mémoriser ; vectorisé pour la recherche vectorielle.
scope	Scope | null	None	non	Portée d'un nouvel élément. Par défaut : {type: user, id: <appelant>}.
subject_id	str | None	None	non	Personne concernée par l'élément (utilisée par les demandes de confidentialité). Par défaut : l'identifiant de portée pour une portée user, sinon l'appelant.
kind	str | None	None	non	episodic, semantic, procedural, preference ou fact (par défaut).
classification	str	'internal'	non	public, internal (par défaut), confidential, restricted ou secret ; relevée si des données personnelles sont détectées, et jamais au-dessus de l'habilitation de l'appelant.
ttl_seconds	int | None	None	non	Durée de vie en secondes (0 ou plus) ; ensuite l'élément n'est plus renvoyé. Omise : pas d'expiration.
**extra	Any		non	Champs supplémentaires fusionnés dans le corps de la requête.

Retour : Any. Réponse JSON décodée de l'opération « Écrire un élément de mémoire ».

Erreurs levées : les erreurs typées du transport (Erreurs).