Noureddine RAMDI / Supermemory: a unified memory and context engine for AI applications

Created Tue, 05 May 2026 13:37:39 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
992 Words
github-stars typescript ai-memory rag sdk mcp hybrid-search

supermemoryai/supermemory

Supermemory tackles a common pain point in AI development: managing user memory and context efficiently without juggling multiple components like vector databases, embedding pipelines, and chunking strategies. Instead of stitching together these parts yourself, Supermemory offers a TypeScript-based unified memory and context engine that automatically extracts facts from conversations, maintains detailed user profiles with both long-term and recent context, and supports hybrid retrieval combining traditional RAG search with memory recall.

What supermemory is and how it simplifies AI memory management

At its core, Supermemory is an abstraction layer designed to replace the traditional Retrieval-Augmented Generation (RAG) stack. The usual approach requires developers to configure vector databases, set up embedding pipelines, decide on chunking strategies, and manage user context stores manually. Supermemory consolidates all these responsibilities into a single unified memory engine.

The system automatically extracts relevant facts from user interactions or documents and organizes them into user profiles containing static (long-term, persistent) and dynamic (recent, session-level) context. This dual-context model allows AI applications to maintain a nuanced understanding of users, tracking temporal changes and contradictions over time.

Under the hood, Supermemory is implemented in TypeScript and offers SDKs for npm and pip, making it accessible across JavaScript/TypeScript and Python environments. It also provides drop-in wrappers for popular AI frameworks like Vercel AI SDK, LangChain, LangGraph, Mastra, and Agno, easing integration into existing AI workflows.

A notable architectural highlight is its hybrid search capability, which combines traditional RAG-style retrieval with memory-based recall, enhancing both relevance and completeness of context retrieval.

Supermemory also integrates with MCP (Model Context Protocol) servers, facilitating seamless operation within AI coding tools such as Claude Code, Cursor, and VS Code extensions. Connectors for major data sources like Google Drive, Gmail, Notion, OneDrive, and GitHub automatically sync external data into the memory engine via webhooks, ensuring up-to-date and comprehensive user profiles.

What sets supermemory apart: architecture, performance, and tradeoffs

The standout feature of Supermemory is its profile() endpoint, which returns both static long-term facts and dynamic recent context in roughly 50 milliseconds—an impressive latency that collapses the typical multi-step user context assembly and search process into a single call. This simplifies developer experience significantly by eliminating the need to maintain separate context stores or run multiple searches.

Supermemory’s architecture emphasizes convention over configuration. Developers don’t have to tune embedding models, configure vector databases, or manually chunk data. This reduces the infrastructure and operational complexity that often acts as a barrier to adopting advanced AI memory management.

The tradeoff lies in the abstraction: while it offers a highly streamlined experience, developers relinquish some control over the internals of embedding strategies and indexing. This could be a limitation in highly specialized use cases demanding fine-tuned vector search or custom embedding workflows.

Code quality appears solid, with clear SDK interfaces and documented integration points. The TypeScript implementation offers type safety and maintainability, while the Python SDK broadens usability for data scientists or AI engineers working in Python environments.

Benchmark-wise, Supermemory tops major AI memory benchmarks like LongMemEval, LoCoMo, and ConvoMem, proving its effectiveness in real-world scenarios where memory and context retrieval speed and accuracy matter.

Quick start with supermemory

Supermemory provides straightforward installation and quickstart commands directly from its README:

npx -y install-mcp@latest https://mcp.supermemory.ai/mcp --client claude --oauth=yes

Replace claude with your client of choice such as cursor, windsurf, or vscode.

To install the core package:

npm install supermemory    # or: pip install supermemory

Example usage in TypeScript:

import Supermemory from "supermemory";

const client = new Supermemory();

// Store a conversation
await client.add({
  content: "User loves TypeScript and prefers functional patterns",
  containerTag: "user_123",
});

// Get user profile + relevant memories in one call
const { profile, searchResults } = await client.profile({
  containerTag: "user_123",
  q: "What programming style does the user prefer?",
});

// profile.static  → ["Loves TypeScript", "Prefers functional patterns"]
// profile.dynamic → ["Working on API integration"]
// searchResults   → Relevant memories ranked by similarity

And in Python:

from supermemory import Supermemory

client = Supermemory()

client.add(
    content="User loves TypeScript and prefers functional patterns",
    container_tag="user_123"
)

result = client.profile(container_tag="user_123", q="programming style")

print(result.profile.static)   # Long-term facts
print(result.profile.dynamic)  # Recent context

This example showcases how Supermemory lets you both add conversational context and retrieve a comprehensive user profile with a single query. The fact extraction and profile management happen behind the scenes, freeing you from manual embedding or vector search code.

Verdict: who should consider supermemory and its limitations

Supermemory is well-suited for developers building AI applications that require persistent, evolving user memory and context without wanting to build and maintain a full RAG stack from scratch. Its SDKs and framework integrations lower the barrier for adding powerful memory capabilities.

The system is especially relevant if you need fast, hybrid memory retrieval that combines long-term facts with recent context in real time, such as AI assistants, chatbots, or coding tools integrating AI context.

However, if you require fine-grained control over embedding models, vector database tuning, or custom chunking strategies, Supermemory’s abstraction might feel limiting. It’s designed for convenience and developer experience at the cost of some configurability.

Overall, the codebase is solid, the architecture well thought-out, and the benchmarks credible. It’s worth exploring if you want to simplify AI memory management without sacrificing performance.

→ GitHub Repo: supermemoryai/supermemory ⭐ 22,383 · TypeScript