remember

Remember: ingest data and build the knowledge graph (add + cognify + improve)

Ingest data and build the knowledge graph in a single call.

This endpoint combines the add and cognify steps. Data is ingested first, then automatically processed into a structured knowledge graph.

Request Parameters

data (List[UploadFile]): Files to upload and process.
raw_data (Optional[List[str]]): String inputs, one entry each: raw text, a local file or directory path on the server (requires ACCEPT_LOCAL_FILE_PATH), a web URL fetched as a page (requires ALLOW_HTTP_REQUESTS), or a GitHub/GitLab repository URL, shallow-cloned and indexed as a code graph. Uploads come first, then raw_data entries; labels and external_metadata pair with that combined order. Normal ingestion only — rejected with content_type. At least one of data or raw_data is required for normal ingestion.
labels (Optional[str]): JSON array of per-file labels, e.g. [“finance”, “people”, ""], paired positionally with the uploaded files (one entry per file; an empty entry skips that file). Stored on each file’s data record. Normal ingestion only — rejected with session_id or content_type.
external_metadata (Optional[str]): JSON array of per-file metadata objects, e.g. [{“source”: “crm”}, null], paired positionally with the uploaded files (one entry per file; null or {} skips that file). Merged into each file’s stored external_metadata. Normal ingestion only — rejected with session_id or content_type.
datasetName (Optional[str]): Name of the target dataset.
datasetId (Optional[UUID]): UUID of an existing dataset.
session_id (Optional[str]): Session to attribute this memory to. When set, data is stored in the session cache and bridged into the permanent graph in the background; the session is tracked in the sessions dashboard. When omitted, data is ingested directly via add + cognify.
node_set (Optional[List[str]]): Node identifiers for graph organisation.
run_in_background (Optional[bool]): Run the cognify step asynchronously (default: False).
self_improvement (Optional[bool]): Run the improve loop after cognify (default: True). False gives a plain add + cognify ingestion.
custom_prompt (Optional[str]): Custom prompt for entity extraction.
chunk_size (Optional[int]): Maximum tokens per chunk (default: 4096).
chunks_per_batch (Optional[int]): Chunks per cognify batch.
ontology_key (Optional[List[str]]): Reference to one or more previously uploaded ontology files to use for knowledge graph construction.
graph_model (Optional[str]): JSON-serialised graph model schema (same dict format accepted by the cognify endpoint).
content_type (Optional[str]): Set to “skills” to ingest SKILL.md files as Skill nodes, or “code” to index whole repositories — each raw_data entry is then a git URL or server-local repo path and one code graph is built per entry (poll progress via GET /v1/datasets/status?pipeline=code_graph_pipeline); omit for normal ingestion.
index_vectors (Optional[bool]): content_type=“code” only — also embed the extracted code facts for semantic retrievers (default false, no LLM/embedding calls otherwise).

Either datasetName or datasetId must be provided.

import_mode (Optional[str]): COGX archive imports only: ‘preserve’ (default), ‘hybrid’, or ‘re-derive’.
skill_name (Optional[str]): content_type=‘skills’ + skills_text only: name/slug for the inline skill (defaults to ‘skill’).
skills_text (Optional[str]): content_type=‘skills’ only: inline SKILL.md markdown to ingest without a file upload (no-code path). When set and no files are uploaded, it is written to a temporary SKILL.md and ingested via the normal skills pipeline. Pair with skill_name to control the resulting skill name.

Error Codes

400 Bad Request: Neither datasetId nor datasetName provided, unsupported content_type, invalid graph_model JSON/schema, or invalid code-ingestion combination (no raw_data repository specs, file uploads or session_id with content_type=“code”, index_vectors without it, or local repo paths while ACCEPT_LOCAL_FILE_PATH=false)
409 Conflict: Error during processing

POST

api

remember

Remember: ingest data and build the knowledge graph (add + cognify + improve)

curl --request POST \
  --url https://{tenant}.aws.cognee.ai/api/v1/remember \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: multipart/form-data' \
  --form 'data=<string>' \
  --form labels= \
  --form external_metadata= \
  --form datasetName=default_dataset \
  --form datasetId= \
  --form session_id= \
  --form run_in_background=false \
  --form self_improvement=true \
  --form custom_prompt= \
  --form chunk_size=4096 \
  --form chunks_per_batch=36 \
  --form graph_model= \
  --form content_type= \
  --form import_mode= \
  --form skills_text= \
  --form skill_name= \
  --form index_vectors=false \
  --form data.items='@example-file'

import requests

url = "https://{tenant}.aws.cognee.ai/api/v1/remember"

files = { "data.items": ("example-file", open("example-file", "rb")) }
payload = {
    "data": "<string>",
    "labels": "",
    "external_metadata": "",
    "datasetName": "default_dataset",
    "datasetId": "",
    "session_id": "",
    "run_in_background": "false",
    "self_improvement": "true",
    "custom_prompt": "",
    "chunk_size": "4096",
    "chunks_per_batch": "36",
    "graph_model": "",
    "content_type": "",
    "import_mode": "",
    "skills_text": "",
    "skill_name": "",
    "index_vectors": "false"
}
headers = {"Authorization": "Bearer <token>"}

response = requests.post(url, data=payload, files=files, headers=headers)

print(response.text)

{}

{
  "detail": [
    {
      "loc": [
        "<string>"
      ],
      "msg": "<string>",
      "type": "<string>",
      "input": "<unknown>",
      "ctx": {}
    }
  ]
}

Authorizations

Authorization

string

header

required

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Body

multipart/form-data

data

file[]

raw_data

string[] | null

Data given as strings instead of uploads, one entry each: raw text to remember, a local file or directory path on the server's filesystem (requires ACCEPT_LOCAL_FILE_PATH), a web URL to fetch (requires ALLOW_HTTP_REQUESTS), or a GitHub/GitLab repository URL, which is shallow-cloned and indexed as a code graph. Combined with 'data': uploads come first, then these entries; labels and external_metadata pair with that combined order. Empty entries are ignored. With content_type='code' every entry is a repository spec (git URL or server-local repo path) and one code graph is built per entry; rejected with content_type='skills' or 'cogx-archive', which take file uploads.

Example:

[]

labels

string | null

Per-file labels, e.g. ["finance", "people", ""] — the Nth label applies to the Nth uploaded file, one entry per file, an empty entry skips that file. The comma-separated form "finance,people," is accepted equivalently (it is what Swagger UI sends when you type a JSON array here), so labels cannot contain commas unless the client sends real JSON. Stored on each file's data record and returned when listing dataset data. Only supported for normal ingestion — rejected when combined with session_id or content_type.

Example:

""

external_metadata

string | null

JSON array of per-file metadata objects, e.g. [{"source": "crm", "ticket": 42}, null]. Paired positionally like labels: the Nth entry applies to the Nth uploaded file (null or {} skips that file), and one entry per file is required when any is given. Merged into the file's stored external_metadata (your keys win over loader-derived ones; 'node_set' is reserved). Only supported for normal ingestion — rejected when combined with session_id or content_type.

Example:

""

datasetName

string | null

Name of the target dataset (created if it does not exist). Required unless datasetId is provided.

Example:

"default_dataset"

datasetId

Example:

""

session_id

string | null

Session to attribute this memory to (e.g. claude-code-1718000000). When set, the data is stored in the session cache (and bridged into the permanent graph in the background) and the session appears in the sessions dashboard. Leave empty for a direct add+cognify.

Example:

""

node_set

string[] | null

Tags the ingested data with named node sets (e.g. per-agent or per-project groups). Extracted graph nodes are linked to these sets, and recall/search can later be restricted to them via their node_name parameter. Leave empty to skip tagging.

Example:

[]

run_in_background

boolean | null

default:false

If true, the request returns immediately (status 'running' with a pipeline_run_id) while ingestion and graph building continue server-side — poll GET /v1/datasets/status to track completion. If false, the request blocks until the knowledge graph is fully built, which can take minutes for large files.

self_improvement

boolean | null

default:true

Run the self-improvement loop (improve) after the knowledge graph is built: triplet enrichment and, for session-backed data, the session bridge. Set to false for a plain add + cognify ingestion. Ignored with session_id.

custom_prompt

string | null

default:""

Replaces the default entity-extraction prompt used during graph building. Use it to steer which entities and relationships get extracted (e.g. focus on technical concepts, people, or contracts). Leave empty for the default prompt.

chunk_size

integer | null

default:4096

Maximum tokens per text chunk during ingestion (default: 4096). Each chunk is processed by the LLM separately for entity extraction: larger chunks give more context per extraction but fewer, coarser passes; smaller chunks give finer-grained extraction at higher LLM cost.

chunks_per_batch

integer | null

default:36

Number of chunks processed per cognify task batch (default: 36). Controls ingestion parallelism/throughput; rarely needs changing.

ontology_key

string[] | null

Keys of previously uploaded ontologies (see /v1/ontologies) to ground entity extraction. Leave empty to ingest without an ontology.

Example:

[]

graph_model

string | null

JSON-serialised graph model schema (same format as the cognify endpoint), e.g. {"title": "CompanyGraph", "type": "object", "properties": {...}}. Must include a top-level 'title' key. Leave empty to use the default KnowledgeGraph model — a restrictive schema here can produce an empty graph. Invalid JSON or an unconvertible schema is rejected with 400.

Example:

""

content_type

string | null

Set to 'skills' to ingest SKILL.md files as dataset-scoped Skill nodes, or 'code' to index whole code repositories (pass git URLs or server-local repo paths via 'raw_data') as an architectural code graph through the enola-backed pipeline. Leave empty for normal ingestion.

Example:

""

import_mode

string | null

COGX archive imports only: 'preserve' (default), 'hybrid', or 're-derive'.

Example:

""

skills_text

string | null

content_type='skills' only: inline SKILL.md markdown to ingest without a file upload (no-code path). When set and no files are uploaded, it is written to a temporary SKILL.md and ingested via the normal skills pipeline. Pair with skill_name to control the resulting skill name.

Example:

""

skill_name

string | null

content_type='skills' + skills_text only: name/slug for the inline skill (defaults to 'skill').

Example:

""

index_vectors

boolean | null

default:false

content_type='code' only: also embed the extracted code facts so semantic/completion retrievers can see them (requires an embedding provider). Default false — the code graph pipeline is deterministic and makes no LLM or embedding calls, and SearchType.CODE uses graph indexes only.

Response

Successful Response

The response is of type Response Remember Api V1 Remember Post · object.

⌘I

Remember: ingest data and build the knowledge graph (add + cognify + improve)

curl --request POST \
  --url https://{tenant}.aws.cognee.ai/api/v1/remember \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: multipart/form-data' \
  --form 'data=<string>' \
  --form labels= \
  --form external_metadata= \
  --form datasetName=default_dataset \
  --form datasetId= \
  --form session_id= \
  --form run_in_background=false \
  --form self_improvement=true \
  --form custom_prompt= \
  --form chunk_size=4096 \
  --form chunks_per_batch=36 \
  --form graph_model= \
  --form content_type= \
  --form import_mode= \
  --form skills_text= \
  --form skill_name= \
  --form index_vectors=false \
  --form data.items='@example-file'

import requests

url = "https://{tenant}.aws.cognee.ai/api/v1/remember"

files = { "data.items": ("example-file", open("example-file", "rb")) }
payload = {
    "data": "<string>",
    "labels": "",
    "external_metadata": "",
    "datasetName": "default_dataset",
    "datasetId": "",
    "session_id": "",
    "run_in_background": "false",
    "self_improvement": "true",
    "custom_prompt": "",
    "chunk_size": "4096",
    "chunks_per_batch": "36",
    "graph_model": "",
    "content_type": "",
    "import_mode": "",
    "skills_text": "",
    "skill_name": "",
    "index_vectors": "false"
}
headers = {"Authorization": "Bearer <token>"}

response = requests.post(url, data=payload, files=files, headers=headers)

print(response.text)

{}

{
  "detail": [
    {
      "loc": [
        "<string>"
      ],
      "msg": "<string>",
      "type": "<string>",
      "input": "<unknown>",
      "ctx": {}
    }
  ]
}

Getting Started

auth

add

cognify

memify

search

permissions

datasets

ontologies

settings

visualize

schema

skills

configuration

delete

validate

update

responses

llm

sync

users

checks

health

agent management

agent connections

activity

sessions

remember

recall

improve

forget

slack

integrations

Remember: ingest data and build the knowledge graph (add + cognify + improve)

Request Parameters

Error Codes

Authorizations

Body

Response