> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cognee.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Self-Improvement Quickstart
> Step-by-step guide to enriching memory and bridging session content with improve
A minimal guide to running a self-improvement pass over existing memory so session-only content becomes part of the permanent dataset. In the current API, this user-facing flow goes through `improve()`, which uses Memify-style enrichment under the hood.
**Before you start:**
* Complete [Quickstart](/getting-started/quickstart) to understand basic operations
* Ensure you have [LLM Providers](/setup-configuration/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 Self-Improvement Does
* Enriches an existing dataset instead of re-ingesting all source data
* Bridges session memory into the permanent graph when you pass `session_ids`
* Distills accepted session guidance into `session_learnings` when the session has durable, gated lessons
* Improves later `recall()` results by adding retrieval-ready structures to the dataset
## Code in Action
### Step 1: Store Permanent Memory
```python theme={null}
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
```python theme={null}
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
```python theme={null}
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
```python theme={null}
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.
If the session accumulated durable guidance during conversation, the same pass can also distill accepted lessons into `session_learnings`.
### Step 5: Recall After Improvement
```python theme={null}
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
* Distilled session-learning documents tagged as `session_learnings`, when the session contains accepted guidance
* 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)
```python theme={null}
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
* persist agent trace steps and distill accepted session guidance into `session_learnings`
* 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 guide keeps its historical `memify-*` path while demonstrating the current way to trigger self-improvement.
## Additional Information
* Runnable guide script available on our [GitHub](https://github.com/topoteretes/cognee/blob/main/examples/guides/improve_quickstart.py)
* An advanced end-to-end script touring the whole memory API — `remember()`, `recall()`, `improve()`, and `forget()`, including session-aware `recall()` — is also on our [GitHub](https://github.com/topoteretes/cognee/blob/dev/examples/advanced_guides/remember_recall_improve_example.py). Unlike the examples above, it leaves `self_improvement` at its default (`True`), so its session `remember()` calls also bridge into the permanent graph in the background; its explicit `improve()` call is still what enriches its `scientists` dataset, because the session calls default to `main_dataset`.
```python theme={null}
import asyncio
import cognee
DATASET = "demo_dataset"
SESSION = "demo_session"
async def main():
await cognee.forget(everything=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())
```
```python theme={null}
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())
```
* **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](/setup-configuration/llm-providers).
* **Permission errors** — the user must have write access to the target dataset. See [Permissions](/core-concepts/multi-user-mode/permissions-system/datasets).
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.
Understand the current improvement workflow
Store permanent and session memory
Learn how session memory behaves before improvement