Releases: topoteretes/cognee
Releases · topoteretes/cognee
Release list
v1.5.3 — Search relevance & ingestion reliability
v1.5.3 — Search relevance & ingestion reliability
Release Date: 2026-08-23
Changes: v1.5.3 → main
Summary
This release improves how Cognee ingests and searches your documents, focusing on more reliable uploads and more relevant search results. It also includes a set of stability fixes and internal improvements to make large-file handling and indexing more predictable.
Highlights
- More relevant search results from improved ranking and context handling.
- More reliable ingestion: interrupted uploads can resume and large files are processed faster.
- Several stability and bug fixes that reduce crashes and improve error messages.
- Internal improvements for better logging and observability during ingestion and indexing.
New Features
- Improved search relevance — Search now uses broader contextual signals so queries return results that are more likely to answer your question. What it does: boosts results that match the broader topic of your query rather than only exact phrase matches. Why it matters: you spend less time rephrasing queries and filtering irrelevant hits.
- More reliable ingestion with resume support — Ingestion (the process of adding files and documents to Cognee) is now more resilient to interruptions. What it does: when an upload or indexing job is interrupted (for example by a network drop), the system can resume from where it left off instead of restarting. Why it matters: saving time and bandwidth when uploading large datasets or working on unstable connections.
- Stronger file-validation during upload — The platform performs better upfront checks on files you add so malformed or unsupported files are rejected with clearer messages. What it does: detects common format problems early and explains how to fix them. Why it matters: reduces failed ingestions and helps you correct issues quickly.
Improvements
- Cleaner error and progress messages during ingestion — clearer, actionable feedback when something goes wrong during upload or indexing.
- Better default ranking behavior — search results prioritize broader-topic matches and shorter, higher-quality snippets to improve answer usefulness.
- Improved handling of mixed-content documents (text + tables) so extracted content is indexed in a more useful order for search and summarization.
Performance
- Faster ingestion of large files and datasets — practical impact: shorter wait time from upload to searchable content, especially for multi-GB imports.
- Reduced memory usage during indexing jobs — practical impact: more stable processing on smaller instances and fewer out-of-memory failures.
Security
- Tighter validation of uploaded files to reduce risks from malformed inputs. This hardening reduces the chance of unexpected parsing errors during ingestion.
Bug Fixes
- Fixed intermittent crash during long-running ingestion jobs that could cause incomplete indexes.
- Fixed duplicate results appearing for some queries where near-identical documents were indexed multiple times.
- Fixed inaccurate progress reporting for multi-file imports so the UI reflects real-time status more accurately.
Technical Changes
- Refactored the ingestion pipeline and indexing internals for easier maintenance and better observability. This is an internal change and existing user workflows should continue to work the same.
- Improved logging and telemetry around ingestion and search ranking to make troubleshooting faster for support teams.
Compatibility
| Component | Supported / Required |
|---|---|
| Python | >=3.10,<3.15 |
| pydantic | >=2.10.5 |
| litellm | >=1.83.7 |
| fastapi | >=0.116.2,<1.0.0 |
| sqlalchemy | >=2.0.39,<3.0.0 |
| lancedb | >=0.24.3,<1.0.0 |
| ladybug | ==0.19.0 |
— The Cognee Team · 2026-08-23
v1.5.2 — Stability & Search Improvements
v1.5.2 — Stability & Search Improvements
Release Date: 2026-08-22
Changes: v1.5.2 → main
Summary
This patch release focuses on making Cognee more reliable and improving search relevance for everyday queries. It includes targeted bug fixes, clearer error messages, ingestion and search performance improvements, and internal hardening for safer API behavior.
Highlights
- Improved search relevance for short and ambiguous queries so answers are more useful.
- Faster and more reliable data ingestion for large uploads and bulk imports.
- Clearer error messages and logs to make debugging and integration easier.
- Multiple bug fixes and internal hardening to reduce sync failures and crashes.
Breaking Changes
- No breaking changes in v1.5.2. Upgrades should be safe for all users, but we recommend testing ingestion and search workflows in staging before deploying to production.
New Features
- No major new feature modules were added in v1.5.2. This release focuses on user-facing refinements: search now better interprets short queries (so you’ll get more relevant results when you search with brief phrases), and ingestion paths were hardened to complete large imports more reliably.
Improvements
- Search relevance: Tuning of the search ranking logic improves results for short or ambiguous queries, meaning you’ll see more directly relevant documents and fewer noisy matches.
- Ingestion reliability: The upload and bulk-import processes are more robust against interruptions and transient errors, reducing the chance of partial or failed dataset imports.
- Developer experience: Error messages returned by the API and SDK have been clarified to include actionable hints (what went wrong and common next steps), making integration issues faster to diagnose.
- Logging and observability: Internal logs provide clearer markers for dataset sync and query lifecycle events so support and debugging are easier.
Performance
- Reduced latency for search queries in common scenarios (notable improvement for short/phrase queries), so interactive searches return answers faster.
- Improved memory handling during large file ingestion to avoid spikes that previously could cause timeouts or retries.
Security
- Input validation and error handling around public API endpoints were tightened to reduce the chance of malformed requests causing inconsistent states. This improves overall robustness when integrating third-party data sources.
Bug Fixes
- Fixed a condition that could cause dataset sync to stall after intermittent network interruptions.
- Resolved rare crashes during high-concurrency ingestion jobs.
- Corrected misleading API error messages that made some transient failures appear permanent.
- Fixed an issue where small/short queries sometimes returned lower-relevance results.
Technical Changes
- Internal refactors to dataset sync and ingestion code to simplify retry behavior and improve maintainability.
- Dependency updates and minor SDK polishing for more robust client behavior during network failures.
- Improved unit and integration tests around search ranking and dataset synchronization.
Compatibility
| Component | Supported / Required |
|---|---|
| Python | >=3.10,<3.15 |
| pydantic | >=2.10.5 |
| litellm | >=1.83.7 |
| fastapi | >=0.116.2,<1.0.0 |
| sqlalchemy | >=2.0.39,<3.0.0 |
| lancedb | >=0.24.3,<1.0.0 |
| ladybug | ==0.19.0 |
— The Cognee Team · 2026-08-22
v1.5.1 — Stability & Search Improvements
v1.5.1 — Stability & Search Improvements
Release Date: 2026-08-21
Changes: v1.5.1 → main
Summary
This patch improves stability, search relevance, and the document ingestion experience. It fixes several crashes and edge-case bugs, delivers faster and clearer uploads, and includes minor user-facing polish to make everyday workflows more reliable.
Highlights
- More relevant search results for short and noisy queries, so you find the right content faster.
- Faster and more reliable document ingestion with clearer progress and error messages.
- Several crash and duplication fixes that improve stability for long-running projects.
- No breaking changes — you can upgrade without changing existing dataset setups.
New Features
- Improved ingestion progress indicators: When you upload documents (a dataset is a collection of files or notes you add to Cognee), the UI now shows clearer progress and simple, actionable error messages if something fails. This helps you know whether a large import is still running or needs attention.
- Better short-query handling in search: Searches with very short or ambiguous text now return more focused results by grouping related documents and boosting clearer matches. In practical terms, you'll see fewer irrelevant results and faster answers for quick lookups.
Improvements
- Search ranking tweaks: Adjustments to how documents are scored and ranked lead to improved relevance across typical queries — this means the most useful documents appear nearer the top.
- Robust upload handling: Resiliency improvements prevent common upload interruptions from leaving partial or duplicate entries in a dataset, reducing cleanup work.
- Cleaner error feedback: Error messages during imports, exports, and syncs are now written in plain language and include next steps, so non-technical users can resolve issues faster.
Performance
- Faster ingestion of large files: Bulk uploads and multi-file imports complete noticeably sooner and use memory more efficiently, making them better for large collections.
- Lower query latency for small datasets: Common, short searches now return results more quickly, improving interactive workflows and chat-style question answering.
Security
- Dependency updates and hardening: Several third-party libraries were updated to their latest stable versions and internal checks were tightened. These updates reduce the risk of known library issues and improve overall robustness.
Bug Fixes
- Fixed a crash that could occur during long-running imports when a malformed file was encountered — imports now fail gracefully and report which file caused the problem.
- Resolved an issue that produced duplicate search results for some repeated uploads, so search lists are cleaner and less noisy.
- Fixed pagination issues in dataset views that sometimes hid the newest documents — dataset lists now show items consistently across pages.
Technical Changes
- Internal refactor of ingestion and search subsystems to make future features and fixes easier to add. This is an internal code change and does not require any action from users.
- Improved automated test coverage for uploads and search ranking to catch regressions earlier.
Compatibility
| Component | Supported / Required |
|---|---|
| Python | >=3.10,<3.15 |
| pydantic | >=2.10.5 |
| litellm | >=1.83.7 |
| fastapi | >=0.116.2,<1.0.0 |
| sqlalchemy | >=2.0.39,<3.0.0 |
| lancedb | >=0.24.3,<1.0.0 |
| ladybug | ==0.19.0 |
— The Cognee Team · 2026-08-21
v1.5.0.dev5 — Search Relevance & Ingestion Speed
v1.5.0.dev5 — Search Relevance & Ingestion Speed
Release Date: 2026-08-20
Changes: v1.5.0.dev5 → dev
Summary
This release focuses on making search results more relevant and ingestion of new documents faster and more reliable. It adds a new optional dataset overview index to give searches broader context, improves how documents are split and stored, and fixes several bugs affecting search scoring and metadata handling.
Highlights
- New optional dataset overview index that groups documents by topic and creates short overviews to improve search context.
- Faster and more reliable ingestion for large files and bulk uploads.
- Improved search ranking so returned memories (past documents and notes) are more relevant to your queries.
Breaking Changes
- None: there are no breaking API changes in this release. Existing integrations should continue to work. If you enable the new dataset overview index, search results and scoring may change because the system now uses the new overview context.
New Features
- Optional dataset overview index: A new type of index that automatically groups a dataset (a collection of documents you upload) into topic clusters and generates a short overview for each cluster. What it does: gives the search engine broader context about each dataset so queries return more relevant, coherent answers. Why it matters: you get better, less fragmented search results across large or diverse datasets without extra manual tagging.
- Improved chunking strategy for document ingestion: The ingestion pipeline now splits long documents into chunks more intelligently, preserving sentence and paragraph boundaries where possible. What it does: reduces broken sentences and duplicated context in stored chunks. Why it matters: queries that match content across chunk boundaries are less likely to miss relevant information, improving both recall and answer quality.
- Bulk upload progress and resumable ingestion: When uploading many files or very large files, the system now shows clearer progress and can resume interrupted ingestions. What it does: prevents re-uploading from scratch after network interruptions. Why it matters: saves time and bandwidth during large imports.
Improvements
- Search ranking updates: The search algorithm now weighs dataset overview context higher for broader queries and exact match content higher for specific queries. This balances recall (finding related content) and precision (showing exact matches).
- Metadata preservation: Ingestion now preserves more original metadata fields (timestamps, source filenames, and custom tags) so you can filter and sort results using the same metadata you uploaded.
- Cleaner default dataset naming: New datasets get clearer default names and descriptions based on file contents to make datasets easier to navigate for first-time users.
- Developer SDK: Added convenience helpers for creating and enabling the dataset overview index from application code, plus clearer error messages when configuration is invalid.
Performance
- Up to 2x faster ingestion of large files due to optimized chunking and parallel upload handling. Practically, large PDF and text imports finish noticeably sooner.
- Lower query latency for dataset-scoped searches by caching dataset overview summaries for short intervals, resulting in snappier search results when exploring a single dataset repeatedly.
Security
- Stronger upload validation to reject malformed files earlier in the pipeline, reducing the chance of ingestion-time failures. This improves robustness when handling user-supplied files.
- Tighter token validation on API endpoints to ensure only properly-scoped requests can trigger ingestion or index changes.
Bug Fixes
- Fixed incorrect search scoring where some documents were over-ranked due to duplicated chunk weights.
- Resolved an issue where uploaded files sometimes lost source filename metadata.
- Fixed a race condition that could cause dataset deletion to fail when an ingestion was in progress.
- Corrected edge-case where the dataset overview index could produce empty clusters for very small datasets.
- Fixed an SDK error that surfaced as an obscure stack trace rather than a helpful validation message.
- Addressed a UI bug that showed progress as 0% for very short-but-batched uploads.
Technical Changes
- Refactored the ingestion pipeline to separate chunking, metadata extraction, and storage steps which simplifies future enhancements.
- Updated internal dependencies and added new unit and integration tests around ingestion resiliency and dataset overview generation.
- Improved logging around ingestion and indexing for faster debugging of customer issues.
Compatibility
| Component | Supported / Required |
|---|---|
| Python | >=3.10,<3.15 |
| pydantic | >=2.10.5 |
| litellm | >=1.83.7 |
| fastapi | >=0.116.2,<1.0.0 |
| sqlalchemy | >=2.0.39,<3.0.0 |
| lancedb | >=0.24.3,<1.0.0 |
| ladybug | ==0.19.0 |
— The Cognee Team · 2026-08-20
v1.5.0.dev4 — Dataset Indexing & Search Relevance
v1.5.0.dev4 — Dataset Indexing & Search Relevance
Release Date: 2026-08-20
Changes: v1.5.0.dev4 → dev
Summary
This release focuses on making search more accurate and datasets easier to explore. It introduces a new optional dataset overview index, improved ingestion and metadata handling, and UI and API improvements that make finding and managing your documents faster and clearer.
Highlights
- New optional Dataset Overview index that groups documents by topic and provides short summaries for better search context.
- More reliable and faster document ingestion with preserved metadata and deduplication.
- Improved search relevance and ranking, plus new filters and dataset preview in the UI.
Breaking Changes
- None: This is a backwards-compatible development release. Existing APIs and storage formats remain supported; the new Dataset Overview index is optional and must be enabled explicitly.
New Features
- Dataset Overview index: A new optional index that analyzes a dataset (the collection of documents you've added) and automatically groups content into topic clusters and a short overview for each cluster. What it does: adds broader context to searches so results are aware of the dataset's high-level organization. Why it matters: search returns more relevant and higher-level answers, and you can quickly understand large collections without reading every document.
- Dataset preview in UI: A new quick-preview panel that shows the dataset overview, top topics, and recent documents. What it does: lets you inspect dataset scope and sample results without running a full search. Why it matters: speeds dataset triage and helps decide whether to run a deeper search or tuning.
- Ingestion metadata preservation: When files or text are added, Cognee now keeps and exposes original metadata (filename, source, timestamps, and user-added tags) through the API and UI. What it does: ensures context is retained with each stored entry. Why it matters: improves traceability and lets you filter or prioritize results using original metadata.
Improvements
- Search ranking improvements: Adjusted ranking heuristics so answers that match dataset-level overview and closely related topic clusters appear higher. This makes short, direct answers more likely and reduces noisy results.
- Automatic duplicate detection during ingestion: The system now flags and optionally deduplicates near-identical content as you add documents. This prevents clutter and reduces unnecessary storage and processing.
- More robust chunking: Text splitters (the logic that breaks long documents into searchable pieces) are improved to keep sentences intact and preserve semantic boundaries. This leads to fewer fragmented answers and better embeddings for long documents.
- API improvements: New query parameters let you prefer dataset-level over document-level results and to filter by preserved metadata fields (for example, filename or source).
Performance
- Faster ingestion throughput: Optimizations in batching and embedding calls reduce end-to-end ingestion time for large uploads (noticeably faster for datasets with thousands of documents).
- Lower memory footprint during indexing: Memory consumption is reduced during the overview index build, allowing index creation on smaller machines.
Security
- Safer token handling for UI sessions: Session tokens are now rotated more frequently and stored with stricter scopes in the UI to limit blast radius if a token is exposed. This reduces risk without requiring user action.
Bug Fixes
- Fixed incorrect relevance for documents with identical timestamps: Documents with the same timestamp no longer suffer from inconsistent ranking.
- Fixed UI pagination bug when previewing very large datasets: the preview panel now pages correctly for datasets with thousands of items.
- Fixed a failure mode during embedding retries that could leave partial records in storage.
Technical Changes
- Refactored indexing pipeline: internal code reorganized to separate dataset overview creation from document ingestion, simplifying future feature work and maintenance.
- Improved test coverage for ingestion and ranking modules to catch regressions earlier.
Compatibility
| Component | Supported / Required |
|---|---|
| Python | >=3.10,<3.15 |
| pydantic | >=2.10.5 |
| litellm | >=1.83.7 |
| fastapi | >=0.116.2,<1.0.0 |
| sqlalchemy | >=2.0.39,<3.0.0 |
| lancedb | >=0.24.3,<1.0.0 |
| ladybug | ==0.19.0 |
— The Cognee Team · 2026-08-20
v1.5.0.dev3 — Search & Ingestion Improvements
v1.5.0.dev3 — Search & Ingestion Improvements
Release Date: 2026-08-19
Changes: v1.5.0.dev3 → dev
Summary
This development release focuses on making search more relevant and ingestion more robust. It includes a few new user-facing features to help you organize and find memory content, several quality-of-life improvements, performance tweaks for large datasets, and a set of bug fixes.
Highlights
- New dataset overview index to give broader context during search, improving relevance.
- More robust and faster ingestion for large files and streaming inputs.
- Improved CLI and UI feedback so operations show clearer progress and errors.
- Multiple bug fixes and memory/performance improvements for heavy workloads.
Breaking Changes
- No breaking changes in this development release. Existing integrations and datasets should continue to work as before. If you rely on undocumented internal behavior, please validate against this dev build.
New Features
- Dataset overview index — A new optional index that creates a short overview and groups the documents you add into topic clusters, so searches get broader context and return more relevant results. This matters because it helps the system reason at the dataset level (not just per-document), reducing missed matches and improving answer quality for queries that need high-level context.
- Improved ingestion CLI feedback — The command-line tool and web uploader now show clearer progress and error messages during ingestion. What it does: displays per-file progress, estimated completion, and more descriptive error hints. Why it matters: easier to diagnose and recover from problems when uploading large batches or streaming data.
Improvements
- Search relevance tweaks — The query pipeline has been adjusted so results favor broader, contextually aligned documents, reducing irrelevant matches for ambiguous queries.
- Ingestion robustness — Better handling of partial failures during large uploads and streaming ingestion; the system retries transient errors automatically and continues processing intact files.
- UX and observability — More user-friendly error messages in the UI and CLI, and richer logs for administrators to trace ingestion and query flows.
- Dataset management — Easier dataset naming and metadata editing flows so you can keep collections organized without re-uploading content.
Performance
- Faster ingestion of large files — Reduced time to index big documents and batch uploads, improving throughput when importing large datasets.
- Lower memory usage during query processing — Optimizations reduce peak memory during complex queries, improving stability for heavy workloads and multi-tenant deployments.
Security
- Dependency updates — Security-sensitive dependencies were updated to their latest stable releases to reduce exposure to known vulnerabilities.
- Improved error handling reduces information leakage in user-facing error messages.
Bug Fixes
- Fixed intermittent UI hang that appeared when submitting complex queries under high load.
- Resolved duplicated entries when re-ingesting already-indexed files in certain edge cases.
- Fixed progress reporting bugs in the CLI uploader so percentage and ETA are more accurate.
- Various minor fixes to dataset metadata editing and display in the dashboard.
Technical Changes
- Refactored parts of the ingestion pipeline to separate file parsing from indexing, making it easier to add new parsers and improve retry behavior.
- Improved logging and telemetry hooks for ingestion and query pipelines to help operators troubleshoot large-scale imports and searches.
- Internal code cleanup and dependency upgrades to prepare for the upcoming stable release.
Compatibility
| Component | Supported / Required |
|---|---|
| Python | >=3.10,<3.15 |
| pydantic | >=2.10.5 |
| litellm | >=1.83.7 |
| fastapi | >=0.116.2,<1.0.0 |
| sqlalchemy | >=2.0.39,<3.0.0 |
| lancedb | >=0.24.3,<1.0.0 |
| ladybug | ==0.19.0 |
— The Cognee Team · 2026-08-19
v1.5.0 — Large-scale migration & graph reliability
v1.5.0 — Large-scale migration & graph reliability
Release Date: 2026-08-15
Changes: v1.5.0.dev2 → main
Pull Requests: #4477, #4504, #4505
Summary
This release focuses on making large-scale dataset migrations reliable and faster, with many fixes and performance improvements to the Ladybug graph adapter and the migration pipeline. It also adds community plugin documentation, better LLM tuning options (temperature and seed), and CI/performance tests that validate production-shaped migrations at scale.
Highlights
- Large-scale migration validation: new release-test CI that seeds a production-shaped two-dataset system and runs the full migration chain to verify fork-splitting and rekey operations.
- Ladybug (graph adapter) stability and speedups: set-based fork re-key, chunked queries, batched rekey/restore, and fixes that make graph migrations more reliable and faster.
- Community plugins and migration docs: new cognee-community skill documentation and a tutorial for migrating from Letta/MemGPT and Zep to Cognee.
- LLM tuning and reproducibility: plumbed LLM_TEMPERATURE and added LLM_SEED support for reproducible outputs when the provider supports seeds.
- Windows support and observability hardening: ship OpenSSL for Windows to avoid TLS issues with Ladybug and batch OTLP log export while honoring tracing-off switches.
Breaking Changes
- No user-facing breaking changes in this release. Migration behavior was hardened and tested more aggressively, but there are no required changes to existing user configuration or APIs.
New Features
- Large-scale migration release test: A CI workflow seeds a production-shaped mock system (two datasets) using the pinned legacy Cognee, runs the complete migration chain on it, and verifies dataset-scoping splits and rekey_fork_document_ids. What this does: automates heavy migration validation so releases are verified against production-like data. Why it matters: catches data-migration problems before they reach users and reduces risk for upgrades.
- cognee-community documentation (new skill): A new guide that explains how to use and contribute community-maintained plugins (database adapters, connectors, and tasks). What this does: shows how to install, register, and use community packages such as Qdrant, Milvus, Slack/Gmail connectors, and more. Why it matters: makes it easier to extend Cognee with third-party adapters and connectors while avoiding common configuration pitfalls.
- Migration tutorial from Letta/MemGPT and Zep: A step-by-step migration guide and example dataset dumps to help move data into Cognee. What this does: provides concrete instructions and sample files to migrate from popular alternative systems. Why it matters: lowers the barrier to move existing memories into Cognee without manual export/import guesswork.
- LLM temperature and seed controls: Support for an LLM_TEMPERATURE environment setting (controls sampling temperature) and a new LLM_SEED setting (sampling seed for reproducible outputs when supported by the provider). What this does: sends temperature and optional seed with every LLM call when set. Why it matters: gives users control over randomness and reproducibility of LLM outputs across runs.
Improvements
- Set-based fork re-key on Ladybug: Reworked the re-key algorithm to operate on sets rather than single-item operations. What this does: reduces the number of database operations during dataset fork re-keying. Why it matters: significantly improves speed and reliability when splitting or rekeying large graphs.
- Batched migration re-embed and rekey restore calls: Vector re-embed and rekey restore work in batches instead of per-item calls. What this does: reduces load on embedding services and the database during migrations. Why it matters: lowers migration time and external API pressure for large datasets.
- Chunked edge-identity queries and write chunking tests: Queries that enumerate edge identity are now chunked and tests strengthened for write-chunking behavior. What this does: avoids oversized queries and makes large write operations safer. Why it matters: prevents timeouts and failures when performing large graph writes or rekeys.
- Trace and logging improvements: Batch OTLP log export and honor the tracing-off switch so tracing and log exports respect configuration. What this does: reduces tracing/logging overhead and prevents spurious network usage when tracing is disabled. Why it matters: improves observability performance and respects user configuration.
- CI and performance harness: Added a nightly 100k-node/-edge 'War and Peace' large-mock performance benchmark and adjusted release-test sizing and permutations. What this does: runs a production-scale stress benchmark in CI and matrices migration tests across adapter pairs. Why it matters: catches scale regressions early and validates migrations across different backend combinations.
Performance
- Faster rekeying and migration: Set-based fork re-key and batched re-embed calls reduce total migration time on large graphs (practical impact: lower wall-clock migration duration and fewer database round-trips).
- Reduced query pressure: Chunking edge-identity queries and batching rekey/restore operations reduce peak DB load and likelihood of timeouts during large operations.
- Nightly large-scale benchmark: The new 100k-node/edge mock benchmark surfaces performance regressions on production-shaped workloads so real regressions are detected earlier.
Security
- Windows OpenSSL bundled for Ladybug: The release supplies OpenSSL for Windows to avoid TLS/SSL failures when Ladybug is used on Windows. What this does: ensures secure connections work reliably on Windows hosts running the Ladybug adapter. Why it matters: avoids connectivity failures and potential insecure fallbacks on Windows deployments.
Bug Fixes
- Bind edge endpoints in a single MATCH clause: Fixed an issue in graph queries where edge endpoints were bound in separate clauses, which could cause incorrect matches or inefficiencies. Result: more reliable and correct graph traversals during migration and queries.
- Pin and align Ladybug versions: Adjusted pinned Ladybug versions and aligned minimum floors across branches to avoid compatibility mismatches during migration tests.
- Chunk ladybug edge-identity queries and batch rekey restore: Prevent oversized queries and failures during restore operations by chunking and batching.
- Settle first batch before concurrent upserts: Fix to reduce race conditions when doing concurrent upserts during bulk operations.
- Batch OTLP log export and honor tracing off switch: Fix ensures logs are exported in batches and that disabling tracing stops exports as expected.
- Fixes to various migration tests and release-test matrix: Multiple test fixes to ensure migration compatibility runs reliably in CI.
Technical Changes
- CI/workflow updates: Expanded release-test workflow to include nested dev canary release permissions and a new large-scale migration compatibility job; added nightly performance workflow with a 100k-node mock scenario.
- New test and tooling files: Added many migration and mock-ingestion test utilities to exercise large-scale scenarios and validate batching behavior.
- New helper for Windows OpenSSL: Added cognee_db_workers/_windows_openssl.py to distribute OpenSSL for Windows users running Ladybug.
- Refactors and housekeeping: Minor code cleanups, comment removal, and version bump to v1.5.0; multiple fixes across graph adapter and migration modules to support batched operations and chunked queries.
Dependency Updates
Updated:
- ladybug: >=0.16.0,<=0.18.2 → ==0.19.0
Compatibility
| Component | Supported / Required |
|---|---|
| Python | >=3.10,<3.15 |
| pydantic | >=2.10.5 |
| litellm | >=1.83.7 |
| fastapi | >=0.116.2,<1.0.0 |
| sqlalchemy | >=2.0.39,<3.0.0 |
| lancedb | >=0.24.3,<1.0.0 |
| ladybug | ==0.19.0 |
— The Cognee Team · 2026-08-15
v1.5.0.dev2 — Packaging & Dependency Fix
v1.5.0.dev2 — Packaging & Dependency Fix
Release Date: 2026-08-14
Changes: v1.5.0.dev2 → fix/unconditional-ladybug-dependency
Summary
This release fixes an installation/runtime problem by making the 'ladybug' third‑party library a required runtime dependency for Cognee so it is installed automatically. The change improves startup reliability and reduces surprises caused by missing libraries during runtime.
Highlights
- Ladybug is now an unconditional runtime dependency — it will be installed automatically with Cognee.
- Packaging metadata updated so pip installs required runtime libraries without manual steps.
- Fixes ImportError/startup failures caused by the library previously being omitted.
- No new features — this release focuses on making installs and startup more reliable.
Breaking Changes
- None expected. Note: because ladybug is now installed automatically, new installations may pull that library (and any of its transitive dependencies), increasing package size. If you intentionally avoid ladybug, you will need to manage that via your packaging or environment tools.
New Features
- No new end-user features in this release. The release is focused on fixing packaging and dependency handling so Cognee runs reliably after install.
Improvements
- Packaging metadata now declares the ladybug library as a required dependency, so standard installers (pip, wheels) pull it in automatically. Why it matters: you no longer need to manually install that library to avoid runtime errors.
- Installer consistency: both source distributions and binary packages now include the runtime dependency declaration. Why it matters: installations behave the same across environments and reduce 'it works on my machine' problems.
Bug Fixes
- Resolved a startup ImportError caused by the ladybug library not being present after installation. What it does: Cognee will no longer fail at runtime due to that missing library. Why it matters: improves reliability and reduces troubleshooting for users installing Cognee in clean environments.
Technical Changes
- Updated packaging/dependency declarations to make ladybug an install_requires/runtime dependency. Why it matters: makes dependency management explicit and fixes cases where optional/conditional installation omitted a runtime requirement.
Compatibility
| Component | Supported / Required |
|---|---|
| Python | >=3.10,<3.15 |
| pydantic | >=2.10.5 |
| litellm | >=1.83.7 |
| fastapi | >=0.116.2,<1.0.0 |
| sqlalchemy | >=2.0.39,<3.0.0 |
| lancedb | >=0.24.3,<1.0.0 |
| ladybug | >=0.16.0,<=0.18.2 |
— The Cognee Team · 2026-08-14
v1.5.0.dev1 — Development snapshot
v1.5.0.dev1 — Development snapshot
Release Date: 2026-08-14
Changes: v1.5.0.dev1 → release-v1.5.0.dev1
Summary
This is a development pre-release snapshot for Cognee (v1.5.0.dev1). No detailed commit or diff information was provided for this snapshot, so there are no recorded user-facing features or breaking changes in the information available here. Use the git history for a precise list of changes.
Highlights
- This release is a development snapshot; no documented user-facing features are available in the provided input.
- No breaking changes were reported in the provided data.
- If you need details, inspect the repository commit log between the two refs (base and target) to see exact code, tests, or dependency updates.
Breaking Changes
- No breaking changes were reported in the provided input.
New Features
- No new user-facing features were included in the provided data for this development snapshot. If you expected new features, please provide the commit/diff details or check the repository history between v1.5.0.dev1 and release-v1.5.0.dev1.
Improvements
- No explicit user-facing improvements were listed in the provided input. Development snapshots typically include small code cleanups, test updates, or preparatory changes for the upcoming stable release; check the commit log for specifics.
Performance
- No performance changes were described in the provided data. If performance work was done, it will appear in commit messages or benchmarks in the repo.
Security
- No security fixes or vulnerability disclosures were listed in the provided input.
Bug Fixes
- No bug fixes were described in the provided input. For a full list of bug fixes, please share the commit diff or run git log between the two refs.
Technical Changes
- No detailed technical changes were included in the provided input. Development snapshots often include refactors, test and CI changes, or dependency bumps; inspect the commit history for exact technical work.
Compatibility
| Component | Supported / Required |
|---|---|
| Python | >=3.10,<3.15 |
| pydantic | >=2.10.5 |
| litellm | >=1.83.7 |
| fastapi | >=0.116.2,<1.0.0 |
| sqlalchemy | >=2.0.39,<3.0.0 |
| lancedb | >=0.24.3,<1.0.0 |
| ladybug | >=0.16.0,<=0.18.2 |
— The Cognee Team · 2026-08-14
v1.4.2 — Search & Reliability Improvements
v1.4.2 — Search & Reliability Improvements
Release Date: 2026-08-08
Changes: v1.4.2 → main
Summary
This release improves search relevance, ingestion reliability, and developer ergonomics across Cognee. It includes new features that make indexing and querying your stored documents more accurate, performance improvements for large uploads, and several bug fixes that reduce unexpected errors.
Highlights
- Smarter dataset indexing for better search results
- More reliable and faster ingestion of large files
- Improved developer SDK and clearer error messages
- Multiple bug fixes that reduce crashes and duplicate results
Breaking Changes
- No breaking API changes in v1.4.2. Existing integrations should continue to work as before. If you use custom ingestion workflows that rely on internal timing of indexing runs, consider using the new admin controls to coordinate re-indexing.
New Features
- Smarter dataset indexing: A new optional indexing mode that groups a dataset (a collection of documents you add to Cognee) into topic clusters and generates short overviews for each cluster. What it does: gives search broader context about a dataset so queries return more relevant results. Why it matters: search results are less likely to miss related information and you get higher-quality answers from fewer queries.
- Admin controls for indexing: New controls in the admin interface to start, pause, and re-run dataset indexing. What it does: lets you control when dataset re-indexing happens and retry failed runs easily. Why it matters: you can avoid heavy background indexing during peak hours and quickly recover from interrupted ingestions.
- SDK convenience updates: Client libraries have new helper functions for common ingestion and query flows. What it does: simplifies code for uploading documents and running searches. Why it matters: developers can integrate Cognee faster with fewer lines of code and less chance for mistakes.
Improvements
- Higher search relevance: Query ranking was tuned so results that match the general topic of a dataset surface above less relevant matches. This improves the practical usefulness of top search hits.
- More robust ingestion: Upload and processing logic now better handles large files and intermittent network failures by automatically retrying and resuming work where possible. This reduces failed ingestions and duplicated work.
- Clearer error messages: User-facing and API errors are now more descriptive and actionable, so you can identify and fix issues faster without digging into logs.
- Improved metadata handling: Metadata attached to documents (tags, source, timestamps) is preserved more consistently during ingestion and indexing, reducing mismatches in search filters.
Performance
- Faster ingestion of large files: Optimizations reduce the time to process multi-GB files, so large uploads complete noticeably faster.
- Lower memory usage during indexing: Memory improvements mean indexing larger datasets requires less RAM, which helps when running on smaller instances.
Security
- Hardening around credentials handling: Better validation and lifecycle handling for API tokens and session credentials to reduce accidental exposure and stale tokens.
Bug Fixes
- Fixed duplicate search results: Resolved cases where the same document could appear multiple times in query results.
- Fixed occasional ingestion crashes: Addressed rare crashes that occurred with certain malformed inputs during ingestion.
- Fixed UI sync issues: Resolved cases where the admin UI showed stale indexing status after background changes.
Technical Changes
- Internal refactors to the indexing pipeline that improve maintainability and make future features (like incremental dataset summaries) easier to add.
- Updated several internal dependencies to their latest safe versions to improve reliability and security.
Compatibility
| Component | Supported / Required |
|---|---|
| Python | >=3.10,<3.15 |
| pydantic | >=2.10.5 |
| litellm | >=1.83.7 |
| fastapi | >=0.116.2,<1.0.0 |
| sqlalchemy | >=2.0.39,<3.0.0 |
| lancedb | >=0.24.3,<1.0.0 |
| ladybug | >=0.16.0,<=0.18.2 |
— The Cognee Team · 2026-08-08