How to Use Supermemory with AI SDK
Every session your AI SDK agent handles starts from zero. No memory of what users asked last week, what they prefer, or what's still unresolved. You can bolt on a vector database, but chunk retrieval isn't the same as understanding context; it hands your agent similar text, not actual knowledge of who it's talking to.
Supermemory slots a full memory layer beneath your existing AI SDK stack without touching your model calls or provider setup. A memory graph that tracks relationships across sessions, user profiles built automatically from behavior, and sub-300ms retrieval that won't stall your streams. This post walks through what that integration actually looks like, what the benchmarks say, and how to get it up and running in under 5 minutes.
TLDR:
- AI SDK handles requests well, but remembers nothing between sessions by design
- Supermemory adds memory graph, user profiles, and sub-300ms retrieval below your agent loop
- Scores 76.7% multi-session accuracy vs 57.9% competitors on LongMemEval-S benchmark
- Install with
npm i supermemoryand inject tools directly into generateText or ToolLoopAgent - Supermemory gives AI SDK a memory API with graph-based intelligence and retrieval under 300ms
What It Means to Use Supermemory with AI SDK
AI SDK handles tool calls, model output, and streaming responses well. What it doesn't do is remember anything every request your agent gets starts cold, with no knowledge of what your users said last week, what they prefer, or what they're still waiting on. Most teams patch this with a quick vector database setup, but retrieval alone won't cut it: it returns text chunks, not actual understanding of who your user is. Fortunately, using Supermemory with AI SDK gives your agent a real memory layer without ripping out your existing stack.
How Supermemory Fits Into a AI SDK Stack
AI SDK's ToolLoopAgent is good at one thing: managing the conversation loop. It maintains a message array, decides what the model sees at each step, and handles tool call orchestration. But when the session ends, that message array is gone. No built-in persistence, no extraction, no retrieval. You manage all of that yourself.
The challenge with designing effective agent tools is balancing granularity with context overhead: too many small tools slow the loop, too few broad tools reduce precision.
So where does Supermemory slot in? Think of it as the layer sitting just below your agent loop.
What Supermemory replaces
- Session storage you'd otherwise build manually from scratch
- A separate vector database for semantic retrieval
- Document extraction pipelines for PDFs, audio, and web pages
- Custom user profile logic spread across your codebase
What it augments
- The conversation loop itself, by injecting relevant memory context before each model call
generateTextandstreamTextcalls, by supplying a richer system prompt built from the user's memory graph
You pull context from Supermemory before generating, then write new memories back after. That's the full integration pattern. It works with any provider AI SDK supports since there's no coupling to a specific model.
Memory Capabilities That Matter for AI SDK Builders
AI SDK gives excellent primitives for model interaction. What it doesn't give you is memory. Here's what Supermemory actually adds for teams building serious agent workflows.
Memory Graph for Multi-Step Tool Loops
Stateless serverless handlers are a real problem for multi-step tool loops. Each invocation starts cold. The memory graph tracks relationships between memories using ontology-aware edges, handling knowledge updates, contradictions, and inferences automatically. Your agent doesn't need to know what happened three tool calls ago because the graph does.
User Profiles for Personalized Agent Responses
Every ToolLoopAgent call that manually stuffs user preferences into a system prompt is tech debt waiting to compound. Supermemory builds user profiles automatically from behavior, combining static facts with real-time episodic context from recent sessions. Inject the profile, skip the boilerplate.
Hybrid Retrieval Under 300ms
Hybrid retrieval combines vector and keyword search with context-aware reranking. Sub-300ms latency fits cleanly inside a streamText call without stalling the stream.
Multi-Modal Extraction Built In
Native extraction handles PDFs, audio, and web pages automatically. Audio gets transcribed via Gemini 2.5 Flash, chunked, and indexed. Connectors handle Slack, Notion, Drive, and Gmail.
Capability
AI SDK Challenge Solved
Outcome
Memory Graph
Stateless handlers lose context between tool calls
Agents remember relationships across multi-step loops
User Profiles
Manual context injection per request
Auto-built personalization without config overhead
Sub-300ms Retrieval
Latency breaks streaming responses
Memory lookup invisible to end users
Connectors
Manual data pipeline integration
One-line sync from Slack, Notion, Drive, Gmail
Performance Benchmarks in a AI SDK Context
Numbers matter when you're deciding what to ship in production. Here's what the benchmarks actually say and what they mean for AI SDK workloads.
On LongMemEval-S, Supermemory scores 76.7% on multi-session accuracy versus 57.9% for competing providers. For ToolLoopAgent workflows spanning multiple sessions, that gap is the difference between an agent that feels coherent and one that keeps forgetting. Temporal reasoning hits 82.0% against 62.4%, which matters when agents reason across conversation threads with time-sensitive context.
On the LoCoMo benchmark, P@1 is 59.7% versus 34.4% from a major provider. Recall@10 reaches 83.5% versus 69.3%. When your agent executes tool calls and writes results back to memory, poor retrieval precision means wrong context fed into future steps.
The latency story is straightforward: sub-300ms recall across 100B+ tokens processed monthly. A streamText call won't stall waiting on memory. That's the engineering risk these numbers remove entirely.
Enterprise Readiness for Teams Shipping on AI SDK
Shipping memory as critical infrastructure means your compliance and deployment story has to hold up under scrutiny. Supermemory is SOC 2 Type 2, HIPAA, and GDPR compliant, with all data encrypted in transit and at rest.
For teams with data residency requirements, full self-hosting via Docker gives you complete control over where customer conversations live. Cloud, self-hosted, VPC, and hybrid deployments are all supported. Enterprise tier includes a forward-deployed engineer for teams who need hands-on integration support.
The vendor lock-in concern is real when memory becomes load-bearing infrastructure. Supermemory's pluggable vector backend support lets you keep your existing Pinecone, Weaviate, or Qdrant setup and add Supermemory's intelligence layer on top. No forced migration, no ripping out current infrastructure. You get the memory graph, user profiles, and retrieval quality without abandoning what you've already built.
Pricing and Scale Considerations for AI SDK Products
Supermemory uses usage-based billing. Each plan includes a monthly credit balance, which is consumed as you ingest content, retrieve context, and run other operations. Usage beyond the included balance is charged at the published rates.
| Plan | Monthly price | Included monthly credits |
|---|---|---|
| Free | $0 | $5 |
| Pro | $19 | $20 |
| Max | $100 | $130 |
| Scale | $399 | $600 |
| Enterprise | Custom | Custom |
Ingestion is metered in SM tokens: unique content actually ingested. Repeated or unchanged content is not billed again. Ingestion rates differ between Memory and SuperRAG, and between plain text and rich content.
See the current plans and rate card for prices, included credits, and feature availability.
Getting Started: Supermemory + AI SDK
Start with npm i supermemory. Get your API key from console.supermemory.ai. Setup takes under five minutes.
The native AI SDK integration lives in @supermemory/tools/ai-sdk. Import supermemoryTools and pass them directly into your ToolLoopAgent or any custom generateText loop. The tools handle saving and retrieving memories automatically through semantic search, which means you're not writing retrieval logic by hand.
import { supermemoryTools } from "@supermemory/tools/ai-sdk";
const result = await generateText({
model,
tools: supermemoryTools({ apiKey: process.env.SUPERMEMORY_API_KEY }),
messages,
});The AI SDK memory docs walk through the ToolLoopAgent pattern in full.
FAQ
What's the best way to add memory to a AI SDK agent?
Use Supermemory's native AI SDK integration (@supermemory/tools/ai-sdk). Import supermemoryTools and pass them into your ToolLoopAgent or generateText loop, the tools handle saving and retrieving memories through semantic search automatically, so you skip writing retrieval logic by hand.
AI SDK memory graph vs vector database?
A vector database gives you lookup, not memory. It returns similar chunks but doesn't track relationships, handle contradictions, or understand how user goals shift over time. Supermemory's memory graph uses ontology-aware edges to manage knowledge updates, inferences, and temporal context, so your agent remembers what actually matters across sessions instead of just fetching text.
How do I use Supermemory with AI SDK?
Install with npm i supermemory, grab your API key from console.supermemory.ai, and import supermemoryTools from @supermemory/tools/ai-sdk. Pass the tools directly into your generateText or ToolLoopAgent calls, the tools handle saving and retrieving memories through semantic search automatically. Setup takes under five minutes and works with any model provider AI SDK supports.
Can stateless serverless handlers maintain context across tool calls?
Yes, if you use a memory layer. Supermemory's memory graph tracks relationships between memories automatically, so each cold invocation can pull relevant context from previous tool calls without manual session storage. Your agent doesn't need to remember what happened three steps ago because the graph does.
What does sub-300ms retrieval mean for streaming responses?
Memory lookup completes fast enough that your streamText call never stalls waiting on context. At 100B+ tokens processed monthly, Supermemory maintains sub-300ms latency so users don't see lag when your agent pulls personalized context mid-stream.