Concepts Overview: Model-Free & Pieces-First
Aether separates storage durability and graph or vector retrieval from model inference. This section explains why the SDK stays model-free, why capabilities are exposed as independent functions and traits before MemoryManager, and how both the SDK pipeline and the Obsidian vault compiler move data.
Why Aether separates storage from inference models
Embedding models, entity extractors, and LLM routers change frequently and often run behind application-specific rate limits, privacy boundaries, or custom batching loops. When a memory framework hides model calls inside remember or recall, your application loses control over token cost, prompt formatting, and retry placement.
Aether stays model-free across the four SDK crates (muninn-aether-core, muninn-aether-cortex, muninn-aether-adapters, and muninn-aether-sdk). Your code calls its own embedder or extractor, then hands Aether plain structs (MemoryInput, Entity, Relation, RecallQuery). Even inside muninn-aether-vault, local embeddings default to zero-network HashedNgramEmbedder behind a swappable Embedder trait rather than bundling an LLM client.
Why pieces-first beats a sealed gateway
Early memory libraries act as a framework that calls your hooks at fixed points. That inversion of control breaks as soon as you need to reorder steps, skip a graph database, or run a custom reranker between vector search and prompt assembly.
Aether builds from small public pieces upward:
- Arguments instead of shared context. Every function takes explicit store trait references and plain data values (
&dyn VectorStore,&ProjectId,Vec<Candidate>). - No hidden background work. Nothing spawns timers or background tasks unless you call
Indexer::spawn, pass.background_indexing(...)toMemoryManager::builder, or setwatch_intervalonVaultConfig. - No private facade powers.
MemoryManagerdepends onmuninn-aether-cortexandmuninn-aether-adaptersthrough the same public API any caller sees.
The trade-off is a wider public API, which Aether keeps manageable by passing ordinary value types (MemoryItem, Candidate, Subgraph) between every stage.
Five-crate dependency structure
Each crate has one clear boundary and depends only downward.
muninn-aether-coreholds zero I/O. It defines validated IDs,DistanceMetric,FilterExpr, DTOs,AetherError, and theOutboundConnector,RecordStore,VectorStore, andGraphStoretraits.muninn-aether-corteximplementsIndexer,PersonalizedPageRank,graph_scores, andrecall::*functions against core traits.muninn-aether-adaptersimplementsInMemoryBackend,Batcher,Timeout,Resilient,Traced, thecontracttest suite, and feature-gated drivers (sqlite,redis,qdrant,pgvector,chroma,turbopuffer,neo4j).muninn-aether-sdkcomposesMemoryManagerand optional OpenTelemetry initialization (otel).muninn-aether-vaultembedsmuninn-aether-coreandmuninn-aether-cortexon top of a single-file SQLite WAL schema to compile Obsidian vaults, serve MCP and HTTP endpoints, sync Git team vaults, and warm GPU KV caches.
SDK write, sync, and recall pipeline
In the core SDK, RecordStore is the single durable write target, while VectorStore and GraphStore are derived indexes reconciled asynchronously or on demand.
Obsidian vault compiler pipeline
muninn-aether-vault adapts the same pattern to local Markdown files, replacing remote vector and graph services with a unified SQLite WAL database while keeping verbatim note text on disk.
Explore the deeper mechanics across the concept pages in this section: