augmentationAI

Documentation

AugmentationAI gives you an OpenAI-compatible API for inference and a persistent memory store your tools can share. Inference uses an API key. Memory connects over MCP (Model Context Protocol): ChatGPT and the Claude app connect by signing in, and other tools use a separate memory-only key (aug_mem_). Automatic memory inside API requests is being built and is not switched on yet.

Get started

Quickstart

1. Sign in and choose the right key

Sign in to your account; memory access depends on your memory plan. Inference API keys (aug_sk_) and MCP keys are separate credentials. Review keys in Console → Settings → Keys. The signed-in account API creates a memory-only key with POST /api/account/keys and {"kind":"mcp_memory","name":"My MCP client"}. Its response includes a one_time_secret and the endpoint URL: store the secret securely when it is created; the key list does not return it again. Inference keys use the separate POST /api/account/inference/keys account route. These requests require your authenticated account; no key belongs in a URL.

2. Point your tool at the API

Any OpenAI-compatible SDK or tool: set the base URL and your API key. The key is sent as Authorization: Bearer.

from openai import OpenAI

client = OpenAI(
    base_url="https://augmentationai.com/v1",
    api_key="YOUR_API_KEY",
)

resp = client.chat.completions.create(
    model="YOUR_MODEL",   # a model id from GET /v1/models
    messages=[{"role": "user", "content": "Where did we leave the billing migration?"}],
)
print(resp.choices[0].message.content)

The same two settings work in any editor, terminal agent or script that lets you set a base URL and a key.

3. Connect memory

Add the memory endpoint to your MCP client (below). Your assistant then saves with save_memory and asks with recall_memory. Your memory goes with every tool you connect.

What you get

Inference OpenAI-compatible, routed to the models listed at /v1/models, streaming supported, billed from your wallet

Memory a persistent private store per customer, shared by every tool you connect: ChatGPT and the Claude app by signing in, other MCP clients with a memory-only key. Your assistant can save, search, open, correct, forget, restore, export and import memories

Harness context management that sends each task only what it needs; on the LoCoMo benchmark that used 87.9% fewer tokens than resending the conversation. Being rolled out in stages

Console usage, wallet, keys, playground, activity

Memory over MCP

ChatGPT and the Claude app: in the app, add a custom connector with the address https://augmentationai.com/mcp/memory and sign in with your account when asked. There is no key to paste.

Other tools: connect your MCP client to https://augmentationai.com/mcp/memory with its memory-only key (aug_mem_) in the Authorization: Bearer header. Use the URL returned when that key is created. Inference keys (aug_sk_) are for the inference API, not this MCP endpoint. Never put a key in a URL or a shared config file.

The full-box MCP endpoint is https://augmentationai.com/mcp/box, using a separate full-box key (aug_mcp_); it also exposes bot tools. The earlier /mcp endpoint uses a legacy PAT, not an inference key. An HTTP 200 response containing unauthorized: bad or missing PAT is an authentication failure, not a successful connection.

For Claude Code, replace the environment variable with your own securely stored memory-only key:

claude mcp add augmentationai --transport http https://augmentationai.com/mcp/memory \
  --header "Authorization: Bearer $AUG_MEMORY_KEY"

Memory MCP reference

JSON-RPC 2.0 over HTTPS. MCP clients start with initialize, then notifications/initialized. Discover tools with tools/list; invoke a tool using tools/call. Tool names are not top-level RPC methods.

POST https://augmentationai.com/mcp/memory
Authorization: Bearer $AUG_MEMORY_KEY
Content-Type: application/json
ToolArgumentsPurpose
save_memorycontent (required), namespace (optional; defaults to mcp), replaces (optional; the ID of an earlier memory this one corrects, or a list of up to 5), valid_until (optional; the last day this memory is valid, YYYY-MM-DD)Save a note into your own memory store. A correction marks the older memory as replaced in searches and puts the new one first; nothing is deleted
recall_memoryquery (required), k (a whole number from 1 to 200; default 50), since and until (optional; a day written YYYY-MM-DD, UTC, the day a memory was saved), namespace (optional; a namespace, or the start of one)Search your own saved notes. Results include each memory's ID
get_memory_recordid (required), cursor and page_bytes (optional; for long memories)Open one full memory by its ID. Search results are previews
forget_memoryid (required), reason (optional)Hide one memory from searches and reads. Nothing is deleted
restore_memoryid (required)Bring back a memory that was forgotten
get_memory_identitynoneShow which connection you are using. It never returns a key
export_memorycursor (optional; from the previous page), limit (optional; 1 to 50, default 20), namespace (optional)Export your memory, one page at a time, as portable envelopes: each note's own words, its topic, where it came from and when. Forgotten notes are never included, and anything that looks like a password or key is left out
import_memoryenvelopes (required; up to 50 per call)Bring memory in from an export of this account or another memory system. The reply lists what was saved, what was already there and what was refused. Imported notes are saved with today's date; credentials are never saved

Built-in memory actions

Along with the tools above, your assistant gets built-in memory actions that save tokens and time. It can do several memory steps in one request, for example search and then open the top results, and get back only what it needs. It can also run exact checks on your notes, such as finding duplicates, on our servers instead of working them out in the conversation. Your assistant finds these in its tool list and uses them on its own; there is nothing to set up.

Apps that show a server's prompts offer two for memory. "Use my memory" brings in what your memory holds about you and your work, and about one topic if you name it. "Save what matters" asks your assistant to save the lasting facts, decisions and preferences from the conversation.

For a read-only tool-discovery check:

curl https://augmentationai.com/mcp/memory \
  -H "Authorization: Bearer $AUG_MEMORY_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Save a memory (writes to your store)

{"jsonrpc":"2.0","id":2,"method":"tools/call",
 "params":{"name":"save_memory","arguments":{
   "namespace":"projects.example","content":"Our next milestone is the beta launch"}}}

Recall it

{"jsonrpc":"2.0","id":3,"method":"tools/call",
 "params":{"name":"recall_memory","arguments":{
   "query":"what is our next milestone","k":5}}}

Tool results use MCP content blocks; check isError as well as HTTP/JSON-RPC errors. A missing or invalid memory-only key returns HTTP 401. If memory access has expired, the memory-only endpoint returns HTTP 402; do not treat it as an empty store.

Namespaces

Dot-separated hierarchy: projects.law.cases, personal.health, taste.music. The dashboard wiki, graph and git tabs are all derived from your namespaces — write once, every view follows.

The Console

Console usage, wallet, keys, playground, activity

Wiki hierarchical notes over your store

Graph 3D memory graph browser

Git writes are committed to an internal history you can browse (best effort)

Export & deletion

You can ask your assistant to forget a memory. A forgotten memory is hidden from your assistant's searches and reads, and you can ask your assistant to restore it. Forgetting hides a memory; it does not erase it.

GET /wiki/export.ndjson (from the Console) downloads your store as NDJSON at any time. What it contains today: a first line labelling the export, then one line per node with id, namespace, title and content. The content field can be shorter than what you saved; edges and history are not included.

For a fuller copy, ask your assistant to export your memory. It returns your notes as portable envelopes, with each note's own words, topic, source and date, that another memory system can take in; a note too long for one page is listed by its ID so it can be opened in full. Your assistant can also import envelopes, from this account or another memory system, into your memory.

Deleting your account in Settings makes your store unreachable straight away and keeps it in a recoverable state for at least 30 days, then deletes it. Single memories cannot be deleted self-serve yet; email support@augmentationai.com. We do not train on your data and we do not sell personal data. See the Privacy Policy for the full retention schedule.

Pricing & limits

Monthly plans: Small CAD $39 (20 GB of memory), Mid CAD $99 (50 GB), Large CAD $199 (100 GB), and Done-for-you at CAD $499 for the first month (Large plus workspace setup and one 1-hour onboarding session), then CAD $199/month. Plans include usage; past the allowance, work continues pay as you go. Memory plans: CAD $29.99/month for 100 GB, or CAD $150/month Unlimited with a 350 GB fair-use limit. Model usage: billed per request from your balance; current rates are shown in your account. GPU clusters: coming soon; not available yet. Prepaid credit top-ups: packs of CAD $10, $25, $50 or $100 from your account; credit is added once the payment is verified. Purchased credits do not expire. All prices are in Canadian dollars (CAD); payments are processed by Square. See pricing.

The inference API allows 10 requests per second per key (bursts to 20). MCP keys can have a daily call limit and expiry set when they are created. Check error responses before retrying; keep keys secret.

FAQ

Which tools work?

Anything that can set an OpenAI-compatible base URL and key, and any MCP client that can reach a remote HTTPS server with a bearer token. ChatGPT and the Claude app connect to memory by signing in, with no key.

How does the memory work?

Our memory is proprietary and built in-house. It remembers your work and goes with you across harnesses, models and machines, cloud or local.

Which models can I reach?

400 models from the Augmentation AI model catalog, including Claude, GPT and Google models, listed at /v1/models and routed through our inference partners. You can also bring your own frontier subscription. The Privacy Policy explains where requests go.

Where does my data live?

In your own private store, kept separately from other customers' stores, on servers run by our hosting provider. We treat credentials and access as boundaries to keep right.

Can I leave?

Any time. Ask your assistant to export your memory, or download the NDJSON export (both described above), then delete your account in Settings.

Use of the service is subject to our Terms of Service and Privacy Policy.