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 Memory: Native Features and the Supermemory PluginUnderstand CLAUDE.md, auto memory, and the Supermemory plugin. Check setup, project scope, corrections, and cross-session recall for your repository.
- 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: What Each Does and When to Combine ThemDistinguish document retrieval, conversation persistence, and memory lifecycle management before choosing an agent architecture.
- 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: Checkpoints, Cross-Thread Stores, and SupermemorySeparate thread checkpoints from reusable user context, test both locally, and add Supermemory at an explicit retrieval boundary.
- 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 CorrectionsBuild useful AI user profiles with selective extraction, source evidence, scoped preferences, corrections, and tests for personalization quality.
- 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 vs Managed AI MemoryCompare self-hosted and managed AI memory by deployment control, data flows, operating work, recovery and total workload cost.
- 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 with Project Files and Supermemory MCPUse Cursor rules, maintained project notes and a scoped MCP connection for persistent context. Verify what is saved, loaded and shared across sessions.
- 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.
- How to Use Supermemory with AI SDKAdd persistent user context to an AI SDK application, then test continuity, isolation, corrections, and retrieval failures.
- 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.
- What Is Long-Term Memory in AI? A Practical GuideLearn how AI applications remember across sessions, why stored chats are not enough, and how to test recall, corrections, and deletion.
- How Perplexity Memory Works: Settings, History, and LimitsUnderstand Perplexity memory and search history, inspect personalization, and distinguish consumer controls from memory infrastructure for your own app.
- 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 ConversationsStore, retrieve, correct, and remove user preferences across sessions with clear identity and scope boundaries.
- Hybrid Search: Combining Lexical and Semantic RetrievalCombine keyword and vector results without mixing incompatible scores. Learn rank fusion, reranking, filtering, and how to evaluate the tradeoffs.
- 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 for AI BuildersChoose what an agent sees at each step: instructions, tools, retrieved evidence, memory, and working state. Includes a concrete context-budget example.
- 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 ArchitectureCarry useful ticket history across conversations while keeping current business state, customer identity, and memory corrections separate.
- 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.
- Agent Memory Architecture: Types, Schemas, and Data FlowDesign agent memory around explicit data contracts, retrieval, corrections, and application state. Use memory types to clarify decisions, not multiply services.
- 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 Embeddings: Dimensions, Normalization, and RetrievalUnderstand nested embedding dimensions, calculate raw storage tradeoffs, and test shortlisting quality before adopting a smaller representation.
- Share Context Across AI Clients with Supermemory MCPConnect compatible MCP clients to a shared memory service using OAuth. Verify spaces, explicit saves, cross-client retrieval, and correction behavior.
- Build a Knowledge Graph for RAG: A Small, Testable ExampleModel evidence-backed relationships, query a scoped path, and validate provenance before adding extraction models or a graph database.
- Choosing Open Embedding Models: A Reproducible Retrieval EvaluationCompare embedding models using their documented prompts, licenses, dimensions, and measured performance on your own retrieval tasks.
- Three Ways to Add Long-Term Memory to an AI AppChoose between saved records, a custom retrieval layer, and a managed memory API. Keep clear boundaries around identity, state, and migration.
- Conversational Memory in LangChain: History, Stores, and RetrievalUnderstand LangChain conversation persistence, control context growth, and connect long-term user context without confusing it with thread history.