Skip to main content
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.
  • 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.

​
v1.2.1

View on GitHub 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 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.
  • 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.
  • 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 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 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 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 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 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 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 Patch release with bug fixes on top of v1.0.0.

​
v1.0.0

View on GitHub

​
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

​
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

​
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

​
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