> ## 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.

# memify()

> Enrich an existing knowledge graph with custom tasks

# cognee.memify()

```python theme={null}
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

<ParamField path="extraction_tasks" type="Optional[Sequence[Union[Task, str]]]" default="None">Task objects and/or [supported task names](#supported-task-names) for graph/data extraction. The two forms can be mixed in one list.</ParamField>
<ParamField path="enrichment_tasks" type="Optional[Sequence[Union[Task, str]]]" default="None">Task objects and/or [supported task names](#supported-task-names) for graph enrichment. The two forms can be mixed in one list.</ParamField>
<ParamField path="data" type="Optional[Any]" default="None">Data to ingest. If not provided, operates on existing knowledge graph.</ParamField>
<ParamField path="dataset" type="Union[str, UUID]" default="'main_dataset'">Dataset name or UUID to operate on.</ParamField>
<ParamField path="user" type="User" default="None">User performing the operation.</ParamField>
<ParamField path="node_type" type="Optional[Type]" default="NodeSet">Filter to specific entity types in the graph.</ParamField>
<ParamField path="node_name" type="Optional[List[str]]" default="None">Filter to specific named entities.</ParamField>
<ParamField path="vector_db_config" type="Optional[dict]" default="None">Override vector database configuration.</ParamField>
<ParamField path="graph_db_config" type="Optional[dict]" default="None">Override graph database configuration.</ParamField>
<ParamField path="run_in_background" type="bool" default="False">If true, return immediately and process in background.</ParamField>

## 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.

<Note>
  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.
</Note>

### 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

```python theme={null}
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](/guides/memify-session-persistence) for lower-level enrichment walkthroughs, or the [Self-Improvement Quickstart](/guides/self-improvement-quickstart) for the v1.0 user-facing flow.