Forget

What is the forget operation

The .forget operation is the unified deletion command in Cognee v1.0.

Single data item deletion: remove one data item from a dataset.
Dataset deletion: remove an entire dataset and its graph/vector data.
Full cleanup: remove everything the current user can delete.
Memory-only reset: delete only graph/vector memory for a dataset or a single file, preserving raw files so the dataset can be re-cognified with different settings.
User-scoped deletion: forget() covers the main v1.0 deletion cases, but it does not replace low-level destructive prune operations.

Where forget fits

Use forget() when you want to remove memory.
Use it to clean up test data, reset a dataset, or fully wipe a local user’s memory.
Use dataset-level forgetting for most operational cleanup.
Use prune only for destructive developer resets that must wipe underlying storage or system metadata directly.

What happens under the hood

Forget a specific data item

Requires both data_id and dataset.
Resolves the dataset by name or UUID with delete-permission checks.
Deletes that item from the dataset with delete_dataset_if_empty=False.
Leaves the dataset itself intact.

Forget a dataset

Resolves the dataset by name or UUID with delete-permission checks.
Deletes the dataset’s relational records and contained data items.
Deletes graph nodes and edges for that dataset.
Deletes vector embeddings for that dataset.
Does not currently target session cache entries by dataset.

Forget everything

Deletes all datasets the current user can delete.
Removes graph, vector, and relational data for those datasets.
Also prunes the session cache when caching or usage logging is enabled.
Does not wipe raw uploaded files or bypass permission checks the way prune does.

Forget memory only (dataset)

Requires dataset. memory_only=True cannot be used without a dataset.
Resolves the dataset by name or UUID with delete-permission checks.
Deletes all graph nodes and edges for the dataset.
Deletes all vector embeddings for the dataset.
Resets pipeline_status on all data records in the dataset, allowing cognify to re-process them.
Does not remove raw files or the dataset/data relational records.

Forget memory only (single file)

Requires both dataset and data_id, plus memory_only=True.
Resolves the dataset by name or UUID with delete-permission checks.
Deletes the graph nodes and edges associated with that single data item.
Deletes the vector embeddings for that data item.
Resets the cognify_pipeline status entry for that data record, allowing re-processing.
Does not remove the raw file or the data record itself.

After forget finishes

Single-item forget: the specified item is removed from the dataset, while the dataset remains.
Dataset forget: the dataset’s relational, graph, and vector data are removed.
Everything forget: all datasets the current user can delete are removed, and session cache is also pruned when caching is enabled.
Memory-only (dataset): graph, vector, and pipeline status are cleared; the dataset, data records, and raw files remain intact and can be re-cognified.
Memory-only (single file): graph nodes/edges and vector embeddings for that file are removed; the data record and raw file are preserved.

Examples and details

Forget a single data item

await cognee.forget(
    data_id=item_id,
    dataset=dataset_id,
)

Forget an entire dataset

await cognee.forget(dataset="scientists")

Forget everything for the current user

await cognee.forget(everything=True)

Forget only memory for a dataset (keep raw files)

Use this when you want to re-cognify a dataset with different settings (e.g. a new graph model or custom prompt) without removing the original files.

await cognee.forget(dataset="scientists", memory_only=True)

Graph nodes/edges and vector embeddings are deleted and the pipeline status is reset. Raw files and the dataset/data records are preserved.

Forget only memory for a single file

Clears just the graph and vector memory for one file, without touching the rest of the dataset.

await cognee.forget(
    dataset="scientists",
    data_id=item_id,
    memory_only=True,
)

Return values

forget() returns a summary dictionary.

Item deletion returns fields like data_id, dataset_id, and status.
Dataset deletion returns the resolved dataset_id and status.
Full deletion returns the number of datasets removed plus status.
Memory-only dataset reset returns dataset_id, data_records_reset (count of data records in the dataset), and status.
Memory-only single-file reset returns data_id, dataset_id, and status.

Deletion scope by mode

Mode	Relational data	Graph data	Vector data	Pipeline status	Raw files	Session cache
`data_id` + `dataset`	removes the targeted item	removed for that item	removed for that item	unchanged	preserved	unchanged
`dataset`	removed	removed	removed	removed	preserved	unchanged
`everything=True`	removed for all owned datasets	removed for all owned datasets	removed for all owned datasets	removed	preserved	pruned when caching is enabled
`dataset` + `memory_only=True`	preserved	removed	removed	reset (cognify re-runs)	preserved	unchanged
`dataset` + `data_id` + `memory_only=True`	preserved	removed for that item	removed for that item	reset for that item	preserved	unchanged

This is why forget(dataset=...) and forget(everything=True) feel different: only the full wipe also clears session cache, and neither mode is a raw-storage/system-metadata reset like prune. The memory_only modes are the only modes that preserve relational records while clearing derived knowledge.

Does forget re-run the LLM or cost tokens?

No. forget() (and the legacy delete()) only remove data — they never call the LLM or embedding model, so they consume no tokens and incur no model cost.Under the hood, forgetting performs deletes against the relational, graph, and vector stores. It does not re-extract entities, re-embed text, or rebuild graph relationships. Existing nodes and edges are simply dropped (or preserved when still shared, as described below); the remaining graph is left as-is and is not recomputed.When you rebuild memory after a forget, model calls happen in the operations that build memory — remember/cognify and memify. Tokens are spent only when you re-cognify after a memory_only forget, not by the forget itself.

What is tracked per document: nodes and relationships

A common misconception is that item-level deletion only considers graph nodes. In practice Cognee also records relationship ownership metadata per source document: when cognify builds the graph, it records which graph nodes and which edges (relationships) were derived from each source.When you forget a single data item (with or without memory_only), Cognee uses those ownership records to identify graph memory tied to that item:

Owned by the removed document	Also referenced by another document in scope	Result
node	no	deleted from graph + vector stores (orphaned)
node	yes	preserved so the rest of the graph stays intact
relationship metadata / edge indexes	no longer referenced	cleaned up along with the removed graph memory
relationship metadata	still referenced	preserved for the remaining graph memory

The per-document ownership records are always cleared, even when every node the document referenced is shared and therefore kept in the graph. Graph relationships attached to deleted nodes are removed with those nodes; relationships between surviving shared nodes are not independently deleted by forget().To replace a document’s extracted graph memory with memory from new content, use update(), which runs this same item-level deletion flow and then re-cognifies the new version.

User context and ownership

forget() always runs in a user context.

If you do not pass user, Cognee resolves the default user.
Deletion scope is based on what that user owns or has delete access to.
everything=True means “everything the current user can delete,” not “everything in the whole system.”
This is why the user parameter matters in multi-user or permissioned setups.

Parameters

Basic Parameters
Advanced Parameters

Option	What it does
`dataset`	Deletes an entire dataset by name or UUID.
`data_id`	Deletes one specific data item, but only when `dataset` is also provided.
`everything`	Deletes all datasets and data the current user can delete.
`memory_only`	When `True`, deletes only memory (graph + vector) and resets pipeline status for the given `dataset`, preserving raw files. Requires `dataset`. Combine with `data_id` to target a single file.

Option	What it does
`user`	Runs forget under a specific user context, affecting ownership checks and deletion scope.

Permissions and safety

Deleting a specific item or dataset requires delete access to that dataset.
data_id cannot be used alone; it must be paired with dataset.
memory_only=True requires dataset to be specified; omitting it raises a ValueError.
memory_only operations check delete permission on the dataset before removing any graph or vector data.
everything=True ignores data_id and dataset and wipes all data the current user can delete.
Dataset deletion does not currently clean only the matching session cache entries because sessions are not keyed by dataset.
forget() is not a substitute for prune_data() or prune_system(...), which are lower-level destructive maintenance tools.

Under the hood — legacy operations

forget() wraps the Delete and dataset-deletion APIs under the hood, extending them with a unified interface and session cache cleanup.Use legacy Delete directly only when maintaining older integrations or referencing older documentation. For destructive storage resets that bypass normal deletion logic, use prune rather than forget().

Inspect what you've stored before forgetting

To find the dataset name or data_id needed for forget(), list your datasets and their contents first:

import cognee

# See all datasets
datasets = await cognee.datasets.list_datasets()
for ds in datasets:
    print(ds.name, ds.id)

# See items inside a specific dataset
items = await cognee.datasets.list_data(dataset_id=ds.id)
for item in items:
    print(item.id, item.name)

See datasets API reference for the full set of listing and management methods.

Remember

Add new permanent or session memory

Recall

Verify what memory is currently retrievable

Getting Started

Core Concepts

Setup Configuration

Guides

Examples

CLI

Rust SDK

TypeScript SDK

OSS

What is the forget operation

Where forget fits

What happens under the hood

Forget a specific data item

Forget a dataset

Forget everything

Forget memory only (dataset)

Forget memory only (single file)

After forget finishes

Examples and details

Remember

Recall

​What is the forget operation

​Where forget fits

​What happens under the hood

​Forget a specific data item

​Forget a dataset

​Forget everything

​Forget memory only (dataset)

​Forget memory only (single file)

​After forget finishes

​Examples and details

Remember

Recall

What is the forget operation

Where forget fits

What happens under the hood

Forget a specific data item

Forget a dataset

Forget everything

Forget memory only (dataset)

Forget memory only (single file)

After forget finishes

Examples and details