Cognee

Utilise cette compétence pour l'aide sur l'API Python spécifique à Cognee et pour mapper les objectifs utilisateur au bon workflow Cognee.

Quand appliquer cette compétence

Applique cette compétence chaque fois que l'utilisateur souhaite faire l'une des choses suivantes avec Cognee :

• ingérer du texte, des fichiers, des URLs, des repos ou des datasets
• construire ou reconstruire un knowledge graph
• chercher des documents, chunks, résumés, triplets ou contexte de graph
• choisir un SearchType
• enrichir un graph existant avec memify
• définir des modèles d'extraction de graph personnalisés ou des types DataPoint
• lancer des pipelines de tâches personnalisés
• configurer les paramètres LLM, graph DB, vector DB ou storage
• tagger et scoper la mémoire avec node_set / NodeSets
• construire une mémoire persistante pour les agents entre les sessions
• créer des boucles de feedback ou des workflows d'agents auto-améliorants
• travailler avec l'extraction temporelle, les ontologies, Cypher ou les requêtes de graph en langage naturel
• gérer les datasets, sessions, feedback, pruning, mises à jour ou visualisation

Si l'intention de l'utilisateur est « stocker des informations en mémoire et les interroger plus tard », préfère le flux principal de Cognee : add -> cognify -> search

Workflow principal

import cognee
from cognee import SearchType

await cognee.add(
    "Your text, file path, URL, or list of inputs",
    dataset_name="main",
    node_set=["default_memory"],
)
await cognee.cognify(datasets="main")
results = await cognee.search(
    "What are the key insights?",
    query_type=SearchType.GRAPH_COMPLETION,
    datasets="main",
)

Guidance par défaut

Quand tu aides avec Cognee :

1. Commence par le chemin le plus simple qui fonctionne, sauf si l'utilisateur demande explicitement une configuration avancée.
2. Préfère le workflow standard :
   • add(...) pour ingérer
   • cognify(...) pour construire le graph
   • search(...) pour l'interroger
3. Traite les APIs Cognee comme asynchrones.
4. Utilise dataset_name / datasets pour garder le travail organisé quand l'utilisateur a plusieurs sources.
5. Utilise node_set quand l'utilisateur veut un tagging léger, un scoping de projet, des buckets de mémoire par utilisateur ou un filtrage de subgraph.
6. Recommande les fonctionnalités avancées seulement quand elles correspondent à la tâche :
   • memify(...) pour enrichir un graph existant
   • temporal_cognify=True pour l'extraction sensible au temps
   • des modèles de graph personnalisés ou des types DataPoint pour l'extraction spécifique au domaine
   • des pipelines personnalisés pour l'orchestration de tâches non-standard
   • des boucles de feedback pour améliorer la récupération
   • des outils de visualisation pour inspecter le graph

Tâches courantes

Ajouter des données

Utilise cognee.add(...) pour du texte, des fichiers, des URLs ou des entrées mixtes.

await cognee.add("notes.md", dataset_name="research")
await cognee.add("https://example.com", dataset_name="research")
await cognee.add(["paper.pdf", "summary.txt"], dataset_name="research")

Utilise node_set quand l'utilisateur veut que les données soient groupées en buckets de mémoire logiques.

await cognee.add(
    "Customer prefers concise weekly summaries and Slack delivery.",
    dataset_name="customer_success",
    node_set=["preferences", "customer_123", "weekly_reports"],
)

Construire le graph

Utilise cognee.cognify(...) après l'ingestion.

await cognee.cognify(datasets="research")

Utilise ces options quand pertinent :

await cognee.cognify(
    datasets="research",
    temporal_cognify=True,
    chunk_size=1024,
    custom_prompt="Extract companies, products, and partnerships.",
)

Chercher dans le graph

Utilise cognee.search(...) et choisis le mode de recherche qui correspond à la demande.

results = await cognee.search(
    "What changed in Q1 2024?",
    query_type=SearchType.TEMPORAL,
    datasets="research",
    top_k=10,
)

Scoper la recherche avec NodeSets

Utilise NodeSets quand l'utilisateur veut chercher seulement un sous-ensemble de mémoire comme un projet, un client, un utilisateur ou un workflow.

results = await cognee.search(
    query_text="What are this customer's reporting preferences?",
    query_type=SearchType.GRAPH_COMPLETION,
    datasets="customer_success",
    node_name=["preferences", "customer_123"],
)

Enrichir un graph existant

Utilise memify(...) quand l'utilisateur veut améliorer ou étendre un graph déjà construit sans redémarrer le workflow complet.

await cognee.memify(dataset="research")

Créer des structures spécifiques au domaine

Utilise des modèles personnalisés quand l'utilisateur veut une extraction façonnée autour d'un schéma.

from typing import Any
from pydantic import SkipValidation
from cognee.infrastructure.engine import DataPoint
from cognee.tasks.storage import add_data_points

class ScientificPaper(DataPoint):
    title: str
    authors: list[str]
    methodology: str
    findings: list[str]
    cites: SkipValidation[Any] = None
    metadata: dict = {"index_fields": ["title", "findings"]}

paper = ScientificPaper(
    title="Graph Memory for Agents",
    authors=["A. Researcher"],
    methodology="Knowledge graph + vector retrieval",
    findings=["Improved cross-session recall", "Better multi-hop retrieval"],
)

await add_data_points([paper])

Lancer des pipelines personnalisés

Utilise run_custom_pipeline(...) quand l'utilisateur a besoin d'un contrôle explicite des tâches séquentielles.

from cognee.modules.pipelines.tasks.task import Task

async def my_task(data):
    return data

await cognee.run_custom_pipeline(
    tasks=[Task(my_task)],
    data="input",
    dataset="research",
)

DataPoints

Un DataPoint est l'unité atomique de connaissance dans Cognee.

Utilise ce concept chaque fois que l'utilisateur demande comment Cognee représente les données structurées en interne ou comment insérer des objets natifs du graph directement.

Idées clés :

• Un DataPoint est un modèle Pydantic qui représente une unité d'information significative.
• Il peut porter à la fois du contenu et du contexte, incluant des indices d'indexation et des champs de relation.
• Quand insertés directement, les DataPoints peuvent devenir des nœuds et des arêtes de graph tout en contribuant aux champs vectoriels interrogeables.
• metadata = {"index_fields": [...]} contrôle quels champs doivent être intégrés pour la recherche sémantique.
• Les champs de relation peuvent pointer vers d'autres DataPoints, te permettant de définir la structure du graph programmatiquement.
• Les DataPoints sont idéaux quand l'utilisateur a déjà des objets structurés et ne veut pas s'appuyer seulement sur l'extraction de texte.

Utilise DataPoint quand l'utilisateur veut :

• une mémoire façonnée par un schéma
• un contrôle exact de la structure du graph
• une création de relations programmatique
• des entités de domaine personnalisées comme des papers, clients, incidents, politiques, produits ou workflows

Préfère add(...) -> cognify(...) pour les documents non-structurés. Préfère les modèles DataPoint plus add_data_points(...) quand l'utilisateur a déjà des objets Python structurés et veut une insertion directe dans le graph.

NodeSets

Utilise NodeSets quand l'utilisateur veut une manière légère de tagger, grouper et scoper la mémoire.

Un NodeSet commence comme une simple liste de tags passée via node_set=[...] pendant add(...), mais après cognify() ces tags deviennent des nœuds de graph de première classe qui aident à organiser la récupération.

Pourquoi NodeSets importent

• Ils permettent à l'utilisateur d'organiser la mémoire par projet, équipe, client, workflow, sujet ou environnement.
• Ils facilitent la recherche seulement dans un subgraph pertinent au lieu du dataset complet.
• Ils sont particulièrement utiles dans les systèmes d'agents où un store de mémoire contient de nombreux utilisateurs, jobs ou tâches.

Bons motifs NodeSet

• par client : ["customer_123"]
• par workflow : ["support_bot", "refund_flow"]
• par sujet : ["contracts", "vendor_risk"]
• par environnement : ["prod", "staging"]
• par mémoire utilisateur : ["user_42", "preferences"]

Exemple

await cognee.add(
    [
        "Alice prefers terse answers and email follow-ups.",
        "Alice escalates billing issues to finance first.",
        "Bob prefers detailed technical explanations."
    ],
    dataset_name="agent_memory",
    node_set=["crm", "user_profiles"],
)

await cognee.cognify(datasets="agent_memory")

results = await cognee.search(
    query_text="How should I respond to Alice?",
    datasets="agent_memory",
    node_name=["crm", "user_profiles"],
)

Utilise NodeSets par défaut chaque fois que l'utilisateur dit des choses comme :

• « scoper la mémoire par client »
• « séparer les projets sans faire des bases de données séparées »
• « laisser l'agent chercher seulement ses propres mémoires »
• « grouper les faits par workflow ou équipe »

Guide de sélection SearchType

Utilise ces valeurs par défaut :

• GRAPH_COMPLETION : meilleur défaut pour Q&A conscient du graph
• RAG_COMPLETION : RAG traditionnel sur les chunks de document
• CHUNKS : récupération sémantique rapide sans completion
• CHUNKS_LEXICAL : correspondance de terme exact / keyword
• SUMMARIES : aperçu des documents
• TRIPLET_COMPLETION : Q&A de style sujet-prédicat-objet du graph
• GRAPH_SUMMARY_COMPLETION : réponses basées sur graph + résumé
• GRAPH_COMPLETION_COT : raisonnement plus approfondi sur le contexte du graph
• GRAPH_COMPLETION_CONTEXT_EXTENSION : récupération de contexte de graph plus large
• CYPHER : requêtes Cypher brutes quand activées
• NATURAL_LANGUAGE : langage naturel vers requête de graph
• TEMPORAL : recherche de graph sensible au temps
• CODING_RULES : règles de code et motifs
• FEELING_LUCKY : laisser Cognee choisir automatiquement
• FEEDBACK : appliquer le feedback pour améliorer le comportement de récupération futur

Workflows agentic et amélioration dirigée par le feedback

Utilise Cognee comme la couche de mémoire pour les systèmes d'agents qui ont besoin de s'améliorer au fil du temps grâce à une meilleure récupération, une meilleure réutilisation du travail antérieur et une meilleure récupération du comportement passé réussi.

L'idée clé est simple :

• garde le workflow d'agent lui-même constant
• garde le prompt et les outils constants
• change seulement ce que l'agent peut se souvenir et récupérer

Cela signifie que « l'amélioration » vient de la réutilisation de la mémoire et de la qualité de la récupération, pas de changer le modèle ou le réentraîner.

Ce que Cognee donne aux workflows agentic

Cognee aide les systèmes d'agents à :

• stocker les observations, décisions, résultats et motifs appris en tant que mémoire
• récupérer le contexte conscient du graph au lieu de s'appuyer seulement sur la recherche de chunks plats
• réutiliser les investigations antérieures, les plans et les résolutions réussies
• préserver le contexte court-terme à travers les sessions
• consolider l'historique de session utile en connaissance à long-terme
• scoper la mémoire par utilisateur, client, workflow, équipe ou environnement avec les datasets et NodeSets
• améliorer le comportement futur grâce aux boucles de feedback et à l'enrichissement de mémoire

Le motif de feedback général

Une façon robuste d'expliquer Cognee dans les systèmes d'agents est :

1. Condition de base L'agent cherche dans le knowledge graph existant et agit en utilisant seulement la connaissance actuellement stockée.

2. Condition avec feedback activé L'agent utilise le même prompt et les mêmes outils, mais bénéficie maintenant de :

   • mémoire court-terme à partir des interactions cachées ou sessionisées
   • mémoire long-terme créée en persistant périodiquement les sessions utiles dans le graph

3. Mécanisme d'amélioration Les futures exécutions deviennent plus rapides ou meilleures parce que l'agent peut récupérer :

   • des cas antérieurs similaires
   • des résolutions réussies
   • les préférences de l'utilisateur ou du client
   • les politiques, heuristiques et motifs de workflow réutilisables
   • les connexions entre incidents, entités et chronologies

Ceci est mieux décrit comme réutilisation de mémoire dirigée par le feedback, non pas fine-tuning.

Feedback court-terme vs long-terme

Cognee s'adapte naturellement à un motif de mémoire à deux niveaux :

Feedback court-terme

Utilise la recherche sessionisée et les interactions cachées pendant le travail actif.

Cela aide l'agent à retenir le contexte récent tel que :

• ce qu'il a déjà découvert dans le workflow actuel
• ce que les étapes antérieures d'un pipeline multi-agent ont trouvé
• le raisonnement récent de l'analyste ou du superviseur
• le dernier motif de réponse réussi dans le même flux de tâche

Utilise ceci quand l'utilisateur veut :

• la continuité dans une exécution multi-étape
• les investigations répétées au sein de la même session
• la mémoire de travail actif pour un agent ou superviseur

Feedback long-terme

Persiste périodiquement les sessions, interactions ou leçons dérivées valides dans le knowledge graph.

Cela permet aux futures exécutions de récupérer des motifs tels que :

• les incidents antérieurs similaires
• les causes racines récurrentes
• les styles de réponse préférés
• les corrections connues et les chemins d'escalade
• les politiques apprises par l'exécution répétée

Utilise ceci quand l'utilisateur veut :

• l'apprentissage entre sessions
• la mémoire organisationnelle
• la réutilisation de cas au fil du temps
• l'auto-amélioration persistante sans réentraînement

Comment Cognee supporte ce motif

Utilise ces éléments constitutifs :

• add(...) pour stocker les observations, logs, résultats ou faits nouveaux
• cognify(...) pour les transformer en mémoire de graph interrogeable
• search(...) pour récupérer les connaissances antérieures pertinentes avant d'agir
• session_id pour préserver la continuité à travers les recherches connexes
• les workflows conscients du feedback pour capturer les interactions utiles
• memify(...) pour enrichir ou consolider la mémoire existante en connaissance de graph plus valuable
• dataset_name et node_set pour scoper la mémoire au bon tenant, projet, workflow ou utilisateur

Boucle d'agent générale

Une explication réutilisable pour les agents alimentés par Cognee est :

1. Observer Capture les nouvelles entrées, événements, préférences utilisateur, résultats, erreurs et décisions.

2. Stocker Ajoute-les à Cognee comme texte brut, documents, objets structurés ou DataPoints.

3. Organiser Utilise les datasets et NodeSets pour séparer la mémoire par client, workflow, équipe, agent ou sujet.

4. Construire la mémoire Lance cognify(...) pour que l'information devienne consciente du graph et interrogeable.

5. Rappeler avant d'agir Cherche dans Cognee avant la planification, l'utilisation d'outils, la synthèse ou la génération de réponse.

6. Capturer le feedback Enregistre ce qui a fonctionné, ce qui a échoué, ce qui a été utile et ce qui doit être réutilisé.

7. Consolider Persiste périodiquement l'historique de session ou les leçons dérivées dans la mémoire de graph long-terme.

8. Réutiliser Les futures exécutions bénéficient d'un contexte plus riche et d'une récupération plus informée.

Exemple de modèle mental

Une bonne façon généralisée de décrire le feedback d'agent est :

L'agent ne change pas sa procédure de raisonnement principale. Il s'améliore parce que chaque exécution laisse derrière elle une meilleure mémoire pour la prochaine exécution.

Cette mémoire peut inclure :

• les résumés d'incidents antérieurs
• les résolutions réussies
• les approches échouées
• les préférences spécifiques au client
• les règles spécifiques au workflow
• les découvertes inter-rôles des agents spécialistes
• les chaînes d'événements temporels
• les DataPoints structurés pour les entités, résultats et relations

Bons exemples de cas d'usage de feedback d'agent visibles pour l'utilisateur

Suggère Cognee quand l'utilisateur veut des agents qui :

• se souviennent des préférences utilisateur entre les sessions
• réutilisent les investigations d'incident antérieures
• accumulent la connaissance de support au fil du temps
• améliorent l'exécution du workflow grâce aux résultats antérieurs
• cherchent des cas antérieurs similaires avant de répondre
• maintiennent une mémoire scoped par tenant ou client
• combinent la mémoire de travail court-terme avec la mémoire de graph long-terme
• transforment les sessions répétées en connaissance organisationnelle réutilisable

Motif d'exemple minimal

import cognee
from cognee import SearchType

# 1) Store a new observation
await cognee.add(
    "Customer 123 prefers concise status updates and Slack notifications.",
    dataset_name="agent_memory",
    node_set=["customer_123", "preferences", "support_agent"],
)

# 2) Build memory
await cognee.cognify(datasets="agent_memory")

# 3) Recall before acting
context = await cognee.search(
    query_text="What should I know before replying to customer 123?",
    query_type=SearchType.GRAPH_COMPLETION,
    datasets="agent_memory",
    session_id="support-session-123",
)

# 4) Continue work in the same session
answer = await cognee.search(
    query_text="Draft the best reply for customer 123.",
    query_type=SearchType.GRAPH_COMPLETION,
    datasets="agent_memory",
    session_id="support-session-123",
)

# 5) Consolidate or enrich memory later
await cognee.memify(dataset="agent_memory")

Meilleure explication par défaut

Si l'utilisateur demande comment Cognee aide les agents à s'améliorer au fil du temps, réponds avec cette idée :

Cognee permet aux agents de s'améliorer en se souvenant de choses plus utiles, en les organisant dans une mémoire de graph interrogeable, et en réutilisant le travail passé réussi dans les futures exécutions.

Aide à la configuration

Utilise les assistants de config Cognee quand l'utilisateur a besoin d'une configuration de provider ou de backend.

cognee.config.set_llm_provider("openai")
cognee.config.set_llm_model("gpt-4o-mini")
cognee.config.set_llm_api_key("sk-...")

Exemples de domaines connexes sur lesquels l'utilisateur peut poser des questions :

• configuration du provider et modèle LLM
• provider de base de données de graph
• provider de base de données vectorielle
• paramètres de base de données relationnelle
• taille de chunk / chevauchement
• répertoires de stockage
• paramètres de traduction
• variables d'environnement

Opérations de dataset et lifecycle

Utilise ceci quand l'utilisateur veut inspecter, vider, remplacer ou supprimer des données.

datasets = await cognee.datasets.list_datasets()
await cognee.datasets.empty_dataset(dataset_id)
await cognee.datasets.delete_all()
await cognee.update(data_id="...", data="Updated content", dataset_id="...")

Sessions et feedback

Utilise session_id quand l'utilisateur veut la continuité conversationnelle à travers les recherches.

results = await cognee.search(
    query_text="Continue the earlier analysis",
    datasets="agent_memory",
    session_id="analysis-session-1",
)

Utilise le feedback quand l'utilisateur veut que Cognee renforce le comportement de récupération utile au fil du temps.

from cognee import SearchType

results = await cognee.search(
    query_text="What are the main themes in my data?",
    query_type=SearchType.GRAPH_COMPLETION,
    save_interaction=True,
)

await cognee.search(
    query_text="Helpful answer. It captured the key technical themes.",
    query_type=SearchType.FEEDBACK,
    last_k=1,
)

Visualisation

Utilise la visualisation quand l'utilisateur veut inspecter ou présenter le graph.

await cognee.visualize_graph("/path/to/output.html")
await cognee.start_visualization_server(port=8080)
await cognee.start_ui()

Opérations de pruning et reset

Utilise le pruning quand l'utilisateur veut réinitialiser les données utilisateur ou les stores de backing.

await cognee.prune.prune_data()
await cognee.prune.prune_system(graph=True, vector=True, metadata=False, cache=True)

Notes importantes sur le comportement

• Les APIs Cognee sont généralement asynchrones.
• Préfère add -> cognify -> search sauf si l'utilisateur a explicitement besoin de quelque chose d'autre.
• Utilise node_set tôt quand l'utilisateur peut avoir besoin plus tard d'une récupération scoped.
• Utilise temporal_cognify=True pour l'extraction d'événement et de temps.
• Utilise session_id quand l'utilisateur veut des interactions conscientes de la session.
• Utilise des boucles de feedback quand l'utilisateur veut que la récupération s'améliore au fil du temps.
• Utilise memify(...) quand l'utilisateur veut enrichir un graph existant avec des faits dérivés ou des règles réutilisables.
• Utilise des modèles de graph personnalisés ou des types DataPoint seulement quand l'utilisateur a besoin d'une extraction façonnée par un schéma.
• Utilise CYPHER seulement quand les requêtes Cypher sont activées dans la config.
• Garde les exemples minimaux et exécutables.

Ne surcharge pas

Ne saute pas directement aux backends avancés, à la configuration d'ontologie ou aux pipelines personnalisés sauf si l'utilisateur les demande ou que le problème les exige clairement. Préfère la plus petite solution Cognee correcte d'abord, puis étends-la.