Skip to content
Contextely
Start

Start here

Quickstart

Two calls to a working retrieval with nothing connected, then the two steps that make it worth keeping. About five minutes, no sales call, and nothing you have to undo afterwards.

  1. 1

    Create an account and a key

    Sign up with an email address. The account is created on first sign-in and you are its owner, which means you hold every entitlement scope in it. Then create an API key under API keys, and tick “Let this key store memory”, because that permission is off by default. The key is shown once and stored only as a hash.

    Sign up
  2. 2

    Store something, and read it back

    No source to connect, nothing to configure, and no waiting for a sync. What you store is kept as written rather than summarised, and the terms retrieval matches on are worked out locally, so this costs nothing and is instant.

    # store it
curl -s https://www.contextely.com/api/v1/memory \
  -H "Authorization: Bearer ctx_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"text":"Northwind asked for net-60 terms. Priya is handling it."}'

# find it
curl -s https://www.contextely.com/api/v1/search \
  -H "Authorization: Bearer ctx_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"query":"northwind payment terms"}'
  3. 3

    Now scope one

    This is the part worth five minutes of your attention, because it is the part that is different. Store the same kind of thing with a scope on it, then search as somebody who does not hold that scope. You will not get a shorter answer or a redacted one. You will get nothing, because the object was multiplied by zero inside the ranking and left with the irrelevant results. Under People and scopes, give a colleague a grant and try it from both sides.

    curl -s https://www.contextely.com/api/v1/memory \
  -H "Authorization: Bearer ctx_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Payroll review is on the 14th. Budget signed off at 480k.",
    "scopes": ["finance"]
  }'

# Anyone without the finance grant now gets zero results for "payroll",
# not a redacted answer. It scored zero and left with the irrelevant ones.
  4. 4

    Connect a system of record, when memory is not enough

    Memory you typed goes out of date and nobody typed most of what your company knows. Under Sources, connect a read-only SQL query against Postgres, Supabase or Neon, or any MCP server you already run. Saving lists one record and reads that same record back, so a source that could never be refreshed fails here rather than silently three days later. Press Sync: each record is condensed into a memory object that carries its own freshness contract and can be expanded back to the full original.

  5. 5

    Decide who may reach the server itself

    A connected MCP server usually declares far more tools than the two used for reading. Under Actions, ask a source what it has, then grant a whole server at once by naming the scope its tools require. Reads become live calls an agent can make when memory does not hold the answer; everything else becomes a write action, scoped and held for a person before it runs.

6. Ask it from anywhere

Four doors, one room. Every one of these runs the same retrieval pipeline, applies the same entitlement scoring and returns the same freshness labels. Pick whichever fits where you are standing.

In the dashboard

A person, checking that it works

The Ask console at /app runs the same retrieval an agent runs, and shows the parts an ordinary search box hides: how many candidates were considered, how many were withheld on entitlement grounds, and what was refreshed. An owner or admin can also ask as another member, to check what that person would actually get.

Over MCP

Claude, Cursor, Zed, your own agent

Add the server to your MCP client config and restart it. The tools appear automatically; no schema to copy.

{
  "mcpServers": {
    "contextely": {
      "url": "https://www.contextely.com/api/mcp",
      "headers": { "Authorization": "Bearer ctx_sk_..." }
    }
  }
}

From the terminal

A person, a script, a cron job

One file, downloaded from this deployment. No package manager, no dependencies, nothing to trust beyond the file you just read. Save the key once and every later call is one line.

curl -fsSL https://www.contextely.com/cli.mjs -o contextely && chmod +x contextely

./contextely config set-key ctx_sk_...
./contextely search "acme renewal"
./contextely related <memory-id>   # walk to what it relates to
./contextely expand <memory-id>    # read the whole record from the source

Over HTTP

A backend service, a RAG pipeline, anything

One POST. The response is the same object the MCP tool returns, so a service and an agent cannot end up looking at different answers.

curl -s https://www.contextely.com/api/v1/search \
  -H "Authorization: Bearer ctx_sk_..." \
  -H "Content-Type: application/json" \
  -d '{"query":"acme renewal","limit":5}'

Reading the answer

Three fields decide whether to trust a result, and they are in every response on every surface.

freshness.state

fresh is inside its TTL. refreshed means it was past its TTL and was just re-read from the source. stale_refresh_failed means it could not be verified, and the attached warning says why. Treat the third as possibly out of date rather than as an answer.

entitlement.withheld_for_entitlement

Above zero means relevant context existed that this asker may not see. An agent that reports that honestly is more useful than one that answers confidently from half a picture.

citation_url

Where the fact came from. If the summary is not enough, call context_expand with the object id and get the full current record back over the same connector.

Where to go next