RUNTIMENATIVE RUST
VAULT SYNCOBSIDIAN NATIVE
SERVINGMCP · OPENAPI 3.1
LICENSEAPACHE-2.0
OPEN-SOURCE RUST MEMORY LAYER FOR MULTI-MODEL AI

One shared memory across every agent, model, and session.

Stateless prompts forget the moment a window closes. Open-source and built natively in Rust, Aether turns Obsidian vaults and vector, cache, and graph stores into shared, privacy-bounded memory served over MCP and OpenAPI 3.1.

MEMORY SERVING // OBSIDIAN VAULT
Obsidian logo
SOURCE VAULT // OBSIDIANLocal Markdown Vault
[AETHER_HOT_PROFILE]
Memory/brand-voice.mdPinned via .aetherhot or aether_tier: hot
Aether SDK logo
AETHER ENGINE // :14771Deterministic amu_id sort · prefix_hash

Served in static_prefix on every recall for KV-cache reuse.

CursorClaudeChatGPTObsidian
01 // OBSIDIAN & MCP

Turn your Obsidian vault into memory every AI agent can use.

Aether indexes your notes locally and exposes them through an MCP server, so Claude, Cursor, and ChatGPT share one persistent, privacy-bounded memory.

INTEGRATION 01 // OBSIDIAN

Your vault is the memory

Point Aether at an Obsidian vault and every note becomes durable memory. Wikilinks turn into graph edges, frontmatter sets the tier, and the vault stays plain Markdown on your disk.

Obsidian
  • SOURCELOCAL MARKDOWN VAULT
  • PRIVACY.AETHERIGNORE · TIER: PRIVATE
INTEGRATION 02 // MCP SERVER

Expose memory to any AI agent

aether-mcp serves your vault over the Model Context Protocol. Agents call aether_recall to read, aether_stage_memory to write back to your Inbox, and aether_inspect_source to cite the note.

  • TOOLSRECALL · STAGE · INSPECT
  • ALSO SERVESOPENAPI 3.1
INTEGRATION 03 // AGENTS

One memory, every assistant

Claude, Cursor, and ChatGPT read from the same vault. Switch tools or models mid-project without re-explaining context, and keep private notes off every client.

ClaudeCursorChatGPT
  • CLIENTSMCP + OPENAPI
  • SCOPEPER-NOTE TIERS
02 // CONVERGENCE

From fragmented silos to continuous shared cognition.

Scroll through the memory lifecycle, or select any stage, to trace how raw multi-agent events are distilled into structured, conflict-free context.

STAGE 01 // MULTI-SURFACE CAPTURERUST ASYNC PIPELINE
SUPPORT THREADSIDE COPILOT LOGSAGENT TOOL RUNSAETHER RUST COREVECTOR + GRAPHREASONING LLMRANKED CONTEXTAUTONOMOUS OPSSTATEFUL GUARD
WRITE ONCE // RECALL ACROSS ANY MODEL PROVIDERgRPC & REST ENDPOINTS
03 // MEMORY PLANES

Three cognitive planes. Zero brittle prompt stuffing.

Vector similarity alone loses time and causality. Aether coordinates three synchronized representations across your storage backends.

PLANE 01 // TEMPORAL

Episodic Memory

Chronological event traces capture what happened, when, and in which session, preserving causal sequences and evolving project history.

  • STRUCTURETIME-ORDERED LOG
  • VERSIONINGIMMUTABLE LINEAGE
PLANE 02 // RELATIONAL

Semantic Knowledge Graph

Entities, relationships, and domain facts are distilled into a live property graph that resolves contradictions when facts change.

  • STRUCTURETYPED ENTITY EDGES
  • CONFLICTSAUTO-SUPERSEDED
PLANE 03 // BEHAVIORAL

Procedural Rules

Learned workflows, formatting standards, and user constraints stay attached to every agent invocation without repeating system instructions.

  • STRUCTURESCOPED DIRECTIVES
  • SCOPEUSER / TEAM / ORG
04 // TECH STACK

Built native on Rust. Pluggable across vector, embedded, cache & graph backends.

Aether compiles to a single memory-safe Rust binary with zero garbage-collection pauses and integrates directly with SQLite, Redis, turbopuffer, Qdrant, Chroma, pgvector, and Neo4j.

Rust official logo
CORE ENGINE // WRITTEN IN RUST

Memory-safe async execution without runtime pauses

Ingestion pipelines, entity consolidation workers, and hybrid RRF rankers execute natively on Rust's async runtime, routing episodic, semantic, and procedural queries across embedded files, hot memory caches, vector stores, and property graphs.

MEMORY MODELZERO-GC OWNERSHIP
CONCURRENCYTOKIO ASYNC + WORK-STEALING
WIRE PROTOCOLMCP · OPENAPI 3.1 · HTTP
PLUGGABLE RUST STORAGE TRAITS
Qdrant brand logo
Vector DB

Qdrant

Rust-native open-source HNSW vector search engine with single-stage payload filtering, scalar/binary quantization, and tenant-keyed collections.

LICENSEAPACHE 2.0
Chroma brand logo
Embedding DB

Chroma

Open-source AI-native embedding store combining dense and sparse vector similarity, BM25 full-text, regex, and metadata filtering across local or server setups.

LICENSEAPACHE 2.0
turbopuffer brand logo
Object Vector + BM25

turbopuffer

Object-storage-native vector and BM25 search engine tiered across S3, NVMe SSD, and RAM cache, integrated via open-source Rust bindings for massive multi-tenant namespaces.

STORAGE TIERS3 + NVMe / RAM CACHE
PostgreSQL pgvector brand logo
Postgres Vector

pgvector

Open-source PostgreSQL extension adding exact and approximate HNSW / IVFFlat kNN search directly alongside ACID relational schemas and SQL joins.

LICENSEPOSTGRESQL OSS
SQLite brand logo
Embedded Memory

SQLite · sqlite-vec

Zero-server single-file local memory combining SQLite WAL transactions, FTS5 lexical indexing, PersonalizedPageRank, and the Obsidian Vault MCP daemon (.aetherhot, .aetherignore, and OpenAPI 3.1).

LICENSEPUBLIC DOMAIN / MIT
Redis brand logo
In-Memory Store

Redis

Sub-millisecond working memory, short-term session buffers, TTL eviction, and real-time HNSW vector indexing for high-concurrency agent loops.

ROLEHOT CACHE + VECTOR
Neo4j brand logo
Graph DB

Neo4j

Native property-graph engine executing Cypher multi-hop entity traversal, contradiction resolution, and GraphRAG lineage queries across semantic memory.

LICENSEGPLV3 COMMUNITY
05 // PROTOCOL

Minimal surface area. Deterministic context assembly.

Select a sample scenario below to simulate how Aether retrieves and ranks cross-session memory nodes across vector and graph backends before your model generates a token.

SELECT SAMPLE MEMORY PROBE
NAMESPACE ISOLATION

Every memory node carries cryptographic tenant boundaries, source provenance, and TTL policies, allowing instant audit or selective forgetting across both vector and graph stores.

SAMPLE SIMULATION DATA
// Illustrative Rust SDK call — hybrid vector + graph recall
use muninn_aether_sdk::{AetherClient, Plane, RecallRequest};

let slice = client.recall(RecallRequest {
    namespace: "org_core_platform".into(),
    query: "Prepare migration brief for service auth".into(),
    planes: vec![Plane::Episodic, Plane::Semantic, Plane::Procedural],
}).await?;
[SEMANTIC · NEO4J] Auth tokens migrated from HS256 to EdDSA asymmetric signing in staging.REL 0.97
[EPISODIC · QDRANT] Code Agent flagged legacy refresh-cookie fallback in gateway-proxy (Session #482).REL 0.91
[PROCEDURAL · PGVECTOR] Architecture briefs require rollback checklist and zero-downtime phase gates.REL 0.88
06 // OPEN SOURCE

Open source from the core up. Clone and build today.

Explore the Rust SDK and memory engine on GitHub, wire Aether into SQLite, Redis, turbopuffer, Qdrant, Chroma, pgvector, or Neo4j, and self-host without vendor lock-in.

cargo build --release -p muninn-aether-vault --bin aether-mcp
./target/release/aether-mcp --init --vault /path/to/vault
./target/release/aether-mcp --vault /path/to/vault --http-addr 127.0.0.1:14771 --http-only