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

# Changelog

> Recent Cognee releases

Cognee releases with highlights and links to the full release notes on GitHub.

## Unreleased

Changes queued for the next release. This section is updated as unreleased work is merged and is folded into a versioned release section when the release is published.

* Removes the Sentry and Langfuse third-party observability integrations while keeping the OpenTelemetry tracing layer intact. The `Observer.LANGFUSE` enum value, the Langfuse branch in `get_observe()`, and the `LANGFUSE_PUBLIC_KEY` / `LANGFUSE_SECRET_KEY` / `LANGFUSE_HOST` configuration fields and environment variables are gone, and Sentry initialization is dropped from the API. The `@observe` decorator now maps only to OpenTelemetry — it emits an OTEL span when tracing is enabled (`COGNEE_TRACING_ENABLED=true`) and is a no-op otherwise — so existing `@observe` usage keeps working unchanged with no call-site edits. **Packaging (breaking):** the `monitoring` extra is removed in favor of the existing `tracing` extra, which installs only the OpenTelemetry API/SDK and OTLP exporters. Migrate with `pip install cognee[tracing]` in place of `pip install cognee[monitoring]`. Users who relied on Sentry or Langfuse should switch to an OTLP-compatible backend; configure it via `OTEL_EXPORTER_OTLP_ENDPOINT` and related `OTEL_*` variables (see [OpenTelemetry Tracing](/integrations/opentelemetry-tracing)). Lockfiles (`uv.lock` / `poetry.lock`) that still reference the removed `sentry-sdk` / `langfuse` packages should be regenerated.
* Fixes a crash when running a pipeline in the background (`run_in_background=True`) with no explicit `datasets`. The background runner (`run_pipeline_as_background_process`) now reads the effective `user` from the run's `params` first and only falls back to the default user when none was supplied, then resolves the run across all datasets that user has write access to. Previously `user` was bound only on the fallback path, so the usual case — a user passed in `params` — left `user` unassigned and raised `UnboundLocalError: cannot access local variable 'user'` before the run started. No API or CLI changes are required.
* Fixes a lock-starvation bug in single-session `improve()`. When `improve()` is called with one `session_id`, it holds a per-session lock so concurrent auto-improve, idle-watcher, and `SessionEnd` runs serialize instead of duplicating work. Previously the lock was released only after a successful run (and on early stage 1–2 failures), so an exception in a later stage — default enrichment (`memify`), the global context index, or the graph-to-session sync — left the lock held permanently, and every subsequent `improve()` for that session silently returned `{}` until the process restarted. All stages are now wrapped in a single `try/finally`, so the session lock is always released on exit regardless of which stage fails. No public signature, parameter, return type, configuration option, or environment variable changed. The fix prevents the issue from recurring; sessions already stuck from before the upgrade still need a process restart to clear the held lock (closes #3313, PR #3317).

***

## v1.2.1

**[View on GitHub](https://github.com/topoteretes/cognee/releases/tag/v1.2.1)**

Patch release that bumps the package version from `1.2.0` to `1.2.1` and refreshes `uv.lock`. This release follows `v1.2.0` with targeted reliability fixes for dataset-scoped ingestion, background task lifetime, and dataset helper authorization.

### Highlights

* Fixes `remember(..., dataset_id=...)` so it now forwards `dataset_id` to `add()`. Previously `dataset_id` was used only to build the `cognify()` target while `add()` silently ingested raw data into the default `main_dataset`, so `cognify()` ran on the intended (but empty) dataset and produced no new graph. Ingestion and graph building now target the same dataset. No API or migration changes are required; callers who passed `dataset_id` and saw missing results should upgrade.
* Anchors fire-and-forget background tasks so Python's garbage collector can no longer abort them mid-run. Background syncs (`cognee.api.v1.sync.sync.sync`) and background pipeline runs (`run_pipeline_as_background_process`) now hold a strong reference to their in-flight `asyncio.Task` in a module-level set (`_BACKGROUND_SYNC_TASKS` / `_BACKGROUND_PIPELINE_TASKS`) until the task finishes, with a done-callback that discards the reference on completion. Previously the event loop kept only a weak reference, so the GC could collect a still-running task and silently abort a background sync or pipeline run. This fixes those intermittent silent aborts; the only side effect is a small, transient increase in retained memory while tasks run (released as each task completes). No public API signature, request/response schema, configuration option, or environment variable changed.
* Fixes `cognee.datasets.has_data()` raising `AttributeError`. The method now forwards the full `User` object to its internal authorization helper instead of `user.id`, so calls succeed and return the expected `bool`. No signature, parameter, or behavioral change beyond the method no longer crashing.

***

## v1.2.0

**[View on GitHub](https://github.com/topoteretes/cognee/releases/tag/v1.2.0)**

Release that promotes accumulated `dev` work after the `v1.2.0` development builds, bumping the package version to `1.2.0` and refreshing the lockfile (`uv.lock`). Highlights include ChromaDB search enhancements, BM25 lexical chunk search, search-answer reference evidence, session-context guidance enabled by default, and a range of Postgres/Neptune adapter, visualization, logging, and memory-stability fixes.

### Highlights

* Adds ChromaDB vector search support for `include_payload=False`, so callers can omit metadata payloads from returned `ScoredResult` values when they only need ids and scores.
* Adds ChromaDB `node_name` filtering for `search()` and `batch_search()`, including `OR` and `AND` semantics through `node_name_filter_operator`.
* Prevents Entity and EntityType node id collisions by namespacing generated ids by node category.
* Excludes internal `EntityType` taxonomy nodes and their `is_a` edges from the schema inventory output (`get_schema_inventory` and the visualize schema inventory endpoint). Consumers no longer receive a separate `EntityType` type group or `is_a` relationship aggregates; entity instances are still grouped under their resolved semantic type.
* Improves ontology parsing for file-like inputs with filename/content-type detection, RDFLib fallback formats, and clearer initialization errors when parsing fails.
* Reaps subprocess database workers deterministically at interpreter exit. The `cognee_db_workers` harness now registers an `atexit` handler that force-terminates any still-live LanceDB/Kuzu worker processes on shutdown, instead of relying on garbage-collector and `__del__` ordering that is not guaranteed to run at interpreter exit (notably for Windows `spawn` daemon workers). This helps avoid leftover worker processes and shutdown hangs when running with `graph_database_subprocess_enabled=true` or `vector_db_subprocess_enabled=true`.
* Offloads the Ollama adapter's blocking client calls off the asyncio event loop. The `LLM_PROVIDER="ollama"` adapter wraps a synchronous OpenAI-compatible client, so its chat-completion, audio-transcription, and image/vision calls previously ran inline and blocked the running event loop for the full duration of each Ollama request, serializing concurrent async callers (for example the per-chunk extraction that `cognify()` fans out). These calls are now dispatched through `asyncio.to_thread`, so they execute in worker threads and no longer stall the loop. Public async signatures are unchanged and no configuration or migration changes are required; because requests now run in worker threads, any objects shared with the Ollama client should be thread-safe.
* Serializes concurrent decodes on the shared llama.cpp local in-process model. The `LLM_PROVIDER="llama_cpp"` local (in-process) adapter now guards calls into its single `llama_cpp.Llama` instance with a lock, so the per-chunk extraction that `cognify()` fans out via `asyncio.gather`/`asyncio.to_thread` no longer decodes on the same non-thread-safe instance concurrently. This helps avoid native `GGML_ASSERT` crashes from corrupted KV-cache/logits state during local llama.cpp runs; in-process requests are now processed one at a time (use server mode for parallel decoding).
* Simplifies the structured-output schema sent to the LLM during graph extraction when a custom `graph_model` (a `DataPoint` subclass) is used. `extract_content_graph` now converts the model to a plain `BaseModel` that keeps only the fields you declare on each subclass — DataPoint infrastructure fields (such as `id`, `created_at`, `version`, `type`, `belongs_to_set`) and the `metadata` field are dropped from the schema the LLM is asked to fill — and then rehydrates the LLM result back into your original `DataPoint` model via `model_validate`. The LLM extracts only your domain fields, while declared `metadata` defaults (for example `{"index_fields": ["name"]}`) are preserved on the rehydrated objects, so indexing behavior is unchanged. This is a no-action change for callers of the high-level extraction, `cognify`, and `remember` APIs.
* Fixes Neptune (`GRAPH_DATABASE_PROVIDER="neptune"`) edge writes for relationship types that contain spaces, hyphens, or openCypher reserved words. The adapter now backtick-quotes (and escapes embedded backticks in) the relationship type when interpolating it into the generated openCypher `MERGE` statements for both single-edge and batched (`UNWIND`) edge upserts, preventing query syntax errors and unsafe interpolation. Also fixes the batched-edge fallback path so that when a batch insert fails, the per-edge retry iterates the edges for that relationship instead of the relationship grouping map. No configuration or migration changes are required, but generated/logged openCypher will now show backtick-quoted relationship-type names.
* Reuses a single `aiohttp.ClientSession` across anonymous telemetry requests instead of opening a new session per call. This avoids a repeated DNS + TCP + TLS handshake to the telemetry endpoint on every event, helping lower latency and connection churn for telemetry. The shared session is created lazily inside the running event loop and rebuilt transparently when the loop changes (for example across tests or `asyncio.run` boundaries) or after it is closed; telemetry stays best-effort and never raises. No new configuration is required, and telemetry can still be turned off with `TELEMETRY_DISABLED=true`.
* Tolerates a missing `dataset_database` table on PostgreSQL during startup migrations and pruning. The `run_startup_migrations()` vector step and the graph/vector prune routines now also catch the asyncpg `ProgrammingError` / `UndefinedTableError`, in addition to the SQLite `OperationalError` already handled. Running against a fresh PostgreSQL/pgvector database (for example the pgvector example) now skips the step with a warning instead of crashing with an undefined-table error.
* Reduces peak memory use of the Postgres graph adapter (`GRAPH_DATABASE_PROVIDER="postgres"`) for graph node and edge relational upserts. `add_nodes`/`add_edges` now stream each batch to Postgres in fixed-size chunks (1000 rows per `INSERT ... ON CONFLICT` statement) instead of compiling one large multi-thousand-row statement, and JSONB property columns are serialized once at execute time via an engine-level `json_serializer` (the UUID/datetime-aware `JSONEncoder`) rather than a per-row `json.loads(json.dumps(...))` round-trip. This helps avoid the transient allocation churn and memory spikes seen on large single-batch writes (the commit reports roughly a 20x reduction). The number of rows written, the upsert/conflict semantics, and the data stored are unchanged; no configuration or migration changes are required.
* Switches `CHUNKS_LEXICAL` search to BM25 ranking. Lexical chunk searches now rank exact-term matches with BM25 instead of the previous Jaccard-style scorer, and the retriever filters default stop words unless explicitly configured otherwise. API signatures stay the same, but result ordering can change for `SearchType.CHUNKS_LEXICAL`.
* Adds lightweight references (Evidence) to completion-style search answers via a new `include_references` flag (default `true`) on `search()`, `recall()`, and the `POST /api/v1/search` and `POST /api/v1/recall` request bodies. When enabled, a deterministic `Evidence:` block is appended to the answer text, assembled in-process (no extra LLM call) from the retrieved chunk payloads, falling back to entity → chunk → document graph traversal when chunk metadata is missing. The response schema and return types are unchanged — Evidence is added to the answer text only. Because this changes default answer text, snapshot and evaluation baselines will diff; set `include_references=False` to restore the exact prior output. Older indexes lacking the new `document_id`/`document_name` chunk fields use the graph fallback where available or omit the Evidence block silently.
* Disables local-variable rendering in logged exception tracebacks. `setup_logging()` now configures the console renderer with `RichTracebackFormatter(show_locals=False)`, so when an exception is logged the traceback no longer expands each frame's local variables. In the retrieval/search path those locals can hold graph objects carrying embedding vectors and deep node/edge references, and rendering them recursively spiked memory to multiple GB and OOM-killed the process (notably in CI) whenever an exception was logged mid-search. Tracebacks themselves are still logged; only the per-frame locals dump is omitted. No configuration changes are required.
* Restores Cognee's safe uncaught-exception hook. `setup_logging()` now installs `sys.excepthook` so non-`KeyboardInterrupt` exceptions are logged through structlog before Python's default traceback is printed, and falls back to plain traceback output if rich rendering itself fails. No configuration changes are required.
* Propagates relational `DATABASE_CONNECT_ARGS` SSL settings to the Postgres maintenance, PGVector, and graph Postgres engines, so connections to managed Postgres that enforce SSL (for example Neon, RDS/Aurora, Azure Database for PostgreSQL) succeed. Previously only the main relational engine received these args, so CREATE/DROP DATABASE maintenance, per-dataset PGVector engines, and the `GRAPH_DATABASE_PROVIDER="postgres"` graph engine could fail with missing-SSL errors. The maintenance engine also maps the libpq `sslmode` key to the asyncpg `ssl` key, and rewrites a Neon `-pooler.` host to its direct endpoint because CREATE/DROP DATABASE cannot run through Neon's PgBouncer pooler. No configuration schema change is required — supply asyncpg SSL options via the existing `DATABASE_CONNECT_ARGS` and they are now honored across Cognee's Postgres engines; the env unset stays a no-op for in-cluster Postgres. Deployments on managed Postgres with enforced SSL should upgrade.
* Fixes two interaction glitches in the graph visualization (`visualize_graph`) story view. Clicking a node no longer displaces it: the click-vs-drag threshold is raised from 3px to 6px so trackpad jitter on a plain click is no longer treated as a drag that reheated the force simulation and sent the clicked node (and, in the **Force** and **Flow** layouts, the whole layout) flying off the canvas. In the **Story** layout, dragging now drives the node position directly instead of reheating the pinned grid, and a released node snaps back cleanly to its lane. Separately, the pipeline stage-header pills (shown in the **Story** and **Flow** layouts) are now drawn in a final pass after edges, nodes, and labels, so a dense graph panned toward the top of the viewport can no longer paint over them. Generated visualization HTML changes only; no API, configuration, or migration changes are required.
* Retries the Kuzu/Ladybug JSON extension load on the live connection when it is missing at runtime. In the subprocess graph worker (`graph_database_subprocess_enabled=true`), if `LOAD EXTENSION` fails with a "not been installed" error, the worker now runs `INSTALL` on the active connection and retries the load once; if that `INSTALL` fails it raises with the real underlying cause instead of the generic load error. This recovers from cases where the best-effort warm-up install on the throwaway database did not complete (for example a transient network error while downloading the extension on a fresh machine). The warm-up install path also now logs its failure cause to stderr (`[ladybug worker] warm-up INSTALL JSON failed: ...`) instead of swallowing it silently, so these conditions are diagnosable from worker/CI logs. The retry may perform an extension install on the live connection and add a small startup delay; no configuration or migration changes are required.
* Relaxes the bundled Ladybug graph-store dependency from the `ladybug==0.16.0` pin to `ladybug>=0.16.0,<0.18`, so installs can pick up the `0.17.x` line. The database migration worker's storage-version table now maps the `0.17` on-disk format (catalog code `41`) to `0.17.1`, so an existing `0.16.x`/`0.17.x` graph database is recognized as current and is not flagged for legacy migration (migration still targets only pre-`0.15.0` databases). No manual database schema changes are required; deployers upgrading should re-lock dependencies (refresh `uv.lock`) and redeploy database workers to pick up the new range.
* Adds a session-context guidance layer and turns it on by default. The cache `AUTO_FEEDBACK` setting now defaults to `true` (previously `false`), so when `CACHING` is enabled, session-capable completion searches run one additional structured-output LLM call per answered turn under the resolved session (`default_session` when `session_id` is omitted) to analyze the current turn against the previous one. The analysis can rewrite the turn into an effective query used for retrieval, accumulate durable per-session guidance grouped into `goals`, `rules`, `preferences`, and `lessons_learned` that can be injected into later answers, and **gate** a follow-up turn — returning a short acknowledgement (the analysis reply, or `"Got it."`) instead of running retrieval and completion. The step fails open to answering the original query when analysis errors or no session is available. Because guidance and the effective query can change retrieval inputs, session answers and turn gating may differ from history-only sessions, and per-turn latency and token usage increase. Set `AUTO_FEEDBACK=false` to disable and restore plain conversation-history replay. See [Sessions and Caching](/core-concepts/sessions-and-caching#session-context-guidance-auto-feedback).
* Bypasses the Instructor structured-output pipeline when `acreate_structured_output` is called with `response_model=str` on the default OpenAI, generic, and Ollama LLM adapters. Plain-text requests are now sent directly to the provider and the model's raw string content is returned, instead of being wrapped in Instructor's JSON/tool-call schema. This avoids repeated parse failures and retry storms on local llama.cpp-compatible servers that don't honor those schemas, and can lower latency for string completions. Rate limiting still applies to these direct calls. Passing a Pydantic model is unchanged — it still returns a validated model instance — so this is a no-action change for callers.
* Fixes the condition that gates name-to-UUID resolution of the `datasets` argument in `search()`. The check was wrapped in a single-element list (`[all(...)]`), which is always truthy, so the name-resolution path ran for any non-`None` `datasets` value. It now runs only when every entry in `datasets` is a string. Passing dataset names (the documented usage) is unaffected; the only behavior change is that non-string entries supplied through `datasets` (for example already-resolved UUIDs) are no longer forced through name-based authorization lookup — pass UUIDs via `dataset_ids` as before. No API signature, default, or migration change is required.
* Corrects two `.env.template` knob names that the config loader was ignoring. The template previously listed `LLM_MAX_TOKENS` and `EMBEDDING_MAX_TOKENS`, but Cognee's settings classes read these values from `LLM_MAX_COMPLETION_TOKENS` (default `16384`) and `EMBEDDING_MAX_COMPLETION_TOKENS` (default `8191`). Anyone who copied the old template and set the chunk-sizing limits under the previous names had them silently ignored, so chunk sizing fell back to the defaults. If you relied on those entries, rename them to `LLM_MAX_COMPLETION_TOKENS` / `EMBEDDING_MAX_COMPLETION_TOKENS` in your `.env`. No code or schema changes are required. The same `.env.template` update also documents additional already-supported settings (LLM/embedding tuning and rate limiting, chunking, session cache, graph/vector connection and subprocess tuning, Langfuse monitoring, llama.cpp, and the auth-token secrets) as commented examples with their defaults.
* Fixes an `UnboundLocalError` in file metadata extraction (`get_file_metadata`) when the underlying file-like object cannot seek. `content_hash` is now initialized before the seek/hash attempt, so when `file.seek(0)` raises `io.UnsupportedOperation` (the error is still logged), metadata is returned with an empty `content_hash` instead of crashing. This makes ingestion more robust for non-seekable file-like inputs; no configuration or API changes are required.
* Preserves structured search completions in the result payload. `SearchResultPayload.completion` now models a single `dict`, a Pydantic `BaseModel`, and a list of models in addition to the previous `str` / list-of-string / list-of-dict shapes, and a custom serializer dumps model instances to their `dict` representation. This fixes searches that pass a non-string `response_model` (typed LLM output via `retriever_specific_config`): the structured object is kept as-is instead of being dropped or coerced into an empty model. The default string-answer path is unchanged; no configuration or migration changes are required.
* Caps LLM retries and recovers from over-length embedding input. The structured-output and transcription adapters (anthropic, azure\_openai, gemini, generic\_llm\_api, llama\_cpp, mistral, ollama, openai) now stop on a fixed number of attempts (`stop_after_attempt`) instead of the previous time-based `stop_after_delay(128)` window, and the instructor retry counts were lowered (for example structured-output generation tops out at 3–4 attempts, while Bedrock's and the other adapters' inner instructor `max_retries` drop to 1–2). This makes transient failures fail faster and at lower cost, with a small reduction in resilience to intermittent errors — watch your LLM error/latency/cost metrics after upgrading. Separately, `LiteLLMEmbeddingEngine` now recovers from over-length embedding input: a context-window error or a `400 BadRequestError` matching `maximum input length` triggers recursive split-and-pool (splitting the batch, or splitting a single string into overlapping halves and averaging the resulting vectors) instead of failing, while other 400 errors still fail fast. No API or configuration changes are required. See [Embedding Providers → Timeout and Retry Behavior](/setup-configuration/embedding-providers).
* Bounds the input-data preview persisted in the `pipeline_runs.run_info` column so a single run cannot grow the table without limit. On pipeline run start, error, and completion, the audit-only `run_info` data is summarized: a list of `Data` records is still reduced to their IDs and empty input is still recorded as `"None"`, but any other payload is now stringified and truncated to a 512-character preview ending with `... [truncated, <N> chars total]` instead of being stored verbatim. `run_info` is never read back during processing; persist large raw inputs (for example text passed to `add()`/`cognify()`) elsewhere if you need the full payload. No configuration or migration changes are required.
* Fixes `forget(everything=True)` under multi-tenant per-dataset database isolation (`ENABLE_BACKEND_ACCESS_CONTROL=true`). The `everything` branch no longer runs inside a single-dataset database context; the per-dataset context is now established per dataset inside the underlying delete-all flow. Previously, entering a single-dataset context with no dataset reference could try to create a `dataset_database` row for a non-existent dataset and fail the operation. Single-dataset, single-item, and `memory_only` modes are unchanged, and the public `forget()` signature, return shapes, and error messages are unchanged.
* Forwards `FALLBACK_ENDPOINT` to the OpenAI adapter's content-policy fallback request (`LLM_PROVIDER="openai"`). Previously this `api_base` override was not applied, so the fallback completion always went to the default OpenAI endpoint even when `FALLBACK_ENDPOINT` was set; now the fallback request is routed to the configured base URL. Deployments that set `FALLBACK_ENDPOINT` to an OpenAI-compatible proxy or alternate endpoint will see their fallback traffic go there. `FALLBACK_ENDPOINT` remains optional for `openai` — when unset, the fallback still uses the default OpenAI endpoint.
* Caps the `instructor` dependency at `<1.15.3` (previously `<2.0.0`) and lowers the `litellm` minimum to `>=1.83.7` (previously `>=1.84.0`). This pins structured-output extraction to a known-good `instructor` range and widens the compatible `litellm` window; lockfiles (`poetry.lock`, `uv.lock`) are refreshed to match. No API or behavioral changes — callers using the high-level `cognify`/`search` APIs are unaffected. Developers and deployers should re-lock and reinstall dependencies to pick up the new constraints.
* Detects Markdown, JSON, XML, and YAML files by extension during file-type guessing. `guess_file_type` now returns deterministic types for `.md`/`.markdown` (`text/markdown`), `.json` (`application/json`), `.xml` (`application/xml`), and `.yaml`/`.yml` (`application/yaml`) instead of relying on content-based detection, which has no magic-number signature for these formats and fell back to `text/plain`/`txt`. The recorded file metadata (`mime_type` and `extension`) for these files now reflects their actual format. Loader selection is unchanged — `TextLoader` already handled these extensions — so no action or migration is required.
* Adds a `GET /api/v1/proposals/{proposal_id}` endpoint for reviewing a stored skill-improvement proposal before applying it. The endpoint takes a required `dataset_id` query parameter and returns the proposal's `status` (`proposed`/`applied`), `confidence`, `rationale`, `model_name`, and before/after procedures (`old_procedure`/`proposed_procedure`); it is read-only and never mutates the graph (applying still goes through `POST /api/v1/remember/entry` with `skill_improvement`). It returns `403` when the caller is not authorized for the dataset and `404` when the proposal is not found.
* Adds no-code, inline skill ingestion. `POST /api/v1/remember` (with `content_type=skills`) now accepts `skills_text` (a `SKILL.md` markdown body as a string) and `skill_name` (the skill name/slug, defaults to `skill`) form fields, so a skill can be ingested without uploading a file — when `skills_text` is set and no files are uploaded, it is written to a temporary `SKILL.md` and ingested through the existing skills pipeline. A new `POST /api/v1/skills` endpoint exposes the same inline ingestion via a JSON body (`skills_text`, optional `skill_name`, and one of `dataset_name`/`dataset_id`).

### Notes

* Includes a behavior-preserving cleanup of the LiteLLM embedding engine (`LiteLLMEmbeddingEngine`): no public `__init__` signature, env-var (`MOCK_EMBEDDING`, `EMBEDDING_ENDPOINT`), or default changes, and embedding behavior is unchanged.
* Deployers upgrading should re-lock dependencies (refresh `uv.lock`) and reinstall, then rebuild/redeploy to pick up the updated dependency set.
* The ontology parser update improves file-like parsing behavior; upload endpoint format restrictions should be documented separately if they change.

***

## v1.1.3

**[View on GitHub](https://github.com/topoteretes/cognee/releases/tag/v1.1.3)**

Patch release focused on API-mode robustness and dependency safety. It enables remote pipeline status checks for MCP/API deployments, improves vector retrieval behavior for empty input, and tightens the `instructor` dependency range.

### Highlights

* Enables `cognify_status` in API mode. The MCP can resolve dataset IDs remotely and read pipeline status from `GET /api/v1/datasets/status`, so self-hosted API deployments can check background pipeline status without local database access.
* Adds API-mode support to `CogneeClient.get_pipeline_status`, which now queries the server's `/api/v1/datasets/status` endpoint instead of raising `NotImplementedError`.
* Makes LanceDB retrieval return an empty list when called with an empty id list, preventing avoidable errors for callers that sometimes have no vector ids to fetch.
* Pins `instructor` below `1.15.3` and refreshes lock metadata. Deployers with exact dependency pins should re-lock or reinstall against the updated constraints.
* Refreshes the README with clearer Cognee positioning, branding, and a research paper link.

***

## v1.1.2

**[View on GitHub](https://github.com/topoteretes/cognee/releases/tag/v1.1.2)**

Patch release with a refreshed public frontend, improved Cloud UI workflows, and a Postgres graph adapter compatibility fix for asyncpg/PostgreSQL 16.

### Highlights

* Syncs the public frontend with the SaaS application, bringing updated dashboard, search, dataset, connection, onboarding, knowledge graph, and graph model editor experiences.
* Adds conversation-based search history and refreshed multi-dataset search flows in the frontend.
* Improves connection and onboarding flows with a connection modal, step-by-step agent setup guidance, new quickstart assets, and updated loading visuals.
* Adds memory customization UI support for datasets, including graph models, custom prompts, and ontology-related configuration.
* Fixes Postgres graph neighborhood expansion under asyncpg/PostgreSQL 16 by casting recursive CTE seed parameters to `text[]`.

### Notable Changes

* Bumps the package version from `1.1.1` to `1.1.2` and refreshes lockfiles.
* Aligns frontend API routes and local development behavior with the OSS backend.
* Updates API key, tenant, configuration, dataset, ingestion, ontology, search-history, session, analytics, and user frontend modules.
* Adds frontend assets for quickstarts, agent integrations, loading states, and graph previews.
* Adds regression coverage for Postgres graph neighborhood seed array typing and retries a flaky usage-logger e2e path in CI.

### Fixes and Improvements

* **Postgres neighborhood query parameter typing**: The Postgres graph adapter's `get_neighborhood` query now casts the seed parameter to `text[]` (`unnest(CAST(:seeds AS text[]))`) in its recursive CTE seed row. Deployments using `GRAPH_DATABASE_PROVIDER=postgres` with asyncpg/PostgreSQL 16 should no longer hit parameter type inference errors when expanding neighbors from seed node ids.
* **Cloud UI refresh**: Dashboard, dataset, dataset detail, connections, search, onboarding, knowledge graph, and graph model editor screens were refreshed and aligned with current Cloud workflows.
* **Search and dataset workflows**: Search now supports conversation history and multi-dataset recall flows, while dataset pages add improved status polling, graph access, and memory customization entry points.
* **Connect Agent flow**: The frontend adds clearer connection setup prompts, modal-based setup guidance, and integration visual assets.
* **Frontend resilience**: Error handling, loading states, analytics logging, tenant context, user configuration, and local fetch behavior were updated across the public frontend.

***

## v1.1.1

**[View on GitHub](https://github.com/topoteretes/cognee/releases/tag/v1.1.1)**

Patch release that promotes accumulated `dev` work after `v1.1.1.dev0`, with agent-management APIs, graph visualization updates, custom graph-model support in `remember`, and backend stability fixes.

### Highlights

* Adds agent management and connection endpoints for listing, creating, inspecting, registering, unregistering, and deleting agents and their active connections.
* Reworks graph visualization with a pipeline-aware Story layout, Schema view, improved labels, legends, and modular visualization components.
* Adds `graph_model` support to the `remember` REST endpoint, letting API callers pass a JSON-serialized graph schema into ingestion.
* Expands graph and retrieval behavior with local Neo4j dataset handling, global context graph bucketing, improved edge text, and `node_name` filtering for chunk retrieval.
* Improves LLM, PGVector, remember/session, prune, forget, and graph-projection error handling.

### Notable Changes

* Bumps the package version from `1.1.0` to `1.1.1` and refreshes the release lockfiles.
* Splits agent lifecycle and connection handling into dedicated modules and API routes, including persisted agent connection state and agent-session names.
* Adds SDK/API support for retrieving specific agent configuration and for inspecting current agent connections.
* Adds local Neo4j dataset database handling and updates graph database selection to recognize that handler.
* Reworks global context index internals with graph bucketing, scoring, build, update, load, summarize, and persistence flows.
* Improves edge indexing and rendering by preserving natural edge descriptions, generating fallback edge text from metadata, and rendering relationship labels inside edge markup.
* Updates CI and test coverage across database adapters, agents, visualization, global context indexing, retrieval filters, and LLM configuration.

### Fixes and Improvements

* **Remember custom graph models**: The `remember` REST endpoint now accepts an optional `graph_model` form field, parses the JSON schema into a graph model, and forwards it into the ingestion flow.
* **Agent lifecycle and connections**: Agent endpoints now separate agent resources from agent connections, support agent-session names, persist connection metadata, mark unregistering agents inactive, and expose connection detail.
* **Graph visualization**: Story view spacing, column pinning, schema rendering, edge-label rendering, and fallback labeling were improved so generated graph views are easier to inspect.
* **Graph ingestion and retrieval**: Edges with unprojectable endpoints are skipped instead of failing graph projection, `KnowledgeGraph` subclasses follow the knowledge-graph integration path, chunk retrieval receives `node_name` filters, and `forget` can handle dataset values that are string UUIDs.
* **PGVector metadata consistency**: `create_collection` now reflects SQLAlchemy metadata only after the table-creation transaction commits, avoiding stale metadata entries when table creation rolls back.
* **LLM adapters**: Generic LLM API transcription and Ollama image transcription now raise clear `ValueError` messages for empty responses, Mistral guards against `None` messages before reading content, and OpenAI instructor mode is honored.
* **Session remember routing**: `remember(session_id=...)` now routes through the JSON `/entry` endpoint in API mode, and using `custom_prompt` with `session_id` raises a clear `ValueError`.
* **Operational stability**: Prune errors and dataset lookup issues are handled more defensively, brittle batch-query test settings were adjusted, and optional LLM configuration can be passed through CI.

***

## v1.1.0.dev1

**[View on GitHub](https://github.com/topoteretes/cognee/releases/tag/v1.1.0.dev1)**

Developer preview release on the way to `v1.1.0dev1`. This release includes API, retrieval, permissions, storage-runtime, and backend consistency changes.

### Highlights

* Adds database subprocess workers for LanceDB and Kuzu so native database work can run outside the main Cognee process. The wheel now includes the `cognee_db_workers` package.
* Exposes more ingestion controls through the public API and remote client paths, including chunk sizing and background execution options for `remember()` and `cognify()`.
* Adds `dataset_ids` support to `recall()`, making shared-dataset retrieval more reliable when dataset names are not owned by the calling user.
* Expands permission management with DELETE endpoints for dataset permissions, roles, and user-role membership.
* Improves session visibility so parent users can see sessions created by child-agent users where appropriate.

### Notable Changes

* Adds `graph_database_subprocess_enabled` and `vector_db_subprocess_enabled` configuration, plus Kuzu tuning variables for threads, buffer pool size, and max DB size.
* Keeps `belongs_to_set` metadata consistent across dataset deletion and shared-node/vector upserts in LanceDB, PGVector, and Neo4j paths.
* Adds `include_payload` behavior to Neptune Analytics vector search.
* Improves Postgres hybrid batching by respecting embedding-engine batch size.
* Improves infer-schema text sampling and prompting.
* Rewrites the examples README into a fuller index and adds performance-testing support with Locust.
* Deprecates `.env.example` as the canonical template in favor of `.env.template`.
* Bumps the package version from `1.0.9` to `1.1.0.dev1` and refreshes lockfiles.

***

## v1.0.3

**[View on GitHub](https://github.com/topoteretes/cognee/releases/tag/v1.0.3)**

Patch release with bug fixes and stability improvements on top of v1.0.2.

### Highlights

* Promotes accumulated `dev` work to `main` for the `v1.0.3` release
* Adds session lifecycle APIs, unified memory/session handling, and dashboard support
* Introduces dataset queueing for async context management and ingestion flows
* Ships new relational migrations, including session lifecycle tables and `parent_user_id`
* Expands recall/remember and cloud routing behavior, plus frontend onboarding and Connect Agent updates

### Notable Changes

* Added session endpoints, metrics, and supporting persistence work
* Added dataset queue infrastructure and follow-up fixes for background processing
* Added database migrations for new tables and user/dataset ownership handling
* Updated recall, remember, improve, and search-related API behavior
* Added frontend work for Connect Agent, dashboard/activity views, API keys, and onboarding
* Included guide updates, workflow/tooling changes, and dependency updates such as `litellm` and `onnxruntime`

### Bug Fixes

* **PostgreSQL null-byte compatibility**: Embedded null bytes (`\x00`) in node or edge string fields no longer cause errors when using PostgreSQL as the relational backend. Null bytes are now automatically stripped from all string values (including nested attributes) before writes to the relational store. This sanitization is transparent — affected strings are silently cleaned rather than rejected.
* Fixed duplicate graph nodes caused by `DataPoint.id` being regenerated during graph construction. The original `id` is now preserved when converting DataPoint instances into graph nodes, ensuring node identity is stable across graph extraction passes.

***

## v1.0.2

**[View on GitHub](https://github.com/topoteretes/cognee/releases/tag/v1.0.2)**

Patch release with bug fixes and stability improvements on top of v1.0.1.

### Bug Fixes

* **LanceDB schema migration**: "contained null values" errors (raised when old rows lack a field required by a newer DataPoint schema) are now treated as recoverable schema drift. The affected table is automatically rebuilt from the current schema instead of raising a hard failure.
* **cognee-mcp Docker image build**: Added missing `build-essential` and `libpq-dev` system packages to the builder stage so that `cognee[postgres]` can compile `psycopg2` from source on Linux.

### Dependency Updates

* Bumped `llama-index-core` requirement from `>=0.13.0,<0.14` to `>=0.14.20,<0.15` for the `llama-index` extra.
* Pinned `nltk>=3.9.3,<4` explicitly in the `docs` extra to satisfy `unstructured`'s dependency until `unstructured` v0.21.0.

***

## v1.0.1

**[View on GitHub](https://github.com/topoteretes/cognee/releases/tag/v1.0.1)**

Patch release with bug fixes on top of v1.0.0.

***

## v1.0.0

**[View on GitHub](https://github.com/topoteretes/cognee/releases/tag/v1.0.0)**

### Highlights

* **New high-level API**: `remember`, `recall`, `improve`, and `forget` cover the full memory lifecycle in four operations
* Session-aware memory via `session_id` — short-term context that can be promoted into the permanent graph
* Unified `recall` replaces the previous `search` call with automatic retrieval strategy selection
* Legacy operations (`add`, `cognify`, `search`, `memify`) remain available as lower-level building blocks

### New Features

* `cognee.remember(data, session_id=...)` — ingest and graph in one call; supports permanent or session memory
* `cognee.recall(query, session_id=...)` — query across both the permanent graph and session cache
* `cognee.improve(...)` — enrich an existing graph with feedback-based weighting and session promotion
* `cognee.forget(dataset=..., session_id=...)` — delete data, datasets, or full session memory

***

## v0.5.4.dev1

**Released:** March 5, 2026\
**[View on GitHub](https://github.com/topoteretes/cognee/releases/tag/v0.5.4.dev1)**

### Highlights

* Developer preview release focused on quality, performance, and developer ergonomics
* Faster ingestion and sync
* Improved search relevance and new filtering options
* Stability fixes for memory creation, deletion, and CLI workflows
* Internal refactoring and dependency upgrades

### New Features

* Bulk import CLI for faster batched ingestion
* Search filters for tags and date ranges
* Optional per-collection ingestion throttling

### Improvements

* Lower latency for ingestion and sync
* Better search ranking
* More robust deletion and duplicate handling
* Clearer CLI messages and debug logs

### Bug Fixes

* Fixed duplicate memories under concurrent ingestion
* Fixed partial state after deletion
* Fixed CLI export formatting issues
* Fixed intermittent retrieval failures under load

***

## v0.5.3

**Released:** February 27, 2026\
**[View on GitHub](https://github.com/topoteretes/cognee/releases/tag/v0.5.3)**

### Highlights

* New graph visualization improvements
* Expanded permissions and user management work
* SessionManager and cache/session persistence work
* Search and graph retrieval improvements
* Multiple stability and CI/CD fixes

### Notable Changes

* Added role-based permission checks and permission endpoints
* Added graph visualization updates, including note set coloring
* Added return type hints to API functions
* Added chunk associations for the memify pipeline
* Added vector filtering based on node sets
* Fixed delete flow bugs, health check issues, MCP issues, and several config/integration issues

***

## v0.5.3.dev1

**Released:** February 20, 2026\
**[View on GitHub](https://github.com/topoteretes/cognee/releases/tag/v0.5.3.dev1)**

### Highlights

* Added vector filtering based on node sets
* Added principal Cognee configuration
* Fixed health check issues
* Fixed FalkorDB adapter port bug
* Fixed Ollama image ingestion argument issue

### Notes

* Includes a small set of targeted fixes and feature work on top of `v0.5.3.dev0`
* Introduced one new contributor in this release