Documentation

Introduction

Quanta is an Azure-native AI context gateway with a long-term memoryAPI. You point your application's model base URL at the gateway to compress context and cut token cost with no code changes, and you use the memory API to recall across millions of tokens of history while sending only a small, relevant slice to the model.

Two surfaces, one key:

Quickstart

1. Create an account at /signup and verify your email. 2. Your API key (sk-rsh-…) is shown after verification and emailed to you. 3. Start calling the API — it works immediately on the free plan.

# 1. Ingest a conversation
curl -s https://quanta.ryshe.com/api/memory/ingest \
  -H "authorization: Bearer $QUANTA_KEY" \
  -H "content-type: application/json" \
  -d '{"title":"Project thread","messages":[
    {"role":"user","content":"The launch date is March 14, 2027."}
  ]}'
# -> { "conversationId": "conv_…", "chunks": 1, "sourceTokens": 12, ... }

# 2. Ask about it later — answered from memory, not the full transcript
curl -s https://quanta.ryshe.com/api/memory/query \
  -H "authorization: Bearer $QUANTA_KEY" \
  -H "content-type: application/json" \
  -d '{"conversationId":"conv_…","question":"When is the launch?"}'

Authentication

Every request authenticates with your account API key as a Bearer token. Keys start with sk-rsh- and are issued after email verification. Keep them secret; treat a key like a password.

authorization: Bearer sk-rsh-xxxxxxxxxxxxxxxxxxxxxxxx

Requests without a valid, verified key return 401. Each account's data is fully isolated — a key can only read and write its own conversations.

Gateway API

The gateway is OpenAI-compatible. Point your existing client at it by changing only the base URL; request and response shapes are unchanged. It compresses the prompt, forwards it to your model provider, streams the real response back, and reports the savings in response headers.

Chat completions

Send a standard chat-completions body. Provide your model-provider key in the x-provider-key header (it is forwarded, never stored). Omit a provider key to get a dry run — the compression report only, with nothing forwarded.

from openai import OpenAI

client = OpenAI(
    base_url="https://quanta.ryshe.com/api/v1",
    api_key="YOUR_PROVIDER_KEY",   # your own OpenAI/Azure key
    default_headers={"authorization": "Bearer $QUANTA_KEY"},
)
resp = client.chat.completions.create(
    model="gpt-5.5",
    messages=[{"role": "user", "content": "Summarize the quarterly report."}],
)

Savings headers

Every gateway response includes the token accounting for that call:

Memory API

The memory API stores conversations in a vector-backed store and reconstructs only the relevant context for each question, within a fixed token budget. See How memory works.

Ingest a conversation

Commit a transcript to memory synchronously. Accepts up to ~375k tokens (1.5M characters); for larger transcripts use the async endpoint below.

{
  "conversationId": "conv_ab12cd34",
  "chunks": 80,
  "sourceTokens": 1736,
  "facts": 12,
  "embedderLive": true
}

Ingest asynchronously (large transcripts)

For transcripts up to ~10M tokens. The POST returns a job id immediately and processing continues in the background; poll the GET endpoint for progress.

# start
{ "jobId": "job_…", "conversationId": "conv_…", "totalChunks": 3094, "status": "processing" }
# poll GET ?id=job_…
{ "status": "processing", "progress": 58.2, "processedChunks": 1800, "totalChunks": 3094 }
{ "status": "complete", "progress": 100, "facts": 41 }

Query memory

{
  "answer": "The launch date is March 14, 2027.",
  "grounded": true,
  "mode": "live",
  "naiveTokens": 50886,     // cost of stuffing the full transcript
  "promptTokens": 790,      // what the model actually saw
  "savedTokens": 50096,
  "savedPct": 98.4,
  "episodesUsed": 12, "factsUsed": 8, "recentUsed": 4
}

Retention eval

Measures recall: auto-generates needle questions from across the conversation, asks memory, and scores how many it recalled — your fidelity gate.

{
  "recallPct": 100,
  "recalled": 6, "total": 6,
  "avgAssembledTokens": 801, "avgSavedPct": 98.7,
  "results": [ { "question": "…", "expected": "…", "correct": true } ]
}

List & delete conversations

List your conversations with their footprint, delete one by id, or erase all of your memory (right to erasure). Deletes cascade to chunks, facts, and summaries.

Accounts & keys

Signup is self-serve and email-verified.

signup takes { email } and sends a verification link. Clicking it calls verify with the token, which mints and returns your key. usage (Bearer auth) returns your plan, keys, and month-to-date token usage and savings.

Plans, quotas & limits

Monthly quotas are enforced on tokens actually consumed (post-compression). When you exceed your plan, the API returns 402 until you upgrade or the month resets.

Rate limits

Per-account rate limits (token-bucket). Exceeding them returns 429 with a retry-after header.

Errors

Errors return JSON: { "error": "message" }.

Data & security

Quanta runs entirely on Microsoft Azure. Each account's data is tenant-isolated and enforced on every request. Secrets are held in Azure Key Vaultvia managed identity; data is encrypted at rest and in transit (TLS). You can delete any conversation or wipe your account's memory at any time. The full stack can also be deployed inside your own Azure subscription so data never leaves your tenant — contact us for the private-deployment option.

How memory works

You can't hold millions of tokens in a model's context window, so Quanta stores everything and reconstructs the relevant slice per question from four tiers, within your token budget:

An assembler ranks these by relevance and recency, de-duplicates, and trims to your budget — so the model sees a small, faithful context instead of the whole history. The retention eval lets you measure that the right things were kept.