Remember

Ahura NoSQL

Document collections without the setup.

Structured records an agent can query. Create a collection, write JSON documents, declare the fields you look things up by, and ask questions with equality, ranges, prefixes and sorting. Indexes are kept consistent for you on every write, so results are always correct and there is no table design to get wrong.

What it does

Collections and documents
Schemaless JSON documents grouped into collections.
Managed indexes
Declare the fields you filter on. The platform keeps the indexes current.
Query by condition
Filter, sort and page without writing a database layer.
Consistent per partition
Every collection lives in one partition and moves with it.

An agent calls it like this

{ "tool": "nosql.query", "collection": "leads", "where": { "field": "status", "op": "eq", "value": "open" }, "sort": "desc", "limit": 50 }

Interactive simulation

Try Ahura NoSQL

Press Run to send the call. The dashboard shows what it would use in a partition. Simulated: nothing is actually executed.

ahura mcp · ptn_demo_7f3a

# Write a document. Indexes follow.

→ POST /mcp

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "nosql.put",
    "arguments": {
      "collection": "leads",
      "id": "l_204",
      "doc": {
        "name": "Acme Ltd",
        "status": "open",
        "score": 82
      }
    }
  }
}

# Ask for the open ones.

→ POST /mcp

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "nosql.query",
    "arguments": {
      "collection": "leads",
      "where": {
        "field": "status",
        "op": "eq",
        "value": "open"
      },
      "sort": "desc",
      "limit": 50
    }
  }
}

# Count by range.

→ POST /mcp

{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "tools/call",
  "params": {
    "name": "nosql.count",
    "arguments": {
      "collection": "leads",
      "where": {
        "field": "score",
        "op": "gte",
        "value": 70
      }
    }
  }
}

Ready. Press Run.

ptn_demo_7f3a

Partition · N. Virginia · created just now

Simulated

Activeus-eastRetention hold

days left

Run time

0.0s

0 calls

Size

2.3MB

0.00 ACU used

Services in this partition

NoSQL
0 calls · 0.00 ACU

Spend by service

Ledger

No usage yet.

Why it matters

Where Ahura NoSQL beats running a database.

Agents need structured records they can look up fast. A full database brings schema design, indexing, tuning and operations along with it.

A database you run

Pick an engine, size it, secure it and back it up.
Design tables and indexes up front, and migrate when the questions change.
Slow queries appear the first time someone filters on a field with no index.
Pay for capacity around the clock.

Ahura NoSQL

Create a collection with one call. No cluster, no schema.
Declare an index when you need one, even on existing data, with no downtime.
Queries must use an index, so a slow scan can never happen by accident.
Billed per call, plus storage for the documents and index entries you keep. Expire or delete data and the charge stops.

Correctness
Documents and indexes change together or not at all.
Concurrency
Version checks and atomic counters prevent lost updates.
Safety
Unindexed queries are refused with a helpful message.
Isolation
Every collection belongs to one partition.

NoSQL is deliberately lightweight. For joins, heavy analytics or free-text search, use a purpose-built service.

In depth

What Ahura NoSQL can do.

JSON documents in collections
Store any JSON, nested as deeply as you like. Collections live inside a partition and are created with a single call.
Managed indexes
Declare the fields you query on, as text, number, true/false or date and time. Ahura keeps every index current on each write.
Unique fields
Mark an index unique and a second document with the same value is refused. Useful for emails, external IDs and idempotency keys.
Nested and list fields
Index into nested objects with paths like address.city. Index a list and every element becomes searchable.
Precise queries
Match exactly, compare, take a range, or match a prefix. Sort either way and page through results with a cursor.
Safe by default
A query that does not use an indexed field is refused, with a message listing the fields you can use. Full scans are a deliberate, separate call.
Consistent indexes
A document and its indexes change together or not at all. A document never shows up under an index value it no longer holds.
Safe concurrent writes
Attach a version to an update and it only applies if nobody changed the document first. Create-if-absent and atomic counters make shared state safe.
Partial updates
Set or remove individual fields, increment numbers and append to lists without rewriting the whole document.
Indexes on live data
Add an index to a collection that already has documents. Ahura backfills it in the background and reports progress while queries keep working.
Batch reads
Fetch up to 100 documents by ID in one call, or select only the fields you need.
Counts and stats
Instant collection counts, counts for a filtered query, and size and index statistics.
Storage and calls are billed
You pay per call and for the space your documents and their index entries occupy. Every index adds stored entries, so index the fields you query and no more. Expire or delete data and the charge stops.

Querying

equals: Exact match on an indexed field
less than, at most, greater than, at least: Compare numbers, text and dates
between: A range, inclusive at both ends
begins with: Prefix match on text
sort and limit: Ascending or descending, up to 500 results per page, with a cursor for the next page
extra filters: Further conditions on non-indexed fields, applied to the results

Right tool for the job

Searching by meaning or free textAhura Search →
Following relationships between recordsAhura Graph →
Large files and binary dataAhura Store →
Fast, short-lived working stateAhura Memory →

Every call, listed

9 tools your agent can call. Each one is a standard MCP tool with a typed schema and a price shown in tools/list.

Collections and indexes

nosql.collection.create / list / get / drop: Create a collection with its indexes, inspect it or remove it with all its documents.
nosql.index.create / status / drop: Add or remove an index at any time and track the backfill.

Write

nosql.put: Create or replace a document, optionally only if absent or at a given version.
nosql.update: Change fields in place: set, unset, increment, append.
nosql.delete: Remove a document, optionally only at a given version.

Read

nosql.get / nosql.mget: Read one document, or up to 100 by ID.
nosql.query: Find documents by indexed field, with sort, paging and field selection.
nosql.scan: Walk a whole collection in order. An explicit choice, not a default.
nosql.count / nosql.stats: Counts and collection statistics.

Not included: joins, aggregations beyond counts, transactions across collections, and schema enforcement. Your agents validate their own documents.

Use cases with NoSQL

All use cases

and 12 more

Industries using Ahura NoSQL

Financial Services

Works with

Next: Ahura Graph

Ahura Memory

Fast working memory for agents.

Ahura Store

Persistent files and objects.

Ahura Graph

Relationships an agent can walk.

Ahura Search

High performance vector/embedding search

Partitions

Where this service's data lives and how it freezes.

Ahura NoSQL

What it does

An agent calls it like this

Try Ahura NoSQL

Where Ahura NoSQL beats running a database.

A database you run

Ahura NoSQL

What Ahura NoSQL can do.

JSON documents in collections

Managed indexes

Unique fields

Nested and list fields

Precise queries

Safe by default

Consistent indexes

Safe concurrent writes

Partial updates

Indexes on live data

Batch reads

Counts and stats

Storage and calls are billed

Querying

Right tool for the job

Every call, listed

Collections and indexes

Write

Read

Use cases with NoSQL

Industries using Ahura NoSQL

Works with