Agent memory for TypeScript & Python
Aether gives your AI agent persistent, per-user memory and document retrieval behind one API — with SDKs for TypeScript, Python, Go, and .NET. Store what your agent learns, recall what it needs by meaning, and ground every reply.
Why Aether: Agent memory plus document RAG — four SDKs, including first-party .NET.
01What is agent memory?
Agent memory is persistent storage that lets an AI agent remember information across sessions — user preferences, earlier conversations, and source documents — and recall the most relevant pieces at query time using semantic search. Without it, an agent loses information once its context window fills up or the session ends.
Aether is a memory layer for autonomous AI agents. It unifies vector search, document storage, and embeddings behind a single API, so the same store handles two jobs at once: per-user memory (facts about a user or agent, recalled by meaning) and document RAG (retrieval over the PDFs, transcripts, and pages your agent needs to cite).
02Add memory in five minutes
Install the SDK for your language, set one environment variable (AETHER_API_KEY), and use the Memory facade. Scope memory to a stable user or agent id; recall() returns the most relevant memories ranked by score.
pip install aether-ai # Python
npm install @aether-ai/sdk # TypeScript / Node
go get github.com/quintessence-group/aether-sdk-go # Go
dotnet add package AetherDb.Sdk # .NETimport { Memory } from "@aether-ai/sdk";
// Scope memory to a stable user or agent id.
const memory = new Memory("user-42", { apiKey: process.env.AETHER_API_KEY });
await memory.remember("Prefers concise weekly summaries");
const hits = await memory.recall("communication style", { k: 5 });
for (const hit of hits) {
console.log(hit.score, hit.text); // higher score = more relevant
}import os
from aether import Memory
# Scope memory to a stable user or agent id.
memory = Memory("user-42", api_key=os.environ["AETHER_API_KEY"])
memory.remember("Prefers concise weekly summaries")
for hit in memory.recall("communication style", k=5):
print(hit.score, hit.text) # higher score = more relevantRetrieve over your own documents
The same client does retrieval-augmented generation. Insert source text once, then retrieve() passages that are ready to drop into a prompt.
import { AetherClient } from "@aether-ai/sdk";
const client = new AetherClient({ apiKey: process.env.AETHER_API_KEY });
// Store source material once...
await client.insertText("Aether bundles vector search, storage, and embeddings.");
// ...then retrieve passages ready to drop into a prompt.
const passages = await client.retrieve("what does Aether bundle?", 5);Full guides: TypeScript quickstart, Python quickstart, and the concepts guide. Prefer to wire it into your editor? Give Claude & Cursor persistent memory in 5 minutes.
03Aether vs Mem0 vs Zep, for a TS or Python builder
| Capability | Aether | Mem0 | Zep |
|---|---|---|---|
| Official SDK languages | TypeScript, Python, Go, .NET | Python, TypeScript | Python, TypeScript, Go |
| First-party .NET SDK | Yes | No | No |
| Per-user memory (remember / recall) | Yes | Yes | Yes |
| Document RAG in the same store | Yes — PDF, DOCX, HTML | Limited (chat-first) | Limited (graph-first) |
| MCP server for coding agents | Yes | Yes (hosted) | Yes (Graphiti) |
| Pricing model | Flat-rate platform | Metered by operations | Metered by data volume |
| Self-host | Single binary | Python service + vector DB | Python + graph DB |
To be fair to the alternatives: Mem0 and Zep are excellent, well-funded memory layers with more mature memory abstractions — automatic fact extraction (Mem0) and a temporal knowledge graph (Zep) — and published benchmarks. Aether competes on a different axis: bundled infrastructure, language coverage, and document-first retrieval. If you want one platform, one bill, and the same store for memory and RAG across four languages, that is where Aether wins.
04Why teams choose Aether
One platform, one bill
Vector search, document storage, and embeddings are bundled behind a single API — not Mem0 plus a vector DB plus an embeddings provider, each on its own invoice.
Four SDKs, including .NET
First-party SDKs for TypeScript, Python, Go, and .NET. Mem0 stops at Python and TypeScript; Zep adds Go. Aether is the only one of the three with a first-party .NET SDK.
Document-first, not just chat
The same store that holds per-user memory also ingests PDFs, DOCX, and HTML for retrieval — so an agent remembers conversations and the source material behind them.
Self-host from one binary
Run Aether as a single binary with no external vector database to operate, or use managed hosting at aetherdb.ai. Flat-rate pricing means your agent fleet can scale without your bill scaling with it.
05Frequently asked questions
What is agent memory?
Agent memory is persistent storage that lets an AI agent remember information across sessions — user preferences, earlier conversations, and source documents — and recall the most relevant pieces at query time using semantic search. Without it, an agent loses information once its context window fills up or the session ends.
What does entity-scoped memory mean?
You create an Aether Memory for a stable entity ID, such as a user, customer, agent, or session. Remember and recall operations use that scope by default, so application code does not have to recreate an entity filter on every request. Your application still controls which entity ID and credentials each caller may use.
How is Aether different from a vector database?
A vector database stores embeddings and returns similar records. Aether uses vector retrieval underneath, then adds an entity-scoped remember and recall API, source-document storage, embeddings, and first-party SDKs. It is a memory layer with the database included, not a replacement for your agent runtime or application authorization.
How is Aether different from memory built into ChatGPT or Claude?
Built-in chat memory personalizes a provider's own chat product. Aether is developer infrastructure for memory inside your own agents and applications, where your code chooses the entity scope and source data. Aether does not copy or control a provider's built-in chat memory.
How is Aether priced?
Aether's published plans are monthly subscriptions with included capacity, not a single per-memory fee. Each plan lists allowances for documents, stored vectors, monthly queries, and storage; paid plans that support overages publish those unit rates on the pricing page.
Which SDKs does Aether support?
Aether ships first-party SDKs for Python, TypeScript, Go, and .NET, plus an MCP server so compatible agents can read and write memory.
How do I add memory to my AI agent?
Create an API key, then use the Memory facade: create a Memory with a stable entity ID, call remember to store a fact, and call recall to retrieve the most relevant memories ranked by score. The documentation has quickstarts for Python, TypeScript, Go, and .NET.
Can I self-host Aether?
Yes. Aether runs as a single binary with no external vector database to operate, and managed cloud hosting is available if you would rather not run the infrastructure yourself.
Give your agent a memory.
Start free with the TypeScript or Python SDK. One API for memory and document retrieval, one bill, sub-millisecond recall.