docs: rewrite Overview to sell the differentiation

The Overview didn't carry the positioning the product earns. Lead with
proof and the technical edge instead of generic capability cards:

- Open with the category + the #1-on-every-benchmark claim and the
  "reasons over a directed knowledge graph" thesis
- Add a benchmarks table (LongMemEval 81.6%, LoCoMo, ConvoMem — all #1)
- Replace the generic "what you can build" grid with "What makes
  Supermemory different": reasons (not retrieves), directed graph, whole
  context stack in one system, multi-modal, built to build on, run anywhere
- Keep deployment callout, how-it-works, the three context approaches,
  and the start-building / ways-to-use cards

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Dhravya Shah 2026-06-15 19:51:12 -07:00
parent e87290e3a4
commit 5437f9743c

View file

@ -4,81 +4,82 @@ sidebarTitle: "Overview"
icon: "book-open"
---
Supermemory is the long-term and short-term memory and context infrastructure for AI agents. It is the [state of the art](https://supermemory.ai/research) across multiple benchmarks, including LongMemEval and LoCoMo.
Supermemory is the memory and context engine for AI agents — and it's the state of the art, ranked **#1 on every major memory benchmark**: [LongMemEval](https://github.com/xiaowu0162/LongMemEval), [LoCoMo](https://github.com/snap-research/locomo), and [ConvoMem](https://github.com/Salesforce/ConvoMem).
With supermemory, you give your agents perfect recall about their users — so they're more intelligent, more personalized, and more consistent. Every piece of the context stack is built in, behind one API.
Your AI forgets everything between conversations. Supermemory fixes that. It learns from every interaction, **reasons over a directed knowledge graph** to resolve contradictions and track how facts change over time, forgets what's expired, and serves the right context at the right moment — through one API.
## State of the art, by the numbers
Most memory systems claim to be better. Supermemory is measurably ahead — first place across all three independent benchmarks the field uses to grade AI memory.
| Benchmark | What it measures | Supermemory |
|---|---|---|
| [LongMemEval](https://github.com/xiaowu0162/LongMemEval) | Long-term memory across sessions, with knowledge updates | **81.6% — #1** |
| [LoCoMo](https://github.com/snap-research/locomo) | Fact recall across long conversations (multi-hop, temporal, adversarial) | **#1** |
| [ConvoMem](https://github.com/Salesforce/ConvoMem) | Personalization and preference learning | **#1** |
Read the full methodology on the [research page](https://supermemory.ai/research), or reproduce it yourself with [MemoryBench](/memorybench/overview), our open-source benchmarking framework.
## What makes Supermemory different
Most "memory layers" are a vector store that retrieves the nearest chunk. Supermemory is an engine that *understands* — which is why it tops the benchmarks instead of just claiming to.
<CardGroup cols={2}>
<Card title="It reasons — not just retrieves" icon="brain" href="/concepts/how-it-works">
Resolves contradictions, tracks temporal change, follows multi-hop relationships, and forgets expired facts automatically. Reasoning is why it wins every benchmark.
</Card>
<Card title="A directed knowledge graph" icon="git-fork" href="/concepts/graph-memory">
One evolving directed graph and a single ontology across all your data — not a flat vector store, and not a raw graph you have to traverse yourself.
</Card>
<Card title="The whole context stack, one system" icon="layers" href="/concepts/super-rag">
Memory, user profiles, hybrid search (RAG), connectors, and file processing — together, sharing one context pool. No stitching five tools together.
</Card>
<Card title="Multi-modal — everything in" icon="file-text" href="/concepts/content-types">
Text, conversations, PDFs, images (OCR), video (transcription), and code (AST-aware chunking). Upload it and it just works.
</Card>
<Card title="Built to build on" icon="blocks" href="/integrations/supermemory-sdk">
One API, plus SDKs, a CLI, a memory filesystem, and MCP. Infrastructure you ship products on — not a closed box.
</Card>
<Card title="Run it anywhere" icon="server" href="/self-hosting/overview">
Hosted for zero-ops scale, or the full engine as one self-hosted binary — fully offline if you want, same API either way.
</Card>
</CardGroup>
<Tip>
**Hosted or self-hosted — same API.** Use the [managed platform](https://console.supermemory.ai) for zero-ops scale, or [run the entire engine on your own machine](/self-hosting/overview) — one binary, zero config, fully offline. Move between them by changing a single `baseURL`.
</Tip>
## What you can build with it
<CardGroup cols={2}>
<Card title="Agent memory" icon="brain" href="/concepts/graph-memory">
Extract and evolve facts about each user over time — knowledge updates, temporal changes, automatic forgetting.
</Card>
<Card title="User profiles" icon="user-round" href="/concepts/user-profiles">
A live blend of static and dynamic context your agent should always know, built automatically from memory.
</Card>
<Card title="Hybrid search (RAG)" icon="search" href="/search">
Semantic search with metadata filtering, contextual chunking, and reranking — over memories and raw documents in one query.
</Card>
<Card title="Content extraction" icon="file-text" href="/concepts/content-types">
Ingest text, conversations, PDFs, images, and even video — all turned into searchable, structured context.
</Card>
<Card title="Connectors and sync" icon="plug" href="/connectors/overview">
Continuously pull from Google Drive, Notion, Gmail, OneDrive, and more, with no pipeline to maintain.
</Card>
<Card title="Managed RAG platform" icon="layers" href="/concepts/super-rag">
Production-grade retrieval as a service, tuned to work alongside the memory engine.
</Card>
</CardGroup>
All of it shares the **same context pool** for a given user (`containerTag`), so memory and search reinforce each other instead of living in separate silos.
## How does it work? (at a glance)
![](/images/232.png)
- You send Supermemory text, files, and chats.
- Supermemory [intelligently indexes them](/concepts/how-it-works) and builds a semantic understanding graph on top of an entity (e.g., a user, a document, a project, an organization).
- At query time, we fetch only the most relevant context and pass it to your models.
- It [indexes them intelligently](/concepts/how-it-works) and builds a directed knowledge graph on top of an entity (a user, document, project, or organization).
- At query time, it fetches only the most relevant context and passes it to your models.
## Supermemory is context engineering
## Three ways to add context
We offer three ways to add context to your LLMs — mix and match them as your use case needs.
Memory, profiles, and search all draw from the **same context pool** for a given user (`containerTag`) — so they reinforce each other instead of living in silos. Mix and match as your use case needs.
#### Memory API — learned user context
![memory graph](/images/memory-graph.png)
Supermemory learns and builds memory for each user. These are extracted facts that:
Supermemory learns and builds memory for each user — extracted facts that:
- [Evolve on top of existing context about the user](/concepts/graph-memory), **in real time**
- Handle **knowledge updates, temporal changes, and forgetfulness**
- Handle **knowledge updates, temporal changes, and contradictions**
- Power a **user profile** that acts as the default context provider for the LLM
_Provide this to your LLM for more contextual, personalized responses._
#### User profiles
The latest, evolving context about a user also produces a [**User Profile**](/concepts/user-profiles) — static and dynamic facts the agent should **always** know:
The evolving context produces a [**User Profile**](/concepts/user-profiles) — the facts your agent should **always** know, in one ~50ms call:
- **Static:** information the agent should **always** know.
- **Dynamic:** **episodic** information about the last few conversations.
Configure what counts as static vs. dynamic for your use case for extremely personalized retrieval.
- **Static:** stable facts the agent should always know.
- **Dynamic:** episodic context from the last few conversations.
#### RAG — advanced semantic search
Alongside user context, run search over the raw content. Full RAG-as-a-service, with:
- Advanced metadata filtering
- Contextual chunking
- Tight integration with the memory engine
<Note>
All three approaches share the **same context pool** when using the same user ID (`containerTag`). Mix and match based on your needs.
</Note>
Run hybrid [search](/search) over the raw content too: advanced metadata filtering, contextual chunking, and reranking — tightly integrated with the memory engine, in a single query.
## Start building