Blog·Author
Shardul Mane.
Growth at Supermemory. Helping developers and teams discover AI memory tools that power smarter, more personalized applications. Based in San Francisco.
- Understanding Zep's Memory Architecture Before You IntegrateEvaluate Zep by tracing how your application's source events become context for an agent.
- Claude Code persistent memory: what it keeps between sessions, and how to add moreClaude Code remembers two things between sessions: the CLAUDE.md files you write, and the auto memory notes it writes for itself. What each keeps, where they stop, and how to add memory that recalls earlier sessions and follows the repo to your other agents.
- Evaluating a Mem0 Alternative: Write the Replacement Brief FirstA useful search for a Mem0 alternative begins with the behavior you need to replace.
- What to Test Before a Memory Migration: Lessons from SciraTurn the published Scira customer story into indexing, retrieval, integration, and migration tests for your own memory workload.
- Mem0 to Supermemory: Compare Lifecycle Contracts Before MigratingCompare identity, source provenance, correction, deletion, and rollout behavior before migrating from Mem0 to Supermemory.
- RAG vs agent memory: which one do you need?Use RAG for knowledge that's the same for every user, and agent memory for what the agent should remember about each user over time. A decision guide with five questions and a worked support-agent example.
- Estimate a Custom Memory System by Workstream, Not API CountEstimate a custom memory system by the work required to make it correct, observable, and maintainable.
- When Is Self-Managed Agent Memory Worth the Work?Self-managed agent memory is justified when a concrete requirement cannot be met acceptably by a managed service and the team can operate the resulting system.
- Why a Chatbot Remembers a Preference but Still Gets It WrongA chatbot can retrieve a user's preference and still apply it incorrectly.
- Why Did Your Agent Forget? A Memory Debugging GuideTrace a memory failure through capture, processing, retrieval, context assembly, and answering before changing the architecture.
- Agent Memory Observability: Logs, Alerts, and Replay That Explain FailuresUseful memory observability connects a source event to the evidence used in an answer.
- Multi-Tenant Agent Memory: Scoping, Authorization, and IsolationDesign tenant and user scopes, enforce access on every path, and test memory isolation, deletion, caches, and background jobs.
- Push, Pull, or Poll? Choosing an Agent Memory Ingestion PatternChoose ingestion patterns from freshness needs, source capabilities, and recovery requirements.
- Useful AI Personalization Without Remembering EverythingPersonalization is useful when it removes repeated work from a task the user wants to complete.
- Memory Containers Are a Scope Boundary, Not a Login SystemA memory container groups records for retrieval.
- Build a Custom Memory Connector That Can Recover from FailureA custom connector needs more than a fetch-and-upload loop.
- How to Evaluate Memory Services for a Multi-Tenant AI ProductEvaluate a memory service for multi-tenancy with adversarial access cases and mixed workloads, not just a successful lookup for one user.
- Agent Memory Eviction: What to Leave Out of the Next PromptContext eviction decides which information will not be included in the next model request.
- Keep Source Connectors Separate from Memory DecisionsA connector should transport authorized source changes into a stable application format.
- Before Connecting Workspace Knowledge, Build a Permission MatrixBefore connecting workspace content to an AI assistant, map which sources can be imported, who can retrieve them, and how changes or removals propagate.
- Agent Memory Lifecycle: Corrections, Retention, and DeletionDefine what remembering, correcting, expiring, and deleting mean in your application, then test the behavior across sources, memories, profiles, and caches.
- Agent Memory Ingestion: Connectors, Freshness, and PermissionsDesign a reliable path from workspace documents to agent answers, with explicit checks for synchronization lag, authorization, retries, and deletion.
- Why Your Agent Cannot Find a Document It Already ReceivedAn agent can fail to find an uploaded document even when the upload succeeded.
- Coding Assistant Preferences: Resolve Scope Before Adding More MemoryWhen a coding assistant uses the wrong formatter or test framework, the problem may be conflicting instructions rather than missing storage.
- How to Preserve Decisions an AI Agent Should Not ReopenAn agent can retain the conversation and still propose an option the team already rejected.
- Make a Chatbot's Remembered Decisions Visible to UsersWhen a chatbot loses a decision, users need more than a better retrieval score.
- Build an AI Knowledge Base with Persistent Document ContextKeep uploaded documents useful across sessions with stable identities, processing checks, version control, scoped search, and source citations.
- Conversation History vs Agent Memory: What Should Survive a Session?Conversation history preserves messages.
- Supermemory with Zapier: Scoped Ingestion and Reliable RetriesConnect a Zap to Supermemory with stable source IDs, explicit identity mapping, and checks that separate accepted writes from searchable content.
- Microsoft Agent Framework Memory with SupermemoryConfigure a scoped Supermemory context provider, distinguish session state from shared context, and make conversation saving an explicit choice.
- Mastra and Supermemory: Native Memory, Processors, and ScopeChoose which memory responsibilities stay in Mastra and configure Supermemory processors with explicit user scope and conversation identity.
- Supermemory with n8n: HTTP Workflows, Identity, and ReadinessBuild an explicit n8n ingestion and retrieval flow with bearer credentials, stable scopes, durable source mapping, and queue-aware tests.
- Pipecat Memory: Retrieval Timing and Reliable Voice ContextPlace memory retrieval deliberately in a Pipecat voice pipeline, preserve call identity, and test interruptions, transcript revisions, and latency.
- LangGraph memory: checkpointers, stores and long-term memoryLangGraph has two kinds of memory. A checkpointer saves a thread's graph state at every step, and a store keeps what should carry across threads. How both work, how to add supermemory as long-term memory, and what to test before production.
- CrewAI Memory with Supermemory: Scope, Retrieval, and WritesUse CrewAI native memory deliberately and add shared external context without duplicating writes or leaking user information between crews.
- Add Memory to an OpenAI SDK App: Choose the Integration BoundaryChoose where an OpenAI SDK app retrieves persistent context: before a request, through a tool, or through a documented integration.
- Connect External Memory to LangChain Without Mixing History and RetrievalExternal memory belongs at a defined retrieval boundary in a LangChain application.
- LangGraph Persistence in Production: Restarts, Replays, and Write TimingA production LangGraph memory design needs to survive process restarts, resumed execution, and repeated writes.
- Repository Memory That Survives Code ChangesRepository memory becomes useful when it helps an agent find the reason behind the code.
- Memory or Fine-Tuning for Personalization? Start with What Must ChangeUse retrieved memory for user-specific facts that change and need inspection, correction, or removal.
- A TypeScript Memory Layer: Define the Contract Before the SDKA TypeScript memory layer benefits from a small application contract that separates identity, retrieval, and writes from any particular SDK.
- OpenAI Agents SDK Memory: Sessions and Cross-Session ContextUse native session storage for conversation history and an explicit memory service for selected context shared across conversations.
- Persistent Research Agents Need an Evidence Ledger, Not Just SummariesA research agent needs to preserve what it has read, which claims a source supports, and what remains unresolved.
- Filesystem Memory for Coding Agents: Paths, Permissions, and ProvenanceA filesystem can provide a useful interface to agent memory: records have paths, content can be inspected, and familiar read operations can retrieve context.
- Audio-to-Memory Costs: Track the Whole Call PipelineThe cost of turning calls into useful memory includes transcription, extraction, storage, retrieval, and later model context.
- Hot, Warm, and Cold Agent Memory: Tier by Use and FreshnessTier agent memory according to how quickly information is needed, how often it is reused, and what it costs to retrieve.
- Add Memory to an Existing App with a Reversible RolloutAdd memory to an existing application at a narrow capture and retrieval boundary, then expand after evaluating real failure cases.
- Supermemory with TanStack Start: A Server-Side Memory BoundaryKeep memory credentials and authorization in TanStack Start server functions while the client receives only permitted context.
- Conversation Compaction: Test What a Summary Must PreserveConversation compaction should preserve the information needed for the next task while reducing prompt size.
- Why Memory Works in One Chat but Fails in the NextWhen an assistant remembers information within a chat but loses it in the next, check persistence and identity before changing the model.
- OpenClaw Memory Troubleshooting: Separate Capture from RecallTroubleshoot OpenClaw memory by testing capture, processing readiness, retrieval scope, and the final answer separately.
- Persistent Memory for a Python Agent with SQLiteBuild a scoped, durable memory baseline in Python, then decide when semantic retrieval and a managed memory service are useful.
- Review an AI-Generated Memory Architecture Before Building ItTreat an AI-generated memory architecture as a proposal that needs evidence, requirements, and failure tests.
- Four Operation Tests Every Agent Memory Integration NeedsTest save, retrieve, correct, and remove as observable application behaviors before relying on agent memory.
- How to Audit Agent Trajectories for Memory FailuresA trajectory audit examines the sequence of retrievals, decisions, and tool calls that led to an agent's result.
- Memory Graph Relationships: Updates, Extensions, and InferencesA memory graph is useful when its relationships explain how facts change or connect.
- LongMemEval: What the Benchmark Tests and How to Read Its ResultsUnderstand LongMemEval-S and M, distinguish retrieval from answer quality, and identify the production tests a benchmark cannot replace.
- How to Evaluate Agent Memory with MemoryBenchRun a reproducible memory evaluation, interpret accuracy, latency, and context tokens, and add product-specific regression cases.
- Entity Resolution for Agent Memory: Avoid Connecting the Wrong FactsEntity resolution determines whether two references describe the same person, organization, project, or other subject.
- What Is RAG? Follow One Question from Source to AnswerRetrieval-augmented generation, or RAG, is a way to give a language model relevant source material when it answers a question.
- Episodic, Semantic, and Procedural Memory: What Should an Agent Store?Episodic memory represents an event, semantic memory represents a fact or concept, and procedural memory represents a way to perform a task.
- Text Chunking for RAG: Strategies, Examples, and EvaluationCompare fixed, structural, semantic, and parent-child chunking. Test evidence coverage and retrieval cost with a runnable Python baseline.
- Vector Database Costs: Build a Quote from the WorkloadA useful vector-database estimate starts with storage, reads, writes, and operating requirements—not just the number of vectors.
- Semantic Chunking for RAG: Test the Boundary Before Changing the ModelSemantic chunking places boundaries using changes in meaning, often estimated from sentence representations.
- Vector Embeddings: Meaning, Similarity, and Model CompatibilityAn embedding represents an input as a list of numbers that a model has learned to place in a useful geometric space.
- Choosing a Vector Database: Test Filters, Updates, and RecoveryChoose a vector database by testing the workload you intend to operate: filtered retrieval, changing documents, concurrent writes, and recovery.
- What Happens to a Vector Index When Documents Change?A vector index needs a lifecycle for revisions, deletions, and model changes.
- Advanced RAG: Route Questions Before Adding More Retrieval StagesAn advanced RAG pipeline should add work where a specific question needs it.
- When Should an Agent Save a Memory? Design the Write PolicyAn agent should save information because a defined future task needs it, not simply because a message was generated.
- Choose RAG Chunking by Document Type and Answer ShapeA chunking strategy should preserve the information needed to answer the questions your documents attract.
- Contextual Reranking for RAG: Query Context, Candidates, and TestsSeparate query rewriting, chunk enrichment, candidate retrieval, and reranking, then evaluate each stage against labeled evidence.
- Building AI User Profiles: Facts, Context, and CorrectionsAn AI user profile is a short, current summary of what an application knows about a person, added to the model's context on every request.
- When to Add a Graph to RAG: Design a Relationship-Question PilotAdd a graph to RAG when a demonstrated question depends on explicit relationships that your current retrieval path fails to supply reliably.
- Self-hosted memory for AI agents: options and trade-offsYou can self-host memory for AI agents three ways: build it on your own database, run a memory framework on your own servers, or run a vendor's memory server inside your network. What each leaves you to build, how to run supermemory Local, and what still leaves your network.
- Few-Shot Examples vs Retrieved Context: Spend the Prompt Budget DeliberatelyFew-shot examples show a model how to perform a task.
- Smaller Embeddings for Code Search: How to Test the TradeoffEvaluate smaller code embeddings with repository questions, compatible model settings, storage arithmetic, and a reversible index pilot.
- Vector Search, Graph Traversal, or Both? Choose by the QuestionChoose vector search, graph traversal, or both by the evidence a question needs, then test relevance, relationships, and access.
- A Composable Memory Stack Starts with Interface ContractsA memory stack becomes replaceable when its components agree on explicit inputs, outputs, identity, and failure behavior.
- Design an Agent Memory Schema That Can Be CorrectedAn agent memory schema should describe what was learned, who it applies to, where it came from, and whether it is still valid.
- Replace One Memory Component Without Losing the ContractReplacing an embedding model, retrieval service, or memory store requires more than moving data.
- An Enterprise Design Review for Agent MemoryAn enterprise memory design review should establish what the system remembers, who can access it, how it changes, and how failure affects the product.
- What Makes Agent Memory Useful? Test the User OutcomeUseful agent memory reduces repeated explanation while keeping answers current, relevant, and under the user's control.
- A Practical Workflow for Using Long-Term AI MemoryLong-term AI memory works best when you deliberately save useful context, verify what was retained, and correct it when circumstances change.
- A RAG Chatbot Launch Review: Evidence, Access, and Failure BehaviorReview a RAG chatbot for evidence quality, permissions, freshness, failure behavior, and realistic workload performance before a pilot.
- Call Transcription to Agent Memory: A Reliable PipelineTurn completed transcript segments into scoped, traceable memory. Handle live audio, revisions, retries, speaker identity, and costs separately.
- Temporal Agent Memory: When Facts ChangeUse event time and validity intervals to answer current and historical questions. Learn when a temporal knowledge graph helps and test a SQL baseline.
- Cursor memory: rules, memory banks and the supermemory pluginCursor doesn't remember your earlier chats on its own. It loads the instructions you write down, in rules and AGENTS.md files. How memory banks fill part of the gap, and how the supermemory plugin adds memory that follows the repo, in Cursor and Grok Bot.
- What Happens When an AI Agent Runs Out of Context?Diagnose context overflow, lost details, and bad summaries. Preserve decisions and evidence while budgeting prompts, tool output, and retrieved memory.
- Memory and Retrieval for Large-Repository Coding AgentsDiagnose stale code, missing dependencies and lost decisions. Combine current source inspection with scoped memory and test the resulting changes.
- Latency Budgets for Memory RetrievalSet workload-specific latency targets, trace the critical path, and compare retrieval changes by answer quality, tail latency and cost.
- AI Memory for Non-Technical Builders — What Your App Should RememberUnderstand persistent AI memory, its relationship to RAG, the questions to ask before integrating it, and how to test whether it helps returning users.
- Vercel AI SDK memory and persistence, with supermemoryThe Vercel AI SDK doesn't store anything between requests for you. How chat persistence and memory across conversations differ, and how to add memory with supermemory's middleware on AI SDK 5, 6 or 7.
- The Operating Cost of an LLM Memory SystemModel ingestion, retries, context tokens, storage, maintenance, and recovery with explicit workload assumptions and a worked cost example.
- Team Knowledge and AI Memory: Notes, Sources, and Shared ContextConnect team notes to useful agent context while preserving source permissions, revisions, and the distinction between a workspace and a memory service.
- Long-Term Memory for AI Study AssistantsBuild continuity across study sessions with source-backed progress records, current preferences and correction tests. Separate memory from mastery.
- How to Use Supermemory with ConvexKeep Convex as your persistent application database and call Supermemory from actions for scoped retrieval, profiles, and cross-session context.
- Long-term memory in AI: what it is and how it worksLong-term memory in AI is information an application saves outside the model and brings back in later conversations, so an assistant can remember users, decisions and unfinished work across sessions.
- How Perplexity memory works: what it remembers and how to delete itYes, Perplexity remembers you between conversations. Its Memory feature draws on saved memories and your past searches. You can turn either off in Settings, under Memory, and delete memories there or past searches in your History.
- Context Management Tools for LLM Chat — How to ChooseCompare context-management approaches across Supermemory, Mem0, Zep, Letta, Cognee and Weaviate using documented capabilities and a shared evaluation workload.
- Weaviate vs Supermemory: Database, Engram, and Agent MemoryCompare Weaviate Database, Engram, and Supermemory by application needs, processing behavior, pricing inputs, deployment, and migration tests.
- How to Make AI Remember User Preferences Across ConversationsTo make an AI remember user preferences across conversations, save each preference outside the model under a stable user ID, then load the relevant ones into the prompt at the start of every new conversation.
- Hybrid search explained: BM25, vector search and rank fusionHybrid search runs a keyword search and a vector search on the same query and merges the two result lists, usually with reciprocal rank fusion. How each side works, a worked example, runnable code and how it applies to agent memory.
- Agentic Workflows — A Practical Guide to AI AutomationDesign agent workflows around bounded tasks, explicit state, reliable tools and measurable outcomes. Understand where persistent memory helps and where it does not.
- Choosing Embedding APIs for Production RetrievalCompare embedding providers by supported inputs, retrieval quality, compatibility and workload cost. Keep embedding APIs separate from databases and memory services.
- What is context engineering? A guide with a worked exampleContext engineering is the work of choosing what an AI model sees on each step of a task: its instructions, its tools, the conversation so far, retrieved documents, tool results and memory.
- Graph RAG vs Vector RAG: When Relationships MatterUse the question type to decide when graph retrieval adds value. Compare explicit relationships, semantic matches, indexing costs, and evidence quality.
- Supermemory vs Pinecone for Agent MemoryCompare Pinecone Database, Pinecone Assistant and Supermemory at the right product boundary, then evaluate retrieval, lifecycle and cost on one workload.
- Best Memory APIs for AI Agents: How to ChooseCompare Supermemory, Mem0, Zep, Letta, and Weaviate Engram by workload, memory behavior, operating cost, and reproducible tests.
- Supermemory vs Zep: Compare Memory for Your Agent WorkloadCompare Supermemory, managed Zep, and Graphiti using the same workflow, evaluation conditions, and operating-cost assumptions.
- How Vector Search Works: Embeddings, Indexes, and TradeoffsUnderstand embeddings, exact and approximate search, metadata filters, and index updates. Choose vector retrieval based on the questions your product must answer.
- Switching Memory Infrastructure Without Losing ContextEvaluate a replacement on real failures, preserve source identity and lifecycle behavior, and use a staged migration with a rollback path.
- How to Build a RAG Chatbot: Retrieval, Citations, and EvaluationBuild a RAG chatbot around authorized retrieval, traceable evidence, and answer-quality tests. Includes a runnable local retrieval baseline.
- AI Memory for Customer Support Agents: A Practical ArchitectureAn AI support agent remembers customers across conversations when every ticket, chat and call is saved under one stable customer ID, and the relevant history is loaded before the agent replies.
- AI Memory vs Vector Databases: What Your Agent NeedsLearn when a vector database is enough for agent memory and when extraction, profiles, corrections, and lifecycle management justify a memory service.
- Sync Notion to an AI Agent with Incremental UpdatesBuild a Notion sync around verified webhooks, page and block retrieval, stable revisions and observable freshness. Avoid unnecessary full re-embedding.
- Context memory in AI: the context window and agent memory architectureContext memory in AI is everything a model can draw on when it answers: the context window it reads on this call, plus memory an application saves outside the model and loads back in.
- Should You Build or Buy an AI Memory System?Compare custom, managed, and hybrid memory infrastructure using workload tests and an explicit twelve-month cost model.
- Catch up with our UNFORGETTABLE Launch WeekOver the last year, one belief has guided almost everything we’ve built at Supermemory AI becomes meaningfully useful only when it remembers. Memory shouldn’t be something developers rebuild from scratch. It shouldn’t be fragile, expensive, or trapped inside a single tool.
- Empowering the Next Generation of Founders: Supermemory Startup ProgramIf there’s one thing we’ve learned while building Supermemory, it’s that most startups don’t fail because they didn't build features; they fail when infrastructure slows them down, or they built too slow.
- Matryoshka representation learning and embeddings: how it works and how we use itMatryoshka representation learning trains one embedding whose first dimensions also work on their own, so you can store and search shorter vectors. How it works, the loss, code, which models support it and how we use it.
- How do I give Claude, ChatGPT and Cursor long-term memory with MCP?Connect each app to the same memory server over MCP, and they all share one long-term memory. Steps for Claude, ChatGPT, Cursor and other clients, the tools the server gives them, and when a plugin works better than MCP.
- Graph RAG tutorial: build a knowledge graph for RAG, step by stepBuild a knowledge graph for RAG step by step in Python. Extract triples, resolve entities, store them with their sources, walk the graph to answer multi-hop questions, test it, then move it to Neo4j.
- Best free embedding models in 2026: open-source models, rankedThe open-source embedding models with the highest retrieval scores in October 2026, the embedding APIs with free allowances, and the small models that run on a CPU, with license, size, dimensions and max input for each.
- Three Ways to Add Long-Term Memory to an AI AppLLMs have no long-term memory of their own: the model keeps nothing between requests, so your application has to save what matters and send the relevant part back.
- LangChain memory: how to add short-term and long-term memoryMemory in LangChain v1 has two parts. Short-term memory is the conversation thread, saved by a checkpointer, and long-term memory carries across threads. How to set up both, keep long chats inside the context window, and add long-term memory with supermemory.