Skip to main content

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.

​
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,
)

await cognee.forget(dataset="scientists")

await cognee.forget(everything=True)
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.
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,
)
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.
ModeRelational dataGraph dataVector dataPipeline statusRaw filesSession cache
data_id + datasetremoves the targeted itemremoved for that itemremoved for that itemunchangedpreservedunchanged
datasetremovedremovedremovedremovedpreservedunchanged
everything=Trueremoved for all owned datasetsremoved for all owned datasetsremoved for all owned datasetsremovedpreservedpruned when caching is enabled
dataset + memory_only=Truepreservedremovedremovedreset (cognify re-runs)preservedunchanged
dataset + data_id + memory_only=Truepreservedremoved for that itemremoved for that itemreset for that itempreservedunchanged
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.
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.
OptionWhat it does
datasetDeletes an entire dataset by name or UUID.
data_idDeletes one specific data item, but only when dataset is also provided.
everythingDeletes all datasets and data the current user can delete.
memory_onlyWhen 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.
  • 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.
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().
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