Comparison
How HUPI compares to other AI memory approaches.
An honest comparison, not a strawman — each of these is a real, useful tool for different jobs. Here's specifically where HUPI's architecture differs.
| HUPI | Vendor-native memory (ChatGPT, Claude, Gemini) | Mem0 | Zep / Graphiti | Letta (MemGPT) | |
|---|---|---|---|---|---|
| How you use it | Drop-in HTTP gateway — point your existing OpenAI-compatible client at it, zero code changes | Built into one vendor’s own chat app/API | SDK you call from your own app code (add/search calls) | SDK/API against a hosted context-graph service | Full agent runtime — your agents live and execute inside it |
| Lives inside your editor | Yes, two ways — a VS Code extension (chat sidebar, inline edit, @hupi, inline completions) today, or HUPI Code, a full HUPI-native VS Code fork with the same experience built in from first launch | No — memory is scoped to that vendor’s own chat app, not your editor | No — a library/API you call from your own app code | No — an API/cloud service, not an editor client | No — an agent runtime/platform, not an editor tool |
| Self-hosted | Yes — the whole thing, on your own Postgres | No | Yes — open-source package or self-hosted server | Core Graphiti engine only; the full Zep product is cloud-hosted only | Yes — server process backed by your own Postgres |
| Works across LLM vendors | Yes — any OpenAI-API-compatible provider, plus Anthropic’s native API | No — locked to that vendor’s own models and apps | Yes — provider-agnostic by design | Yes — provider-agnostic | Yes — model-agnostic agent runtime |
| Independent fact-check before trusting a memory | Yes — a separate AI call verifies every claimed fact against the source conversation before it’s trusted | Not disclosed | Not a built-in step | Entity/fact extraction, not an independent verification pass | Not a built-in step |
| Retrieval audit trail | Yes — every turn logs exactly what was retrieved and why (hupi-trace, hupi-audit) | No | Request/audit logs on the self-hosted server | Platform-level logging (cloud product) | Agent-level state, not a dedicated retrieval audit log |
| Team workspaces with real isolation | Yes (Tier 3, commercially licensed) — per-team encryption keys + Postgres row-level security, independent of app code | No — single-user by design | Multi-user scoping in the API; isolation model is what you build around it | Depends on plan/deployment | Multi-agent, not a team-workspace/tenancy model |
| SSO / login via OpenID Connect (OIDC) | Yes (Tier 3) — any standards-compliant OIDC provider (Azure AD/Entra ID, Okta, Auth0, Google Workspace); team membership comes from your directory’s own roles/groups, not a separate admin step | Account-level SSO on Enterprise plans, unrelated to any memory/isolation model — there isn’t one to authenticate into | Not a built-in identity layer — you wire your own auth in front of it, same as any library called from your own app code | Depends on plan/deployment (cloud product) | Not applicable — no team-identity model to authenticate into |
| License | MIT (single-user core) + a separate commercial license for team workspaces | Proprietary | Apache-2.0, open source | Graphiti engine: Apache-2.0. Full product: proprietary, cloud-only | Apache-2.0, open source |
Based on public documentation as of this writing — this space moves fast, so verify current details against each project's own site before deciding. Corrections welcome: open an issue on GitHub.
In their own lane
When one of these is actually the better fit.
Vendor-native memory (ChatGPT, Claude, Gemini)
Zero setup, and it's already there if you only ever use one vendor's chat app. The trade-off is exactly that: it doesn't follow you to a different model, isn't self-hosted, and gives you no way to audit what it retrieved for a given answer or why. Reach for HUPI when you're building a product on top of an API rather than using a vendor's own chat app, or when you need memory that survives a future vendor switch.
Mem0
A genuinely broad, actively developed open-source memory library with support for far more vector-store backends than HUPI targets. It's a library you call from your own application code, though — you're building the retrieval-injection loop yourself. HUPI instead sits transparently in front of your existing OpenAI-compatible client, so nothing in your application code changes at all.
Zep / Graphiti
Graphiti's temporal knowledge graph is more sophisticated than HUPI's entity model for tracking how relationships between facts change over time. The full Zep product, though, is a cloud service — if self-hosting end to end matters to you, you'd be assembling Graphiti yourself on your own graph database rather than running a finished product.
Letta (MemGPT)
A genuinely different category — a full, open-source agent runtime with memory management as one part of a larger OS-like platform for agents that act autonomously. If you want to build agents that live inside a persistent runtime, Letta is built for exactly that. HUPI is narrower and more composable on purpose: a memory layer for whatever client you already have, not a runtime you build inside.