memify()

Enrich an existing knowledge graph with custom tasks

cognee.memify()

async def memify(
    extraction_tasks: Optional[Sequence[Union[Task, str]]] = None,
    enrichment_tasks: Optional[Sequence[Union[Task, str]]] = None,
    data: Optional[Any] = None,
    dataset: Union[str, UUID] = 'main_dataset',
    user: User = None,
    node_type: Optional[Type] = NodeSet,
    node_name: Optional[List[str]] = None,
    vector_db_config: Optional[dict] = None,
    graph_db_config: Optional[dict] = None,
    run_in_background: bool = False,
)

Description

Enrichment pipeline in Cognee, can work with already built graphs. If no data is provided existing knowledge graph will be used as data, custom data can also be provided instead which can be processed with provided extraction and enrichment tasks.

Provided tasks and data will be arranged to run the Cognee pipeline and execute graph enrichment/creation.

This is the core processing step in Cognee that converts raw text and documents into an intelligent knowledge graph. It analyzes content, extracts entities and relationships, and creates semantic connections for enhanced search and reasoning.

Args: extraction_tasks: List of Cognee Tasks to execute for graph/data extraction. Entries may be Task instances or names of built-in memify tasks (see cognee.memify_pipelines.memify_task_registry). enrichment_tasks: List of Cognee Tasks to handle enrichment of provided graph/data from extraction tasks. Entries may be Task instances or names of built-in memify tasks. data: The data to ingest. Can be anything when custom extraction and enrichment tasks are used. Data provided here will be forwarded to the first extraction task in the pipeline as input. If no data is provided the whole graph (or subgraph if node_name/node_type is specified) will be forwarded dataset: Dataset name or dataset uuid to process. user: User context for authentication and data access. Uses default if None. node_type: Filter graph to specific entity types (for advanced filtering). Used when no data is provided. node_name: Filter graph to specific named entities (for targeted search). Used when no data is provided. vector_db_config: Custom vector database configuration for embeddings storage. graph_db_config: Custom graph database configuration for relationship storage. run_in_background: If True, starts processing asynchronously and returns immediately. If False, waits for completion before returning. Background mode recommended for large datasets (>100MB). Use pipeline_run_id from return value to monitor progress.

Parameters

extraction_tasks · Optional[Sequence[Union[Task, str]]] · default: "None"

Task objects and/or supported task names for graph/data extraction. The two forms can be mixed in one list.

enrichment_tasks · Optional[Sequence[Union[Task, str]]] · default: "None"

Task objects and/or supported task names for graph enrichment. The two forms can be mixed in one list.

data · Optional[Any] · default: "None"

Data to ingest. If not provided, operates on existing knowledge graph.

dataset · Union[str, UUID] · default: "'main_dataset'"

Dataset name or UUID to operate on.

user · User · default: "None"

User performing the operation.

node_type · Optional[Type] · default: "NodeSet"

Filter to specific entity types in the graph.

node_name · Optional[List[str]] · default: "None"

Filter to specific named entities.

vector_db_config · Optional[dict] · default: "None"

Override vector database configuration.

graph_db_config · Optional[dict] · default: "None"

Override graph database configuration.

run_in_background · bool · default: "False"

If true, return immediately and process in background.

Supported task names

extraction_tasks and enrichment_tasks accept Task instances, task names as plain strings, or a mix of both in the same list. Names are resolved against a curated registry (cognee.memify_pipelines.memify_task_registry) that only exposes tasks runnable without required keyword arguments. Every call builds a fresh Task instance per name, so resolved tasks are never shared between runs.

The registry is shared by both parameters. These names are typically used for extraction:

Name	Task
extract_subgraph	Yield the edges of the incoming subgraphs
extract_subgraph_chunks	Pull document chunks from the incoming subgraphs
get_triplet_datapoints	Convert graph triplets into indexable datapoints (triplets_batch_size=100)
extract_user_sessions	Extract not-yet-persisted Q&A entries from the session cache
extract_agent_trace_feedbacks	Extract step-level agent trace content for the current user
detect_entity_duplicates	Find semantically near-duplicate Entity nodes

And these for enrichment:

Name	Task
cognify_session	Cognify session windows into the knowledge graph
cognify_agent_trace_feedback	Cognify agent trace session text into the knowledge graph
apply_feedback_weights	Update graph-element weights from feedback scores (batch_size=100)
apply_frequency_weights	Increment graph-element weights on each use (batch_size=100)
merge_entity_duplicates	Merge the duplicates found by detect_entity_duplicates
index_data_points	Index datapoints in the vector DB (batch_size=100)

Each name is constructed with the same defaults the dedicated memify pipelines use, shown in parentheses above. To use different arguments, pass a Task instance instead of a name.

Tasks that require call-specific parameters are not in the registry and stay SDK-only. For example, extract_feedback_qas requires session_ids, so it must be passed as Task(extract_feedback_qas, session_ids=[...]) rather than by name.

Invalid task names

Names are resolved before any setup or database work happens, so a bad name fails fast without starting a pipeline run.

• Python SDK — an unknown name, or an entry that is neither a Task nor a str, raises CogneeValidationError. The message for an unknown name lists every supported name.
• REST (POST /api/v1/memify) — the same condition returns 422 Unprocessable Content with the supported names in the error body. Previously any non-empty task-name list failed with a 500.

How memify() differs from cognify()

	cognify()	memify()
Purpose	Build knowledge graph from raw data	Enrich an existing graph
Input	Raw text/files	Existing graph or new data
Pipeline	Fixed (chunk → extract → build)	Customizable extraction + enrichment tasks
Use case	Initial processing	Iterative refinement, entity consolidation

Examples

import cognee

# Enrich existing graph with default tasks
await cognee.memify()

# Enrich a specific dataset
await cognee.memify(dataset="my_dataset")

# Custom extraction and enrichment
from cognee.modules.pipelines import Task

await cognee.memify(
    extraction_tasks=[my_extractor_task],
    enrichment_tasks=[my_enrichment_task],
    dataset="my_dataset",
)

# Select built-in tasks by name
await cognee.memify(
    extraction_tasks=["detect_entity_duplicates"],
    enrichment_tasks=["merge_entity_duplicates"],
    dataset="my_dataset",
)

# Mix task names with Task instances
from cognee.tasks.storage.index_data_points import index_data_points

await cognee.memify(
    extraction_tasks=["get_triplet_datapoints"],
    enrichment_tasks=[Task(index_data_points, task_config={"batch_size": 500})],
    dataset="my_dataset",
)

# Filter to specific entity types
await cognee.memify(node_name=["Person", "Organization"])

See the Memify pipeline guides for lower-level enrichment walkthroughs, or the Self-Improvement Quickstart for the v1.0 user-facing flow.