Quick answer: The best alternatives to google inmemory sessions for anthropic sdk projects are a database that you can control (sqlite, postgres, or redis) to store the messages for each conversation, Anthropic’s resumable sessions, and Anthropic’s memory for facts that need to persist beyond the conversation. The fundamental fact is, of course, that an in-memory store will drop all its contents during restart and that the basic Messages API doesn’t provide any conversation state for you.
What Google’s In-Memory Sessions Are
A SessionService in Google’s Agent Development Kit (ADK) is where the session data, events and state are stored. These services are applied by default for agents: VertexAiSessionService and by default InMemorySessionService is for local dev. Also, there’s a DatabaseSessionService, which has a relational database that provides session data. In-memory sessions, while alluring in prototypes, are not persisted and will not exist after a restart of the application – so these are suitable for prototypes but not for production. One ADK tip-off is to use in-memory for local use, a database for developing most applications in production and a cloud service for enterprise-scale managed applications.
None of that is present if you use the Anthropic SDK to call Claude. You have to persist, since you send the conversation with each request.
The Three Layers
The best method for choosing is to distinguish three problems that people tend to lump into one. A single article in the Claude Agent SDK says the same – context window, session and memory are three distinct issues.
| Layer | Question | Typical solution |
| Context | What does the model observe on this request? | Reduce, cut or compact messages sent |
| Session | What’s happened in this conversation so far? | History, save and load the message history |
| Memory | What are things that should carry over from conversation to conversation? | Some kind of memory store (like Anthropic’s memory tool) |
“In-memory” is only a partial answer to the second layer, and isn’t a solution to the third at all.
The Options Compared
It is not a benchmark or comparison, but an editorial comparison.
| Option | Persists | Best for | Watch out for |
| Your Own DB (SQLite or Postgres) | Complete message history | Most production applications | You have to write load, save and clean out logic |
| Weak consistency during application cycles, sessions or chats may time out, due to Redis not being persistent | Recent history | redis with expiry | Data loss if Redis isn’t persistent |
| Our Claude AI agent sessions | Stored on disk, resume by ID | Agentic applications using that SDK | Functional – session ID must be tracked by the app developer |
| Anthropic memory tool | Files that live across sessions | Long running agents/Conversation memory across sessions | You handle the file handler |
| Already have Teams on ADK, need changes and migrations; Schema changes and migrations need care; Google ADK with a persistent service |
Option 1: Your Own Database
For the majority of apps, this is the easiest route. Keep a list of messages for a session occurring with an index and an ID for every session and refresh that list on each call to present to the user. This is not a sketch that has been tested here; therefore, run this sketch before using it:
python
import json
import sqlite3
import anthropic
db = sqlite3.connect(“sessions.db”)
db.execute(
The “CREATE TABLE IF NOT EXISTS messages “
“(session_id TEXT, idx INTEGER, role TEXT, content TEXT)”.
)
client = anthropic.Anthropic()
def load(session_id):
rows = db.execute(
“use 획득.SELECT role, content FROM messages WHERE session_id=? ORDER BY idx”,
(session_id,),
).fetchall()
return [{“role”: r, “content”: json.loads(c)} for r, c in rows]
Save the specified role,content.
n = db.execute(
“If the DB message count is available, it is 500 words more efficient.
).fetchone()[0]
db.execute(
“INSERT INTO messages VALUES (?, ?, ?, ?)”,
(json.dumps(content), role, n, session_id),
)
db.commit()
def chat(session_id, user_text):
save(session_id, “user”, user_text)
reply = client.messages.create(
model=”claude-haiku-4-5-20251001″,
max_tokens=1000,
messages=load(session_id),
)
text = reply.content[0].text
save(session_id, “assistant”, text)
return text
If you are using tools, store not only text, but also content blocks, tool-use-blocks and tool-result-blocks. Use Postgres or managed database when you have a lot of users or multiple servers.
Option 2: Claude Agent SDK Sessions
When your agent uses the Claude Agent SDK to accomplish a task, it keeps track of the conversation’s history, which is the summary of the session, and includes your prompt, any tool calls, tool outputs and responses. continue, resume and fork are options that you set on a query. The session ID is specific and is supposed to be captured and tracked by the client, and the SDK takes care of it for a single conversation in the client’s class.
According to one of the third-party articles, the sessions are stored on the device as a file named “session.jsonl” under a .claude/projects directory. That will help you to persist them if needed, but confirm with the official docs. Recently the docs were updated with an option for TypeScript of persistSession: false, meaning that the tasks will be stateless and do not require disk writes.
Option 3: The Memory Tool
The anthropic memory is a tool that enables Claude to store and access information through a set of memory files across conversations in a directory. It is client side as Claude asks you to perform file operations and your application does. It is not listed as a feature in the Claude Edge Tabs, as it is generally available on the Messages API (no beta header) and available is several SDKs with tool loop helpers, according to the docs. In a cookbook, it is combined with context editing, keeping longer sessions manageable with the aid of a tool-result clearing option.
Anthropic’s own framing is memory plus context editing: client memory + server context control. It is not meant to be a substitute for the message history for a single conversation, but for facts that need to live on, preferences and project notes for example.
Keeping Long Sessions Affordable
Long sessions are more expensive and eventually the context limit is reached due to the fact you resend history each turn. Context editing of Anthropic documents removes previous tool results and compaction is performed on the server for purposes of long conversations. If you’re sessions increase, plan for one of these.
Session Store Checklist
This is a checklist for Session Store (Linkable Asset).
- Choices Layer I need: Context, Session/Memory.
- Select a retail outlet that conducts itself following refreshes.
- Storing complete contents blocks, such as tool calls
- Assigned a unique ID to each session, and to each user
- Expiry & deletion rules are added.
- Using planned with context editing or compaction
- Avoided (where possible) personal data in stored history
- Tested to see if it reloads after server start-up
- Used memory support tool just for facts for cross-conversation
- Reviewed/checked the current document of changes in model and SDK
Guest Post Angles
These are suitable AI development and back-end publication topics:
- Designing conversation storage – Stateless APIs, stateful agents.
- Three layers: Context, Session and Memory.
- Moving from in-memory to Postgres: hands on.
Add Memory Later
Due to persistence, let’s add memory later.
When replacing in-memory sessions today, take a baby step: database table of messages, keyed by session ID. It is compact, extensible and resists crashes. Turn on conversations when they require text and add context management if they’re lengthy, but only add memory tool when knowledge needs to be carried over conversations. That simplifies the first version, and makes comparison with alternatives to google inmemory sessions for anthropic sdk draw closer accessible in opposition to your data.
