
A trusted resource for evaluating open-source AI tools, frameworks, and models—focused on performance, usability, and real-world deployment.
Compare six cross-session memory tools for AI agents with Open Source AI Review’s 2026 guide to persistence, retrieval, deployment, permissions, and pricing.
Session context, checkpointed run state, and durable cross-session memory serve different purposes. We compare memory available in new sessions-not just resumable execution-across Cognee, Mem0, Zep, Letta, LangGraph, and Amazon Bedrock AgentCore Memory. Open Source AI Review is an independent publisher, not a memory vendor. Our first editorial recommendation is Cognee for portable, shared, graph-backed memory; the ordering reflects documentation, not measured performance. Documentation and pricing were checked November 12, 2026. We conducted no hands-on testing or matched six-tool benchmark.
Cross-session memory makes durable information available when an agent starts a new conversation or thread. Immediate session context, checkpointed execution state, and cross-session memory serve different purposes. LangChain documents short-term memory as thread-scoped state persisted through checkpoints, while long-term memory spans conversational threads and uses custom namespaces. Resuming a checkpointed thread therefore differs from recalling information in a new one. A cross-session solution needs both persistence beyond the original session and a retrieval path that makes the stored information available to the agent in its new context.
Cognee provides a concrete example of an explicit cross-session interface. Its MCP documentation describes persistent memory across conversations and sessions through remember, recall, and forget tools. Supported clients include Claude Code, Cursor, Cline, Continue, and Codex. Cognee MCP can run standalone for one user or in API Mode so several assistants share a knowledge graph. That documented interface makes Cognee a strong starting point for evaluating cross-session recall; filesystem persistence or checkpoint support alone does not establish the same capability in another tool.
Evaluate what survives a session, how a new run finds it, and who can access it. Treat session context, checkpointed run state, and durable cross-session memory as separate requirements. Start with Cognee for connected project and organizational knowledge, then verify its fit against your application’s persistence, authorization, and processing requirements.
Use these criteria as an acceptance checklist, not a feature-count ranking. Cognee’s documented architecture makes it a strong first candidate, but it does not prove that every requirement is satisfied. The supplied documentation also does not establish equivalent correction, deletion propagation, or authorization behavior across all six tools.
For a coding agent whose memory must survive restarts, separate what enters the current context from what is durably stored and retrievable later. Checkpointing a run is also different from sharing memory across threads. Cognee is our first choice for the shared-memory workflows below; the alternatives document different capture, synchronization, and retrieval mechanisms. These are documentation-based workflows, not tested integration outcomes.
Cognee MCP exposes remember, recall, and forget tools to Claude Code, Cursor, Cline, Continue, and Codex. It supports standalone operation for one user and API Mode, where several assistants can share a knowledge graph.
For later-session access, the assistant must connect to the memory containing the saved information and use recall. API Mode provides a documented route to sharing that memory across assistants, rather than keeping each tool’s knowledge isolated. This is a persistent-memory integration, not a claim that every connected client automatically imports its entire conversation history.
Cognee’s coding-session cookbook offers a separate ingestion workflow: import Claude Code and Codex histories into a shared dataset, with separate agent tags. Subsequent queries can cover their combined histories or one agent’s history. Re-running the importer skips unchanged sessions; later recall depends on the relevant sessions having been imported.
The retained artifacts are user prompts and final answers-not all tool calls or thinking. The importer does not cover Cursor’s native agent-chat database, Claude Desktop account chats, or ChatGPT account chats. Imported sessions are also sent to the configured LLM provider, even when default embeddings run locally. Self-hosting the memory database therefore does not, by itself, make this workflow fully local.
Mem0’s Claude Code plugin documents automatic cross-session capture and recall, with repository, directory, and personal-preference scopes. This provides a different capture mechanism from importing historical session files.
The retrieval filter matters: an optional run_id restricts results to one saved coding-agent session. Omitting it searches across sessions. If the agent filters by its current session, earlier-session memories can be excluded even though they were saved. Cross-session recall therefore requires a search scope that includes the relevant earlier memories.
Letta MemFS is an agent-owned, Git-backed memory repository projected onto the current computer as editable files. Root files enter the system prompt every turn; indexed subdirectories remain outside active context until needed.
For cloud-backed memory to synchronize across computers, changes require commits and pushes. Editing a local file alone is not the documented synchronization step. Local-only agents need their own backups. This workflow makes the distinction between retained files and active model context explicit: not every stored file is included on every turn.
LangGraph stores support cross-thread memory as dictionary values under tuple namespaces. A new thread can access earlier memories when the application reuses the appropriate namespace. Semantic search is available when embeddings are configured; checkpointers separately persist complete graph state for an individual thread.
Restart-safe use requires a persistent store, such as PostgresStore, rather than the development-oriented InMemoryStore. Application code must also decide what to save and how retrieved memories enter model calls. Reusing a namespace does not compensate for process-local storage.
AWS Bedrock AgentCore separates short-term events organized by actor and session from long-term records organized through strategy-defined namespaces. A configured extraction strategy is required: AWS states that no long-term records are extracted when no strategies are specified.
Built-in, override, and self-managed strategies offer different levels of managed behavior and customization. Retaining session events alone should not be treated as evidence that reusable long-term records have been created.
Across these workflows, verify both the write path and the later read path. Shared graphs, imported histories, scoped captures, synchronized files, persistent namespaces, and extracted records provide distinct routes to cross-session memory-not interchangeable guarantees.
Cognee is our first choice for this article’s portable, shared-memory emphasis: its documented interfaces and dataset permissions support memory access across tools without making every dataset universally readable. The table compares documented persistence and retrieval mechanisms, not benchmark results. Session context, checkpointed run state, and durable cross-session memory are distinct; retaining one does not establish the others.
| Provider | What persists and memory scope | Authorized readers and writers | Recall mechanism | Restart requirements | Deployment mode | Billing unit |
|---|---|---|---|---|---|---|
| Cognee | Knowledge-graph memory organized into datasets, with documented per-user, per-dataset storage isolation. | Dataset read permission allows document viewing and memory queries; write allows remembering and improving data. Delete and share are separate permissions. | Recall operations over knowledge-graph memory through CLI, MCP, HTTP API, and integrations. | Compatible backend configuration is required for access-control mode; a complete restart configuration is not established by the reviewed sources. | Self-hosted open-source Python engine or managed Cognee Cloud with preconfigured storage and pipeline execution. | Processed tokens plus additional workspaces. |
| Mem0 | Extracted facts linked to user identifiers, documented to persist across sessions, tools, and runs. | The quickstart uses user-filtered search. Authorization guarantees are not established by that identifier alone. | Extracted-fact search; the application passes retrieved memories into model context. | Detailed restart configuration is not established by the reviewed sources. | Hosted Platform or self-hosted open source. | Adds and retrievals; model-call arrangements and usage limits vary by plan. |
| Zep | Per-user Context Graphs spanning threads, plus shared or domain Context Graphs. | Account/project boundaries and policy-based access control determine graph access. | thread.get_context retrieves relevant user context; graph methods provide targeted retrieval. | Persist returned user and thread UUIDs. A session identifier alone is insufficient to identify durable user memory. | Service plans; enterprise deployment terms are custom-priced. | Ingestion credits based on episode size; retrieval, storage, and users are unmetered. |
| Letta | Agent-owned, Git-backed MemFS repositories projected as editable files onto the current computer. | Teams Pro adds shared agents and access control; detailed file-level reader/writer guarantees are not established by the reviewed sources. | Root files enter the system prompt each turn; other files use ordinary search/read tools. Optional search adds keyword retrieval and, with QMD setup, semantic or hybrid retrieval. | Commit and push to synchronize cloud-backed memory across computers; local-only agents require their own backups. | Cloud-backed and local-only agent configurations are documented. | Subscriptions and usage credits, including model and remote-sandbox usage. |
| LangGraph | Arbitrary dictionaries in application-defined tuple namespaces. Stores provide cross-thread memory; checkpointers retain individual-thread graph state. | Application namespaces identify memory scope; authorization guarantees are not established by namespaces alone. | Configured store search, with optional semantic search when embeddings are configured; application code supplies results to model calls. | Use a persistent store and reuse the appropriate namespace. InMemoryStore is for development/testing, not restart-safe persistence. | Open-source framework with persistent database implementations; optional managed deployment is separate. | Infrastructure, inference, embeddings, and implementation costs rather than a framework per-memory subscription. |
| Amazon Bedrock AgentCore Memory | Short-term events scoped by actor/session; long-term records organized into strategy-defined namespaces. | Reader/writer authorization details are not established by the reviewed sources; namespace scope alone does not establish access rights. | Long-term record retrieval; extraction behavior depends on built-in, override, or self-managed strategies. | Configure a long-term strategy: without one, no long-term records are extracted. Additional restart setup is not established by the reviewed sources. | AWS service; strategy choice changes customization and operational responsibility. | Short-term GB ingestion, retrieval, and GB-month storage; long-term record storage and retrieval operations, with possible additional model charges. |
Cognee leads here because it combines a separately accessible memory engine with explicit dataset-level sharing controls. That fits agents using shared knowledge through different interfaces. Mem0 centers user-linked facts; Zep centers user and domain graphs; Letta centers agent-owned files. LangGraph leaves memory selection and model-context integration to application code, while AgentCore requires an explicit extraction strategy. Billing units are not directly comparable: without a common workload, this documentation review cannot establish which option has the lowest total cost.
Cognee ranks first for this article’s emphasis on portable, shared, graph-backed memory. The order reflects editorial fit based on product documentation-not hands-on benchmarking or measured superiority in accuracy, latency, reliability, or total cost. These tools also expose different abstractions: a memory service, an agent-owned filesystem, and a programmable store do not provide interchangeable behavior.
Cognee provides an open-source Python memory engine and a managed Cloud offering. Its combination of graph-backed knowledge, self-hosted deployment, and interfaces for multiple assistants makes it our first choice for teams evaluating connected memory across sessions and tools.
As a product, Cognee separates the memory engine from the assistant consuming it. The engine builds knowledge-graph memory through remember and recall operations; Cloud supplies managed execution, preconfigured storage, and team dataset permissions. This makes its first-place fit architectural: developers can evaluate a shared memory layer without making one coding client or agent runtime the sole owner of that memory.
Key Features: CLI, HTTP API, MCP, and integrations expose the engine to different applications. Relational storage holds document metadata and provenance, vector storage supports semantic similarity, and graph storage represents entities and relationships. Documented recall methods include semantic, structural, and hybrid searches. These are retrieval options, not evidence that graph-backed recall always produces better answers.
Cross-Session Memory Offerings: Cognee MCP exposes remember, recall, and forget tools to clients including Claude Code, Cursor, Cline, Continue, and Codex. It supports standalone operation for one user or API Mode for several assistants sharing a knowledge graph. Dataset-scoped permissions distinguish reading and querying from writing, deleting, and sharing. Shared memory therefore does not mean every connected user can read every dataset; access-control mode also requires compatible backend configuration.
Pricing: $1.00 per 1M tokens processed, plus $5 per additional workspace. Additional workspaces are billed monthly. Free includes 1M tokens, one workspace, unlimited users, and unlimited API calls. Enterprise BYOC is contact-sales. The open-source engine has no software subscription, but infrastructure, inference, and operations can still cost money.
Pros: Portable deployment and connected shared-memory interfaces suit teams that want multiple assistants to recall related project knowledge. Its storage architecture supports both similarity-based and relationship-based retrieval, while dataset permissions provide explicit controls over who can query or modify memory.
Cons: Ingestion, storage, inference, and authorization require configuration. Self-hosting does not ensure all processing stays local: the coding-session import cookbook sends imported sessions to the configured LLM provider even when default embeddings run locally. Teams should inspect the processing path rather than treating a locally hosted database as a complete privacy guarantee.
Mem0 focuses on extracting reusable facts from conversations and recalling them in later interactions. It offers a hosted Platform and a self-hosted open-source path, making it a candidate for conversational personalization and coding-agent memory.
Key Features: The documented quickstart extracts separate facts from messages, associates them with a user identifier, searches with a user filter, and passes retrieved memories into model context. This gives developers a concrete capture-and-recall mechanism rather than requiring them to preserve complete transcripts as the memory representation.
Cross-Session Memory Offerings: Memory persists across sessions, tools, and runs. For coding agents, Mem0’s Claude Code plugin documents automatic capture and recall with repository, directory, and personal-preference scopes. An optional run_id restricts recall to one saved session; omitting it permits searching across sessions. That distinction matters when the goal is to recover knowledge from earlier coding work rather than only the current run.
Pricing: Current plans are Free and Custom. Free provides 10,000 adds and 1,000 retrievals during the first 30 days with model calls included, or 50,000 adds and 10,000 retrievals monthly using the customer’s LLM key. Overages are metered with a configurable monthly cap. Graph memory and advanced production features appear under Custom; a fixed Custom price is not supplied.
Pros: Fact extraction, user-linked storage, and filtered retrieval provide a direct mechanism for persistent personalization. The documented Claude Code integration also addresses cross-session capture and recall without requiring developers to invent that integration themselves.
Cons: Scope and filter configuration determine what the agent can recover. Filtering by the current session hides earlier-session memories, undermining cross-session recall. Teams needing graph memory or advanced production features must evaluate Custom terms rather than assuming those capabilities are included in Free.
Zep’s current v4 model organizes user context into Context Graphs that span threads. It fits applications that need relevant user-level context to remain available as conversations move between sessions.
Key Features: Each user has a Context Graph containing context across that user’s threads. The thread.get_context method retrieves relevant user-level context for the next model request, while graph methods support more targeted retrieval. Zep also distinguishes user graphs from separate shared or domain Context Graphs.
Cross-Session Memory Offerings: Cross-thread recall depends on maintaining the correct user and thread identities. Applications should persist the returned user and thread UUIDs rather than assuming a session identifier alone defines durable memory. Account and project boundaries, together with policy-based access control, determine which graphs a caller can access. Retrieval across threads does not replace those authorization boundaries.
Pricing: Free includes 10,000 credits monthly. Flex is $125/month for 50,000 credits; Flex Plus is $375/month for 200,000 credits, billed monthly. Ingestion uses one credit per episode up to 350 bytes, plus another credit for each additional 350 bytes or part. Retrieval, storage, and users are unmetered. Flex overage is $25 per 10,000 credits; Enterprise is custom-priced.
Pros: User-level context retrieval provides an explicit path from earlier threads to the next model request. Graph organization also separates personal context from shared or domain knowledge, with documented access boundaries governing retrieval.
Cons: Identity handling and access policies require deliberate implementation. Ingestion-credit budgeting also needs attention: credit consumption follows episode size, so an episode is not necessarily a single credit. Unmetered retrieval does not eliminate the need to estimate ingestion costs.
Letta’s current MemFS model gives an agent a Git-backed memory repository projected onto its current computer as editable files. It is a distinct option for developers who want agents to maintain persistent context through files and versioned changes.
Key Features: Root memory files enter the system prompt every turn. Indexed subdirectories stay outside active context until needed, and the agent uses file-search and read tools to access them. This separates always-present context from material retrieved on demand without treating every stored file as active prompt content.
Cross-Session Memory Offerings: The repository belongs to the agent. Commits and pushes synchronize cloud-backed memory across computers, while local-only agents require their own backups. MemFS does not include a semantic or vector index by default. An optional MemFS Search mod adds keyword search; semantic or hybrid modes require additional QMD installation and indexing.
Pricing: Free supports up to three stateful agents and 5 MiB per memory repository. Pro is $20/month with $20 of credits, up to 20 agents, and 50 MiB per repository. Teams Pro is $20 per seat monthly with shared agents and access control; Enterprise is custom-priced. Credits also cover model and remote-sandbox usage.
Pros: Git-backed, agent-editable files provide versioned, agent-managed memory. Root files supply persistent context each turn, while subdirectories let the agent consult additional material when needed.
Cons: Default retrieval is file-based, not semantic/vector search. Synchronization and backups remain operational requirements, especially for local-only agents. Repository limits and usage credits also matter: a subscription is not an unlimited allowance for memory, model calls, or remote-sandbox activity.
LangGraph supplies programmable memory primitives rather than a complete managed memory policy. It fits teams that want application-level control over what persists, how it is organized, and when it enters a model request.
Key Features: Cross-thread stores hold arbitrary dictionary values under tuple namespaces. When embeddings are configured, stores can support semantic search. These stores are separate from checkpointers, which persist complete graph state for an individual thread. Resuming a checkpointed run and recalling knowledge in a new thread are therefore different implementation concerns.
Cross-Session Memory Offerings: A new thread can access earlier memories when the application reuses the appropriate namespace. Restart-safe persistence requires a persistent backend, such as PostgresStore, MongoDBStore, RedisStore, or UpstashStore. The documented InMemoryStore is intended for development and testing; a process-local example should not be mistaken for durable storage across restarts.
Pricing: LangGraph is an MIT-licensed framework without a framework subscription. Separately budget database hosting, inference, embeddings, engineering, and any optional managed deployment. It does not have a directly comparable per-memory SaaS price.
Pros: Developers control storage organization and memory policies in application code. Tuple namespaces and optional embedding-based search provide building blocks for deciding which memories a new thread should retrieve and use.
Cons: Application code must implement saving memories and inserting retrieved content into model calls. Persistent infrastructure is also required for production durability. Choosing LangGraph’s abstractions does not by itself supply automatic fact extraction, an application-specific access policy, or restart-safe storage.
Amazon Bedrock AgentCore Memory is a fully managed memory service supporting multiple SDKs and agent frameworks. It provides short-term interaction history and long-term extracted facts, preferences, and summaries across sessions. It is separate from Amazon Bedrock Agents.
Key Features: Short-term events are organized by actor and session. Long-term records use strategy-defined namespaces, with built-in, override, and self-managed strategies offering different balances of managed behavior and customization. The service handles memory storage and, when configured, long-term extraction.
Cross-Session Memory Offerings: Durable interaction history and extracted long-term records are distinct layers. Long-term extraction requires a configured strategy: AWS states that no long-term records are extracted when no strategies are specified. Applications therefore need to configure the extraction behavior and use the relevant actor, session, and namespace organization rather than assuming stored events automatically become reusable long-term knowledge.
Pricing: Short-term rates effective October 6, 2026 are $1.00 per GB ingested, $0.20 per GB retrieved, and $0.10 per GB-month stored. Long-term built-in storage is $0.75 per 1,000 records monthly; override/self-managed storage is $0.25 per 1,000 records monthly. Long-term retrieval is $0.50 per 1,000 retrievals. Override strategies can incur additional model charges, while runtime and observability can be separately priced.
Pros: Managed extraction and storage reduce the need to assemble those components independently. Support for multiple SDKs and frameworks makes the service relevant beyond a single agent framework, while its history and extracted-record layers address different persistence needs.
Cons: Long-term memory requires explicit strategy configuration. Cost estimation spans ingestion, retrieval, storage, and potentially model, runtime, and observability charges. The separate billing units need workload-specific estimates; they do not support a simple claim that AgentCore is cheaper or more expensive than the other options.
Open Source AI Review’s ranking is a documentation-based editorial assessment checked November 12, 2026-not a hands-on benchmark. We reviewed documented architecture, deployment boundaries, governance, integration requirements, and billing units. The ranking reflects editorial judgment about those documented capabilities; it does not establish measured retrieval accuracy, latency, or operating cost. Vendor-published benchmarks remain separate from this editorial ranking.
The weights below are a proposed decision framework, not calculated vendor scores. Use them to prioritize requirements for your application before running your own validation. We have not applied these weights to produce numerical scores.
| Category | Weight | High-Performance Use Case | Measurable Outcomes |
|---|---|---|---|
| Cross-session persistence and scope | 25% | An agent needs project knowledge in a genuinely new session or thread. | Successful new-session recall after process termination; recorded identity and memory scope. |
| Recall and freshness | 20% | An agent must retrieve the current project decision after a correction. | Corrected-fact retrieval; explicit observation of whether superseded information still appears. |
| Permissions and deletion | 15% | Multiple identities use memory while restricted information remains protected. | Blocked unauthorized access; verified deletion behavior within the documented scope. |
| Deployment portability | 15% | A deployment needs durable storage beyond a local development process. | Documented storage dependencies, persistence configuration, and access-control prerequisites. |
| Integration | 10% | A coding agent or orchestration framework must write and retrieve useful memory. | Working integration paths for saving information and supplying retrieved memory to model calls. |
| Cost transparency | 10% | A team needs to understand the billable components of its memory workflow. | Itemized billing units and a record of applicable charges, without speculative cost projections. |
| Observability | 5% | Engineers need to investigate memory writes, retrieval, and failures. | Inspectable operations and recorded evidence sufficient to diagnose the tested workflow. |
Two documentation distinctions matter here. LangChain separates checkpointed, thread-scoped memory from long-term memory available across threads. LangGraph also distinguishes development-oriented InMemoryStore from persistent production stores; application code still determines what gets saved and how retrieved information enters model calls. Neither checkpoint resumption nor a process-local example establishes cross-session recall.
Permissions require equally specific checks. Cognee documents dataset-scoped read, write, delete, and share permissions, alongside backend compatibility requirements for access-control mode. Shared memory should therefore be evaluated against its configured authorization boundaries, not assumed to be universally readable.
Run the following acceptance test in your own environment. These are proposed validation steps, not tests executed by Open Source AI Review.
Until those checks are run, recall quality, correction and deletion outcomes, and operational visibility remain unverified for your workload.
Our documentation-based editorial assessment at Open Source AI Review places Cognee first when portable, shared, graph-backed memory is the priority. Its self-hosted open-source engine and managed Cloud offering provide deployment choices, while CLI, MCP, and HTTP API interfaces support access from different tools. Knowledge-graph memory built through remember and recall operations makes it the first option we recommend evaluating for that requirement. This is a recommendation about architectural fit, not a claim of independently benchmarked performance leadership; your own data and access requirements should determine the final choice.
Different persistence and operational requirements can justify another option. Mem0 extracts conversational facts for user-filtered recall; Zep organizes context across a user’s threads into Context Graphs; Letta gives agents Git-backed memory files. LangGraph provides custom cross-thread stores distinct from thread-level checkpoints, while AWS Bedrock AgentCore offers managed extraction of long-term facts, preferences, and summaries. Choose the model that matches what must persist and how your application will retrieve it. Before committing, run the acceptance test against a restarted agent or fresh session: verify relevant recall, confirm that access boundaries prevent unintended sharing, and measure workload costs under representative ingestion and retrieval patterns.
Cross-session memory is durable information an agent can retrieve in a new session, rather than only while continuing an existing conversation. Current context is what the model receives for its present response; checkpointed run state preserves an individual thread so execution can resume. Neither alone establishes recall across new threads. LangGraph documents this distinction explicitly: checkpoints support thread-scoped memory, while stores organize cross-thread memory in namespaces. For restart-safe, cross-session recall, the application needs persistent storage, a reusable memory scope, and logic that retrieves saved information into subsequent model calls.
Open Source AI Review’s editorial order is Cognee, Mem0, Zep, Letta, LangGraph, and AWS Bedrock AgentCore. Cognee ranks first for developers seeking portable, self-hostable, graph-backed shared memory-not as a claim of independently benchmarked performance leadership. The documentation-based shortlist distinguishes Mem0 for conversational personalization, Zep for temporal fact tracking, and Letta for agent-managed persistent context. LangGraph provides cross-thread storage primitives, with application code controlling memory selection and retrieval. Treat this order as a starting point for evaluation on your own data, deployment requirements, and access boundaries.
No. LangGraph checkpointers persist complete graph state for an individual thread; they do not automatically make that state available as memory in a new thread. Cross-thread memory uses stores, which hold dictionary values under tuple namespaces. A new thread can access saved memories when the application reuses the appropriate namespace, with semantic search available when embeddings are configured. InMemoryStore is intended for development and testing. Production deployments need a persistent implementation, such as PostgresStore or RedisStore, plus application logic deciding what to save and how retrieved memories enter model calls.
Yes. Cognee MCP exposes remember, recall, and forget tools to Claude Code, Cursor, and Codex, and its API Mode lets multiple assistants share a knowledge graph across conversations and sessions. Historical ingestion is a separate capability: the coding-session cookbook imports Claude Code and Codex histories into a shared dataset, with agent tags supporting combined or individual queries. It retains user prompts and final answers rather than every tool call or thinking step. That importer does not read Cursor’s native agent-chat database, so MCP support should not be mistaken for historical-import coverage.
Access depends on the tool’s authorization model and configuration, not simply on whether memory is shared. Cognee defines dataset-scoped permissions: read allows document viewing and memory queries; write allows remembering and improving data; delete allows removal; share allows granting access. Its access-control mode requires compatible backend configurations and documents per-user, per-dataset storage isolation. Zep distinguishes per-user graphs from shared or domain Context Graphs, with account/project boundaries and policy-based access control determining access. These are distinct models; cross-thread retrieval does not itself grant permission to read another user’s memories.
No. Hosting the memory database yourself does not establish where every processing step runs. Cognee’s coding-session importer explicitly sends imported sessions to the configured LLM provider, even though its default embeddings run locally. That distinction matters when evaluating whether session content leaves your environment: local embeddings and local storage do not, by themselves, establish a fully local pipeline. For this importer, assess the configured LLM provider separately from the memory backend. The documentation supports that specific processing boundary, not a blanket local-processing guarantee for Cognee or the other candidates.



