NoSQL / document.
Elastic document and key-value stores for low-latency, high-throughput workloads.
Horizontally scalable document and key-value stores with single-digit-millisecond latency at any scale — for flexible schemas and throughput a single SQL node can't sustain.
- Category
- Databases
- Deployment
- Managed → air-gapped
- Governance
- IAM · encryption · audit
Single-digit-millisecond at any scale, flexible schema — and on the same platform as the model.
For user data, sessions, events and catalogs, a document/key-value store that partitions automatically and answers in single-digit milliseconds is the right tool, and Aether's does exactly that — billions of items, high write rates, flexible schema with no migrations, and global tables for local reads worldwide. What it adds over a standalone NoSQL service is location: it lives on the platform with your analytics and the model, so the operational data and the AI that acts on it aren't separated by a vendor boundary.
Elastic by default, global when you need it.
It partitions transparently as you grow, so you don't capacity-plan a sharding strategy up front, and global tables replicate for low-latency local reads and resilience. The data structures and access patterns you'd expect from a managed NoSQL store are all here — the difference is what's reachable from it.
Operational data the model can actually use.
When the document store, the lakehouse and the model are one platform, the user profile a request just read can be enriched by the model and written back, or streamed into analytics, without an export. Operational and analytical and AI workloads share governance and identity instead of each holding a copy. It deploys managed or air-gapped like the rest of the catalog.
Read a profile, enrich it with the model, and write it back — one platform, no export.
import { aether } from "@aether/sdk";
const users = aether.nosql.table("users");
const u = await users.get({ id });
u.segment = await aether.classify(u.activity, SEGMENTS); // model, on-platform
await users.put(u); // back in single-digit msThe classification happens on the same platform as the store, so enriching a record is a function call, not an export to an external model and a write-back pipeline.
Three steps to running.
Define a key and go; the store partitions automatically as you grow.
Single-digit-millisecond access at any scale, flexible schema.
Multi-region global tables for local reads and resilience.
NoSQL / document, in full.
Partition automatically to billions of items and high write rates.
Store documents and key-value data without migrations.
Single-digit-millisecond reads and writes at scale.
Multi-region replication for local reads and resilience.
Provision it in a few lines.
Every service is reachable from the same SDK, CLI and infrastructure-as-code — one identity, one bill, one audit trail across the whole catalog.
import { aether } from "@aether/sdk";
// Provision nosql / document and query it
const nosql_document = await aether.databases.create({
service: "nosql-document",
name: "app",
region: "us-1",
});
const rows = await nosql_document.query(`select * from events limit 10`);At a glance.
- Model
- Document + key-value
- Latency
- Single-digit ms
- Scale
- Billions of items
- Schema
- Flexible, no migrations
- Replication
- Global tables
Built for real work.
High-throughput user data
Session and profile stores
Event and catalog data
On one model, not stitched together.
The usual stack runs nosql / document in one product, the model in another and the data in a third — and the seams between them are the cost. Aether Cloud runs it on the same platform that serves the model, governs your identity and deploys into your boundary, with the rest of the catalog one hop away.
No stitching a vector DB to one place, a warehouse to another and a model to a third — nosql / document sits next to the rest of the catalog, one identity, one bill.
The provider that runs Aether runs your nosql / document — so the data and the model never leave the same governed boundary to talk to each other.
Need a capability that isn’t here yet? The model writes and deploys it into the same boundary — the catalog is a starting point, not a ceiling.
Good to know.
Elastic document and key-value storage at single-digit-ms latency — on the platform that runs your model and analytics.
Yes — automatic partitioning handles high write rates to billions of items.
Yes — global tables replicate for local reads and resilience.
Your boundary, your choice.
Pairs well with.
Managed Postgres-compatible SQL with HA, read replicas, backups and point-in-time restore.
Managed embeddings and similarity search at scale — the retrieval layer under grounded apps.
Purpose-built time-series storage for telemetry, metrics and sensor streams.
Sub-millisecond managed cache for sessions, hot data and rate limiting.
A property-graph database for relationships, knowledge graphs and path queries.
Columnar, separation-of-storage-and-compute warehouse for analytics at scale.
Run NoSQL / document on Aether Cloud.
Elastic document and key-value stores for low-latency, high-throughput workloads. Deployable managed, in your VPC, on-prem or fully air-gapped — talk to us about the configuration your workloads and your boundary require.