Skip to main content
A minimal guide to running a small improvement pass over existing memory so session-only content becomes part of the permanent dataset. In the current API, that flow goes through improve(), which uses memify-style enrichment under the hood. Before you start:
  • Complete Quickstart to understand basic operations
  • Ensure you have LLM Providers configured
  • Have an existing dataset or be ready to create one with remember()
  • Have session content you want to bridge into permanent memory

​
What Memify Does

  • Enriches an existing dataset instead of re-ingesting all source data
  • Bridges session memory into the permanent graph when you pass session_ids
  • Improves later recall() results by adding retrieval-ready structures to the dataset

​
Code in Action

​
Step 1: Store Permanent Memory

await cognee.remember(
    "Einstein developed general relativity.",
    dataset_name=DATASET,
    self_improvement=False,
)
This creates durable graph memory in demo_dataset. Setting self_improvement=False keeps the example focused on the explicit improve() call later.

​
Step 2: Store Session-only Memory

await cognee.remember(
    "Niels Bohr worked on atomic structure.",
    dataset_name=DATASET,
    session_id=SESSION,
    self_improvement=False,
)
This writes the Bohr fact into session memory under demo_session instead of immediately pushing it into the permanent graph.

​
Step 3: Recall Before Improvement

answer_before_improve = await cognee.recall(
    "What did Bohr work on?",
    datasets=[DATASET],
)
At this point, the permanent dataset may not yet know about the session-only Bohr fact, so the recall result can be empty or incomplete.

​
Step 4: Bridge and Enrich with Improve

await cognee.improve(dataset=DATASET, session_ids=[SESSION])
This runs the improvement pass for demo_dataset, bridging the gap between short-term (session) memory and long term (permanent) memory by pulling in the specified session and enriching the graph.

​
Step 5: Recall After Improvement

answer_after_improve = await cognee.recall(
    "What did Bohr work on?",
    datasets=[DATASET],
)
After improve() finishes, the permanent dataset can answer from the newly bridged session content.

​
What Changed in Your Graph

After improve() completes, the dataset can include:
  • Session-derived content from demo_session persisted into the permanent graph
  • Additional derived retrieval structures created during the enrichment pass
  • Better downstream recall for facts that were previously only available in the session
  • dataset (str, default: "main_dataset") — the dataset to improve.
  • session_ids (Optional[List[str]]) — session IDs whose cached memory should be bridged into the permanent graph.
  • run_in_background (bool, default: False) — if True, returns immediately and runs improvement asynchronously.
  • node_name (Optional[List[str]]) — narrows the improvement pass to specific named nodes or node sets.
  • feedback_alpha (float, default depends on runtime config) — controls how strongly session feedback affects graph weighting when feedback data exists.

​
Customizing Tasks (Optional)

await cognee.improve(
    dataset=DATASET,
    session_ids=[SESSION],
    extraction_tasks=[...],
    enrichment_tasks=[...],
)
You can override the default extraction and enrichment tasks when you need domain-specific improvement behavior.

​
What Happens Under the Hood

When session_ids are provided, the improvement flow can:
  • apply feedback-based weighting updates to graph elements used during retrieval
  • persist session memory into the permanent graph
  • run the enrichment pass on the target dataset
  • sync new graph context back into the session cache
improve() uses memify for its enrichment stage, which is why this quickstart now demonstrates the current way to trigger that workflow.

​
Additional examples

Additional examples about improve and memify-style enrichment are available in the updated tests/guides/improve_quickstart.py guide script.
  • No visible change after improve() — make sure the session ID you pass actually contains session memory and that self_improvement=False did not leave the content unbridged.
  • Empty recall results after improvement — verify that you are recalling against the same dataset you improved.
  • Error: no graph data found — create the base dataset first with cognee.remember(..., dataset_name=...).
  • LLM errors — verify that your LLM provider is configured correctly. See LLM Providers.
  • Permission errors — the user must have write access to the target dataset. See Permissions.

​
Full Example

import asyncio
import cognee

DATASET = "demo_dataset"
SESSION = "demo_session"


async def main():
    await cognee.prune.prune_data()
    await cognee.prune.prune_system(metadata=True)

    await cognee.remember(
        "Einstein developed general relativity.",
        dataset_name=DATASET,
        self_improvement=False,
    )

    await cognee.remember(
        "Niels Bohr worked on atomic structure.",
        dataset_name=DATASET,
        session_id=SESSION,
        self_improvement=False,
    )

    answer_before_improve = await cognee.recall(
        "What did Bohr work on?",
        datasets=[DATASET],
    )

    await cognee.improve(dataset=DATASET, session_ids=[SESSION])

    answer_after_improve = await cognee.recall(
        "What did Bohr work on?",
        datasets=[DATASET],
    )
    print("Before improve:", answer_before_improve)

    print("After improve:", answer_after_improve)


if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import cognee
from cognee.modules.search.types import SearchType

async def main():
    # 1) Add two short chats and build a graph
    await cognee.add([
        "We follow PEP8. Add type hints and docstrings.",
        "Releases should not be on Friday. Susan must review PRs.",
    ], dataset_name="rules_demo")
    await cognee.cognify(datasets=["rules_demo"])  # builds graph

    # 2) Enrich the graph (uses default memify tasks)
    await cognee.memify(dataset="rules_demo")

    # 3) Query the new coding rules
    rules = await cognee.search(
        query_type=SearchType.CODING_RULES,
        query_text="List coding rules",
        node_name=["coding_agent_rules"],
    )
    print("Rules:", rules)

if __name__ == "__main__":
    asyncio.run(main())
This updated example uses one permanent fact and one session-only fact for demonstration. In practice, you can bridge larger sessions and then run additional enrichment on the same dataset.

Improve

Understand the current improvement workflow

Remember

Store permanent and session memory

Sessions

Learn how session memory behaves before improvement