The agentram-mcp server provides persistent, cloud-backed memory for AI agents via the AgentRAM API. It offers the following capabilities:
Personal Agent Memory
Store a memory: Save a key-value pair for a specific agent, with an optional expiry (ttl_days). Overwrites existing keys without duplicates.
Retrieve a memory: Fetch a stored value by agent ID and key.
List memories: Get all memories for an agent, sorted newest first (up to 200), with expired entries excluded.
Search memories: Perform a case-insensitive text search across both keys and values — no embeddings or vector setup required.
Delete a memory: Permanently remove a specific memory by agent ID and key.
Shared Multi-Agent Memory
Create a namespace: Create a shared memory pool (free) that multiple agents can read from and write to.
Store shared memory: Write a key-value pair into a shared namespace, accessible by any agent with the namespace key.
Retrieve shared memory: Read a value from a shared namespace by key.
List shared memories: List all entries in a shared namespace, sorted by most recent.
Utility
Check credits: View your current AgentRAM account balance. This call is free.
Most operations cost 1 credit each.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@agentram-mcp Store that my favorite color is blue"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP server for AgentRAM. It gives your AI agents persistent memory through a set of tools, with no vector database and no embedding pipeline to set up. Get a key, paste the config below, and you're running in about a minute.
Works with any MCP client: Claude Desktop, Claude Code, Cline, Cursor, Windsurf, and others.
Every agent session starts with amnesia. AgentRAM is a plain HTTP memory store built for agents: one call to save something, one call to read it back. No infra to stand up, no vectors to babysit. This package wraps that API as MCP tools so your agent can just use it.
Related MCP server: Recall Select
You need an API key first. Register at agentram.dev and it gets emailed to you. New accounts start with 1,000 credits and no card is required.
Then add this to your client's MCP config. For Claude Desktop that file is claude_desktop_config.json (on macOS it lives at ~/Library/Application Support/Claude/claude_desktop_config.json):
{
"mcpServers": {
"agentram": {
"command": "npx",
"args": ["-y", "agentram-mcp"],
"env": {
"AGENTRAM_API_KEY": "agentram_your_key_here"
}
}
}
}Restart the client and the tools show up. Most clients let you mark them "always allow" so you're not clicking approve on every call.
One gotcha on macOS: Claude Desktop doesn't ship with Node, so install Node 18 or newer first or the server won't start.
Fifteen tools. Ten for flat memory, five for temporal memory (facts that change over time).
Flat memory:
store_memory: save a value under a key for an agent
retrieve_memory: read one back by key
list_memories: list everything stored for an agent
search_memories: text search across keys and values, no embeddings needed
delete_memory: remove one
check_credits: current balance, free to call
Shared memory, for when more than one agent needs the same pool:
create_namespace: make a shared space, free to call
store_shared_memory: write into it
retrieve_shared_memory: read from it
list_shared_memories: list what's in it
Temporal memory (assertions):
store_assertion: record a fact that can change, like a plan, a status, or a preference
retire_assertion: mark a fact as no longer true while keeping the history
get_assertion: what's currently true for a key
list_assertions: all the current facts for an agent
get_assertion_history: the full chain of what a key has been over time
Flat memory overwrites. Temporal memory keeps the trail. When a fact changes you supersede the old value, and the previous values stick around so you can see how you got to the current one.
The part worth knowing: if two different values land on the same key and neither one supersedes the other, get_assertion will not quietly pick a winner. It tells you the key is contested and returns both values, so your agent can decide instead of running on a guess. list_assertions flags which keys are in that state.
Flat and temporal are separate keyspaces. A key called plan in store_memory and a key called plan in store_assertion have nothing to do with each other. Use flat memory for stuff you just overwrite, and assertions for facts you want a record of.
Reads and writes cost 1 credit each. check_credits and create_namespace are free. A read that finds nothing (a 404) refunds the credit. Most responses include your credits_remaining so you can watch the balance.
AGENTRAM_API_KEY (required): your key, starts with agentram_
AGENTRAM_API_BASE (optional): defaults to https://api.agentram.dev
Site: https://agentram.dev
MIT
Create a shared memory namespace that multiple agents can read from and write to. Returns a namespace_key to share with each agent. Free to call (no credit deducted).
Inputs: label.
Permanently delete a stored memory. Cannot be undone. Costs 1 credit.
Inputs: key (required), agent_id (required).
List all memories stored under an agent ID, ordered by most recently written. Expired memories are excluded. Costs 1 credit.
Inputs: agent_id (required), limit.
Retrieve a stored memory by agent ID and key. Returns 404 (and refunds the credit) if the memory does not exist. Costs 1 credit.
Inputs: key (required), agent_id (required).
Store a value under a key for a given AI agent. Writing to an existing key updates the value (no duplicates created). Costs 1 credit.
Inputs: key (required), value (required), agent_id (required), ttl_days.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 6 tools
Each tool targets a clearly defined operation, but store_memory and store_shared_memory are close enough in name and behavior that an agent might briefly confuse them. Descriptions do clarify the distinction between agent-specific memory and shared namespaces.
Most tools follow a consistent verb_noun pattern: store_memory, retrieve_memory, delete_memory, create_namespace, store_shared_memory. The only minor inconsistency is list_memories using a plural noun while the other memory operations use singular.
Six tools is a well-scoped size for an agent memory server. Each tool represents a distinct core operation without unnecessary bloat or redundancy.
Per-agent memory has full CRUD coverage, but the shared namespace feature is incomplete: create_namespace and store_shared_memory exist with no way to retrieve, list, or delete shared memories. This creates a dead-end for agents trying to use shared memory.
Shared long-term memory vault for AI agents with 20 MCP tools.
Hosted agent memory: store, search, and recall facts across sessions from any MCP client.
Cross-tool persistent memory and context for AI assistants over MCP.
Persistent memory, knowledge graph, task management and more for AI agents via MCP.
