Self-Hosted vs VPC vs Managed AI Memory: A Deployment Guide
< BlogGuides
October 15, 2026
Updated October 21, 2026
26 minutes read

Self-Hosted vs VPC vs Managed AI Memory: A Deployment Guide

Cognee Editorial Team
Cognee Editorial TeamCognee team

Most buyer conversations about self-hosted AI memory start with a residency question: can the platform run inside our own VPC, and if so, what exactly leaves the network? The honest answer depends on which of four deployment models is on the table, a fully managed cloud service, a single-tenant VPC or bring-your-own-cloud (BYOC) install, a customer-managed self-host, or a hardened air-gapped deployment. Each model changes where vectors and graphs are stored, which outbound calls to embedding and LLM providers are still required, who carries the operational burden, how cost scales with usage, and which compliance regimes it satisfies.

This guide walks through those four models as a decision framework rather than a ranked product list. It defines each model, outlines the trade-offs on data residency, outbound dependencies, operations, cost, and compliance posture, and gives selection criteria for a self-hostable memory layer. It then compares Cognee against Mem0, Zep, Letta, Graphiti, and Supermemory on VPC and self-host readiness, documents the deployment patterns regulated enterprises use inside their VPC, and closes with operational guidance and FAQs. Cognee is used as a reference point because the same engine runs across all four models, so the model choice can be made on architecture rather than vendor lock-in.

The intended reader is a technical buyer, platform engineer, or security architect evaluating a memory layer for AI agents that handle regulated or sensitive data, healthcare records, financial transactions, legal matters, internal knowledge, or anything else that cannot leave a controlled perimeter. If the shortlist already includes requirements like SOC 2 alignment, VPC-only deployment, on-premise operation, or an air-gap option, the framework here is meant to make the trade-offs explicit before a procurement decision is locked in.

What is self-hosted, VPC/BYOC, and managed AI memory?

Before comparing tradeoffs, the four deployment models for an AI memory layer need precise definitions. The labels get used loosely across vendor marketing, which makes it hard to tell whether a product actually keeps regulated data inside your perimeter or merely offers a dedicated database inside someone else's cloud.

Managed cloud

In a managed cloud deployment, the vendor operates both the control plane and the data plane inside its own cloud account. Agent memory, embeddings, graph structures, and the source documents being ingested all transit to the vendor's infrastructure. The customer interacts through an API or SDK and holds no infrastructure responsibility. Every vendor in the comparison below offers this form; it is the default for prototypes and non-regulated internal tooling.

Single-tenant VPC / BYOC

Bring-your-own-cloud for an AI memory layer means the data plane runs inside the customer's own cloud account, the vendor control plane (if any) stays external, and no agent memory, embeddings, or source documents leave the account boundary. Compute, storage, vector indexes, and graph databases are provisioned inside the customer's AWS, GCP, or Azure account. The vendor can push updates and read operational telemetry, typically over a private interconnect such as AWS PrivateLink rather than the public internet, but regulated payloads never cross the account edge.

Customer-managed self-hosting

Self-hosting removes the vendor from the runtime path entirely. The customer pulls the software, deploys it on infrastructure it already operates, and takes on upgrades, scaling, and monitoring. Apache-2.0 engines such as Cognee, Mem0, and Letta install this way, via pip install and container-based deployment through docker compose up or Kubernetes. The useful distinguishing factor is backend flexibility: whether the memory layer can be wired into existing Postgres/pgvector, Neo4j, Kuzu, LanceDB, Qdrant, or Redis instances rather than demanding a dedicated stack.

Air-gapped deployment

Air-gapped deployment extends self-hosting to environments with no outbound internet access. Embeddings and inference must run locally, commonly through a local model runtime such as Ollama, because calls to hosted embedding and LLM providers are not permitted. The test of a genuinely air-gap-capable memory layer is whether the same engine, with identical memory logic, graph construction, and retrieval behavior, runs with every outbound call removed, or whether the air-gapped build is a reduced fork.

Why does the deployment model matter for AI memory?

Agent workloads have moved past prototype demos into pipelines that read patient records, trade data, student records, and internal bank documentation. Once memory stores that content, the deployment model stops being an infrastructure preference and becomes a regulatory decision. Banks, pharmaceutical companies, and universities running memory layers in production increasingly operate under residency or air-gap constraints that rule out a shared SaaS data plane entirely.

Residency and sovereignty pressure

GDPR obligations around lawful transfer, data minimization, and the right to erasure determine where embeddings, graph nodes, and raw source documents can be stored and processed. For EU controllers, a managed US endpoint is often a non-starter regardless of its feature set. Sector-specific obligations that go beyond GDPR are satisfied by self-hosting inside the controller's own environment, which keeps the lawful basis and processing records under the controller's direct ownership rather than a vendor's attestation.

Agent workloads touching regulated data

HIPAA imposes a sharper constraint. Protected health information cannot flow to any processor without a Business Associate Agreement, and most memory layers were not designed with PHI boundaries in mind. For HIPAA-aligned deployments the memory layer has to be self-hostable, air-gappable, or VPC-deployable with BYOC, work with local LLMs through Ollama or an in-tenant Azure OpenAI endpoint under a BAA, and support dataset-scoped permissions plus a forget operation for erasure requests. The practical effect is that PHI, embeddings derived from PHI, and the graph structure built on top of it never leave the covered entity's network perimeter.

Operational resilience obligations

DORA has changed procurement for EU financial entities. Firms must maintain continuity of critical ICT services and audit third-party providers at a depth that a standard SaaS contract rarely supports. A memory layer that sits in the agent's critical path inherits those requirements, which pushes buyers toward deployment models where the data plane runs inside the firm's own environment and the vendor's role is reduced to shipping and supporting the engine. That is the pattern behind most bank and large-enterprise memory deployments: the controller owns the runtime, the storage, and the audit trail, while the vendor provides the software and the operational guidance to run it.

What goes wrong when deploying AI memory inside a VPC?

Moving an AI memory layer into a private VPC rarely fails on a single technical issue. The friction comes from a handful of recurring obstacles that each require a deliberate answer before the deployment is production-ready. Four of them show up on almost every regulated project.

Outbound dependencies for embeddings and inference

A memory layer is only as private as the services it calls. If every write triggers an embedding request to a hosted provider, and every retrieval augments a prompt sent to a hosted LLM, then the VPC boundary is largely cosmetic, sensitive text is still crossing the public internet. The fix is a memory layer that works with any LLM provider, including local models served through Ollama or vLLM, so a fully air-gapped deployment with no outbound inference traffic is possible without code forks.

Operational burden of running the stack

Many memory architectures stitch together a graph database, a vector database, and a service layer, each with its own upgrade cycle, backup strategy, and failure modes. Running that combination inside a VPC multiplies the on-call surface area. A single engine with pluggable backends, able to target Postgres with pgvector, a dedicated graph store, or an object store without introducing additional services to operate, keeps that surface small. A documented telemetry switch is also required: air-gapped and public-sector installations will ask for the exact environment variable that stops outbound diagnostics.

Multi-tenant isolation inside a single account

A single VPC often has to serve several business lines, each with its own data boundary and auditor. Account-level separation is too coarse, and per-tenant clusters are expensive to run. A representative BYOC pattern for a European bank runs the memory engine inside the bank's AWS or Azure VPC against a Postgres cluster with pgvector, with workspace-level separation per business line and provenance enabled on every retrieval. The same engine serves retail, markets, and compliance workloads without co-mingling their memory.

Audit, provenance, and erasure

Regulated workloads require that any stored fact can be traced back to its source document and removed on request. A machine-readable per-subject export answers data-portability requests, dataset-level separation keeps subjects partitioned, and a forget operation handles erasure. Combined with per-retrieval provenance, this gives auditors a direct answer to where a model's recall came from and how to revoke it.

What should a self-hosted AI memory platform provide?

When the deployment target is a customer-controlled VPC, the evaluation criteria differ sharply from managed SaaS. Licensing, backend flexibility, inference independence, and erasure primitives all become selection gates rather than nice-to-haves. The checklist below reflects the requirements that recur in regulated procurement cycles, healthcare, financial services, and public-sector buyers moving AI memory inside their own perimeter.

Must-have features

  • Permissive open-source license (Apache-2.0): A permissive license removes legal friction around embedding, modifying, and redistributing the memory engine inside internal products. Copyleft or source-available licenses often fail enterprise OSS review.
  • Pluggable backends (vector + graph + relational): The memory layer should connect to databases already approved by platform and security review, not force a new managed service. Look for native support across Postgres/pgvector, Neo4j, Kuzu, LanceDB, Qdrant, and Redis so the storage decision stays with the customer.
  • Works with any LLM provider, including local models: Embedding and generation calls are the most common source of outbound traffic. A self-hostable platform must accept OpenAI, Anthropic, Bedrock, Azure OpenAI, and on-prem inference via Ollama or vLLM without code forks.
  • Air-gap support with telemetry disable: Public-sector and defense installations require a documented switch for outbound telemetry. A single environment variable (for example TELEMETRY_DISABLED=1) is the baseline.
  • BYOC path with SSO, SLAs, and dedicated support: Open-source alone is insufficient for most enterprise buyers. A commercial tier that deploys inside the customer VPC from day one, with SSO, SLAs, and a named support engineer, bridges the production gap.
  • EU-region and sovereign cloud coverage: Data residency obligations under GDPR and sector-specific regulation require deployment in named EU regions across AWS, GCP, Azure, and sovereign providers such as Hetzner, OVHcloud, and Scaleway.
  • Workspace isolation, provenance, and erasure primitives: Dataset-level separation, per-subject export, and a documented forget operation are prerequisites for GDPR Article 17 and 20 compliance.

A platform that meets all seven can be evaluated on architecture and retrieval quality. A platform that misses one of the first four usually cannot be deployed in a regulated VPC at all, regardless of how it scores elsewhere.

Self-hosted vs managed: Cognee, Mem0, Zep, Letta, Graphiti, and Supermemory compared

The deployment picture across the memory landscape is uneven. Most memory frameworks offer some form of self-hosted option, but few hold SOC 2 on an enterprise tier; among the platforms compared here, Mem0 and Zep do. The table below captures where each platform stands on license, self-host status, VPC/BYOC path, air-gap support, and SOC 2 at the enterprise tier.

Comparison table

PlatformLicenseSelf-host statusVPC/BYOC pathAir-gap supportSOC 2 (enterprise)
CogneeApache-2.0Docker Compose or Kubernetes, pip install cogneeSupported (BYOC in customer VPC)Supported (fully air-gapped)In progress; no Type I or Type II report yet
Mem0OSS core + managed PlatformOSS self-deploy with Qdrant or pgvectorOn-premise gated to Enterprise tierNot documented in OSSYes (Enterprise)
ZepEnterprise (Graphiti engine OSS)Community Edition retired April 2025; Graphiti + graph DB + custom service layerEnterprise contract required for in-environment deploymentEnterprise contract requiredYes (Enterprise)
LettaApache-2.0App Server with Dockerfile for Docker Compose, Railway, Fly.io; prior self-hosted Docker image no longer actively maintainedPossible via App Server; no managed BYOC program documentedNot documentedNot documented
GraphitiApache-2.0 (engine only)Self-hostable engine; requires Neo4j, FalkorDB, or Kuzu plus a service layer built by the adopterDIY within customer infrastructureDIY within customer infrastructureNot applicable (engine, not a product tier)
SupermemoryProprietary (not open source)No OSS self-host; air-gapped deployment documented on vendor homepageVendor-managed air-gap/enterprise deploymentDocumented (vendor-managed)Not documented; HIPAA BAA on Scale/Enterprise cloud

Row-by-row notes

Cognee. Apache-licensed and installable via pip install cognee, with Docker Compose (docker compose up) or Kubernetes for container deployments. Pluggable backends include Postgres/pgvector, Neo4j, Kuzu, LanceDB, Qdrant, and Redis, so the same engine runs across managed cloud, BYOC inside a customer VPC, customer-managed self-hosting, and fully air-gapped environments.

Mem0. The OSS build pairs with a vector store, typically Qdrant or pgvector, and can be self-deployed by the adopter. The managed alternative at app.mem0.ai covers general use; SSO, on-premise deployment, and audit logs are gated behind the Enterprise tier, which also carries SOC 2.

Zep. The self-hosted Community Edition was retired in April 2025. The Graphiti engine beneath Zep is still Apache-licensed and self-hostable, but running it as a product means standing up Graphiti plus a compatible graph database (Neo4j, FalkorDB, or Kuzu) plus a custom service layer, a different operational commitment than a single docker run. In-environment deployment of the full Zep product requires an Enterprise contract.

Letta. Apache-2.0 with a self-hostable App Server that ships a Dockerfile and configurations for Docker Compose, Railway, and Fly.io, running agent state, memory, and tool execution on the deployed machine. The previously published self-hosted Docker image is no longer actively maintained; current guidance in the letta-ai/letta repository points to local mode in the Letta app or CLI, or to the App Server for custom applications.

Graphiti. Open-source engine rather than a packaged product. Running it inside a VPC requires selecting and operating a graph database (Neo4j, FalkorDB, or Kuzu) and building the service layer around it.

Supermemory. Not open source. Air-gapped deployment is documented on the vendor homepage, and HIPAA BAA is offered on Scale and Enterprise cloud plans, but there is no community self-host path.

For deeper per-vendor comparisons see the guides to Mem0 alternatives, Zep alternatives, and Letta alternatives.

How do you run self-hosted or VPC AI memory in production?

Operational guidance

The following practices come from regulated deployments across banking, healthcare, and public-sector environments. They apply whether the engine is running in a managed cloud, a customer VPC, or a fully air-gapped enclave.

  • Disable telemetry for air-gapped installs. Set the documented telemetry switch (TELEMETRY_DISABLED=1 in the open-source package) before the first boot. This is a standard precondition for public-sector and air-gapped installations where no outbound diagnostic traffic is permitted.
  • Pair the memory engine with Postgres and pgvector for regulated workloads. When a bank or insurer has already standardized on Postgres, running the engine against a Postgres cluster with pgvector keeps the memory store inside the same backup, encryption, and audit perimeter as the rest of the data estate. A representative BYOC pattern for a European bank follows exactly this layout inside its AWS or Azure VPC.
  • Separate workspaces per business line or tenant. Dataset-scoped permissions let a single deployment host retail banking, wealth, and treasury on the same engine without cross-reads. The same model works for multi-tenant SaaS, where each customer receives a dedicated workspace; see the guide to multi-tenant AI memory data isolation.
  • Enable provenance on every retrieval. Every answer should carry back the source nodes, edges, and documents it was built from. Provenance-on-by-default is what makes a memory layer defensible under audit and what allows a reviewer to reconstruct why the agent said what it said.
  • Route inference through Ollama or in-tenant Azure OpenAI when outbound calls are prohibited. For HIPAA-aligned and air-gapped builds, local models served through Ollama remove outbound inference traffic entirely, while in-tenant Azure OpenAI under a BAA covers healthcare deployments that still want hosted frontier models.
  • Plan erasure before it is requested. GDPR Article 17 and HIPAA right-to-amend requests will arrive. Combine a targeted forget operation with a per-subject export for data-portability requests, so a subject's full memory record can be produced as a machine-readable archive and then removed across datasets.

Treating these as deployment-time defaults, rather than retrofits, is what keeps a VPC or air-gapped install audit-ready from day one.

What do you gain from self-hosted or BYOC AI memory?

When the data plane runs inside the controller's own infrastructure, the deployment inherits properties that a shared SaaS backend cannot replicate. The measurable benefits below are what make self-host and VPC paths attractive for regulated workloads, latency-sensitive agents, and finance teams that need predictable spend.

Measurable benefits

  • Benefit 1, Data residency inside the controller account. Under a BYOC model for an AI memory layer, the data plane runs inside the customer's own cloud account while the vendor control plane (if any) stays external. Residency is therefore a property of the account itself, not a vendor promise.
  • Benefit 2, Reduced outbound dependency area under BYOC. No agent memory, embeddings, or source documents cross the account boundary. Outbound calls can be constrained to the embedding and LLM endpoints the controller selects, and those too can be swapped for in-VPC inference when required.
  • Benefit 3, Internal-network latency when co-located with agents. When the memory layer runs in the same network as the agents, retrieval stops paying for a public round trip on every call. An embedded, in-process path goes further and removes the hop entirely; Cognee's Rust engine, for example, recalls in 0.24s against 1.77s for the Python SDK on its enterprise reference workload.
  • Benefit 4, Compliance inherited from the controller's own environment. A vendor's SOC 2 report, as defined by the AICPA's SOC suite, attests to controls in the vendor's environment, not yours. Self-hosting inside the controller's own certified environment means the controlling account's SOC 2, HIPAA, FedRAMP, or ISO scope extends to the memory layer, which is the only route to sector-specific compliance for vendors that do not yet hold those reports themselves.
  • Benefit 5, Predictable cost via OSS plus a managed option. An open-source engine is free to run on existing infrastructure, and a managed tier priced per token processed scales with what agents actually ingest and query rather than seat count or node hours, which simplifies forecasting as traffic grows.

How Cognee delivers a self-host, VPC, and air-gap path from one engine

Most memory platforms force a decision between an open-source project with limited support and a managed service that pulls data outside the controller's environment. Cognee collapses that choice by running the same engine across four deployment models, so a project can start on a laptop and graduate to a regulated VPC install without rewriting pipelines or re-indexing the knowledge graph. Cognee's pipeline volume has grown past one million runs per month across customers that include Bayer, the University of Wyoming, Dynamo, Knowunity, and a tier-1 US bank, several of which operate under residency or air-gap constraints.

One engine across four models

The same Cognee engine ships as pip install cognee for local development, as a Docker Compose or Kubernetes install for internal platform groups, as an air-gapped deployment paired with Ollama for environments with no outbound internet, as Enterprise BYOC inside a customer VPC, and as Cognee Cloud for hosted workloads. Cognee Cloud runs on gpt-oss-120b, OpenAI's open-weight model, while every self-hosted path lets a deployment bring its own embedding and LLM provider, local, private, or commercial.

Because the ingestion, graph construction, and recall logic are identical across models, an evaluation that starts with the OSS package produces the same memory behavior once promoted to BYOC or air-gap. There is no separate "enterprise fork" to re-learn.

How Cognee meets the self-host checklist

Cognee is Apache-2.0 and installs via pip install cognee, with pluggable backends spanning Postgres/pgvector, Neo4j, Kuzu, LanceDB, Qdrant, and Redis, storage stays on infrastructure the customer already operates. Any LLM provider is supported, including local models through Ollama, which enables fully air-gapped recall with no outbound inference traffic. Telemetry is disabled with TELEMETRY_DISABLED=1. The open-source distribution runs in any EU region, AWS Frankfurt or Ireland, GCP europe-west, Azure German or French regions, Hetzner, OVHcloud, Scaleway, and the enterprise product page documents SSO, VPC deployment, and in-process recall with no network hop per call on the embedded path. For erasure and portability, a COGX export produces a machine-readable archive of a subject's records to satisfy data-portability requests, with dataset-level separation and a forget operation available for Article 17 obligations.

Enterprise BYOC specifics

The Enterprise tier is a fixed-scope BYOC engagement deployed inside the customer's VPC from day one. It includes a proprietary runtime, a domain ontology built against the customer's data model, evaluation harnesses run on customer data rather than public benchmarks, SSO, SLAs, and a dedicated support engineer. The enterprise product configuration supports in-process recall with no network hop per call for the embedded path, which keeps retrieval latency inside the VPC boundary. Pricing for the hosted tiers is on the pricing page: a free tier with 1M tokens and one workspace, Standard at $1.00 per 1M tokens processed plus $5 per additional workspace, and Enterprise BYOC on custom terms.

On certifications, Cognee is direct about scope. The company is Berlin-based with GDPR-aligned processes audited with heyData, and data is encrypted at rest and in transit. SOC 2 certification is in progress, with no Type I or Type II report yet, and Cognee does not claim HIPAA or ISO certification on the controller's behalf; sector-specific obligations are satisfied by self-hosting Cognee inside the controller's own environment, where the existing audited controls apply. For a regulated buyer, this is the point: the memory layer inherits the compliance posture of the infrastructure it runs in, rather than requiring a separate trust transfer to a vendor cloud.

Representative regulated deployment patterns

The deployments below are drawn from Cognee's documented customer patterns and enterprise engagements, and each one pairs a concrete constraint (data residency, air-gap, HIPAA, sovereign operation) with the Cognee feature or product that makes it workable inside a customer-controlled VPC.

  • European bank BYOC, Postgres/pgvector inside AWS or Azure VPC. Cognee runs inside the bank's own AWS or Azure VPC against a Postgres cluster with pgvector, with workspace-level separation per business line and provenance enabled on every retrieval. Retail, markets, and compliance each get their own workspace, and every answer carries the lineage needed for audit review.
  • EU-region self-host, open-source package on sovereign infrastructure. The open-source self-host runs in any EU region, including AWS Frankfurt or Ireland, GCP europe-west regions, Azure German or French regions, Hetzner, OVHcloud, and Scaleway. The same binary covers hyperscaler VPCs and European sovereign clouds, which simplifies residency commitments made to regulators or customers.
  • Air-gapped, Ollama for local inference, telemetry disabled. Cognee works with any LLM provider, including local models through Ollama, so an installation can run with no outbound inference traffic at all. With TELEMETRY_DISABLED=1 set, the memory layer performs ingestion, graph construction, and recall without crossing the network boundary.
  • HIPAA-aligned healthcare, BYOC with BAA-covered inference. Cognee is self-hostable, air-gappable, and VPC-deployable with BYOC, and is compatible with local LLMs via Ollama or in-tenant Azure OpenAI under a BAA. Dataset-scoped permissions keep PHI partitioned by cohort or care team, and a forget operation handles patient erasure requests without a full re-index.
  • Sovereign operation, embedded path with no network hop per call. The enterprise product provides production-grade AI memory with SSO and deployment inside the customer VPC, and the embedded path performs in-process recall with no network hop per call. For latency-sensitive agents and for operators who need to prove that recall traffic never leaves the host, the embedded path removes the network entirely from the hot loop.

Next steps

The four-model framework in this guide reduces to a question of where data physically resides and how much operational control is required. Managed cloud works when the data is non-regulated and speed of iteration outweighs tenancy concerns. Single-tenant VPC (BYOC) is the fit when sensitive data cannot leave the customer network but a vendor runtime is acceptable. Customer-managed self-hosting applies when internal platform engineering already owns similar infrastructure and prefers full control of upgrades, backups, and observability. Air-gapped deployment is required when outbound calls to embedding and LLM providers are prohibited and local models must handle every inference.

Choosing your model

Map the decision to three axes: data residency, outbound network posture, and operations capacity. If outbound calls to hosted embedding and LLM providers are blocked, the air-gapped path with local models is the only viable option. If data must stay inside a known network boundary but outbound inference calls are permitted, BYOC inside the customer VPC covers most regulated workloads. If the workload is internal tooling on non-sensitive data, managed cloud removes the operations burden entirely. Cognee runs the same engine across all four models, so the decision does not lock the project into a different platform later.

How to get started

A practical evaluation path moves in three stages. Begin with the open-source engine: pip install cognee or docker compose up against a local Postgres/pgvector or Neo4j backend to validate ingestion, graph construction, and retrieval quality on a representative dataset. The Apache-licensed distribution supports pluggable backends including Postgres/pgvector, Neo4j, Kuzu, LanceDB, Qdrant, and Redis, so the evaluation stack can match the production stack.

Second, run a BYOC pilot inside a non-production VPC. Deploy via Docker Compose or Kubernetes, wire up the chosen vector and graph stores, and test the full ingestion and retrieval loop against realistic data volumes and access controls.

Third, engage the Enterprise tier when SSO, SLAs, a dedicated support engineer, domain ontology work, and evaluations on customer data are required. The Enterprise engagement is fixed-scope BYOC with a proprietary runtime deployed inside the customer VPC from day one.

To start an evaluation, install the OSS engine from PyPI or GitHub. To scope a BYOC or air-gapped deployment, contact the Cognee team for an Enterprise engagement.

FAQ

What is the difference between self-hosted, VPC/BYOC, and managed AI memory?

Self-hosted means the engine runs on infrastructure the customer operates end to end, with no vendor control plane involved. VPC/BYOC means the data plane runs inside the customer's own cloud account while a vendor control plane remains external, and no agent memory, embeddings, or source documents cross the account boundary. Managed means the vendor operates both planes in its own cloud. Cognee supports all three models from one engine, including Docker or Kubernetes self-hosting, BYOC into a customer VPC, and Cognee Cloud.

Can I run an AI memory layer entirely inside my own infrastructure with no outbound calls?

Yes. Cognee can be self-hosted with docker compose up or Kubernetes, deployed fully air-gapped, and pointed at any LLM provider including local models through Ollama, which removes outbound inference traffic. Telemetry in the open-source package is disabled by setting TELEMETRY_DISABLED=1, a configuration used in air-gapped and public-sector installations. Combined with a local embedding model and a self-hosted vector or graph store, the full memory pipeline, ingestion, extraction, retrieval, runs without any network egress from the controller's environment.

Which AI memory platforms support bring-your-own-cloud deployment inside a customer VPC?

Support varies. Cognee's Enterprise tier is a fixed-scope BYOC engagement deployed inside the customer's VPC from day one, including a proprietary runtime, domain ontology, evals on customer data, SSO, SLAs, and a dedicated support engineer. Mem0 gates on-premise deployment, SSO, and audit logs behind its Enterprise tier. Zep retired its self-hosted Community Edition in April 2025, so running the full product inside a customer environment now requires an Enterprise contract. Letta is Apache-2.0 with a self-hostable App Server but no longer actively maintains its self-hosted Docker image.

Does Cognee hold SOC 2, HIPAA, or ISO certification?

Cognee is a Berlin-based company with GDPR-aligned processes audited with heyData. Data is encrypted at rest and in transit. SOC 2 certification is in progress; Cognee does not yet hold a Type I or Type II report, and does not claim HIPAA or ISO certification. Sector-specific obligations such as HIPAA or financial-services controls are satisfied by self-hosting the engine inside the data controller's own environment, where the controller's existing certifications govern the deployment. Among the platforms compared here, Mem0 and Zep hold SOC 2 on an enterprise tier, while most offer some self-hosted option, making deployment model, not certification, the decisive compliance lever.

What does Cognee Cloud cost compared to running the open-source engine myself?

Cognee Cloud has a free tier with 1M tokens and one workspace. Paid usage is $1.00 per 1M tokens processed, plus $5 per additional workspace. The Enterprise tier adds SSO, SLAs, a dedicated support engineer, and BYOC deployment into a customer VPC under a fixed-scope engagement. Running the open-source engine on self-managed infrastructure removes the per-token Cognee fee entirely; the remaining cost is compute, storage, the chosen vector or graph backend, and any outbound embedding or LLM provider charges, which also drop to zero when local models through Ollama are used.

How do Mem0, Zep, Letta, and Cognee compare on self-hosting and VPC deployment?

Mem0 open-source can be self-deployed with a vector store such as Qdrant or pgvector, with on-premise deployment gated behind Enterprise. Zep retired its self-hosted Community Edition in April 2025; the underlying Graphiti engine is still open source, but the full Zep product needs an Enterprise contract for customer-environment deployment. Letta is Apache-2.0 with a self-hostable App Server, though its Docker image is no longer actively maintained and users are pointed to local mode or the App Server for custom applications. Cognee ships one engine across self-host, air-gap, BYOC, and managed cloud.

Related reading

Self-Hosted AI Memory Layer: Running Agent Memory on Docker and Kubernetes
Best Managed AI Memory Platforms for LLM Apps in 2026 (Compared)
Deploying AI Memory in Your Own VPC: Bring-Your-Own-Cloud Options for Agent Memory
Get started

Cognee is the fastest way to start building reliable Al agent memory.

Cognee Cloud
Latest
Claude Code vs Codex vs Cursor: What Coding Agents Really Cost in 2026
Coding Agent Memory with cognee: Hooks, Capture, and Recall
Dataset Routing in cognee: How recall() Picks Which Datasets to Search