Connect Tulimoa Memory

Create a memory in the dashboard and top it up by card, or let an agent pay for its own key with USDC. Then connect any MCP client and store your first memory.

Last updated Sep 30, 2026

Tulimoa Memory is an MCP server that speaks streamable HTTP. Every request carries a bearer token. Clients like claude.ai and ChatGPT get it by signing in with your Tulimoa account (OAuth). Everything else uses an API key, which you get in one of two ways: create a memory in the dashboard and top it up by card, or let an agent sign up on its own with a crypto payment.

https://memory.tulimoa.com/mcp

In claude.ai or ChatGPT: sign in#

1. Add a custom connector with the address https://memory.tulimoa.com/mcp. In ChatGPT this needs developer mode.
2. The client sends you to tulimoa.com. Sign in with your Tulimoa account.
3. Pick the memory the app may use, or create a new one (your first memory starts with $1 of credit). Decide whether it may see personal data in plain text, then allow access.

Calls cost the same $0.002 and come out of that memory's balance; top it up by card in the dashboard. The app stays signed in and renews its access on its own. Under Memory you see each connected app and can disconnect it at any time. API keys, agent sign-up and link codes keep working alongside.

Get an API key#

For people: open Memory in the dashboard and click "Create memory". You see the key once, together with the connect command, and start with $1 of credit. Keys from the dashboard may read personal data in plain text; untick that when you create another key for an agent that should only see placeholders. Top up by card under Billing, from $5. For agents without a person: keys are paid for in USDC on Base, using the x402 payment protocol. The wallet that pays becomes the account. Registration is the first top-up: the whole amount lands on your balance, and the minimum is $0.01.

1. Send POST /register without a payment. The server answers HTTP 402 with the payment requirements: amount, asset and recipient.
2. Sign an EIP-3009 transferWithAuthorization for exactly that amount, base64-encode the payment payload and send the same request again with it in the X-PAYMENT header.
3. The response (201) contains your api_key, starting with tlm_mem_. Store it right away: it is shown exactly once.

# 1. Ask for the payment requirements (answers HTTP 402)
curl -i -X POST "https://memory.tulimoa.com/register?amount_micro_usd=1000000"

# 2. Retry with the signed payment and an optional label for this agent
curl -X POST "https://memory.tulimoa.com/register?amount_micro_usd=1000000" \
  -H "X-PAYMENT: <base64 payment payload>" \
  -H "Content-Type: application/json" \
  -d '{"agent_label": "support-agent"}'

Amounts are in micro-USD, the atomic unit of USDC: 1000000 is $1.00, 10000 is the $0.01 minimum. Without amount_micro_usd the minimum is used. agent_label names the agent in the timeline, up to 120 characters. The machine-readable terms for agents live at /.well-known/x402.

Connect your client#

claude mcp add --transport http tulimoa-memory https://memory.tulimoa.com/mcp --header "Authorization: Bearer tlm_mem_..."

{
  "servers": {
    "tulimoa-memory": {
      "type": "http",
      "url": "https://memory.tulimoa.com/mcp",
      "headers": { "Authorization": "Bearer tlm_mem_..." }
    }
  }
}

Every MCP request needs the key, initialize and tools/list included. Only tool calls are billed. On connect the server hands your agent a short waking state: the current goal, the last checkpoint, open loops, warnings, the latest briefing headline, the remaining balance and the storage tier.

Store your first memory#

Today:        "Remember that our staging URL is https://staging.example.com"
              -> the agent calls tulimoa__remember

Next session: "What is our staging URL?"
              -> the agent calls tulimoa__recall and answers without searching

Right after writing, recall finds the memory among the raw experiences. After the first night it is part of the knowledge graph and comes back by association, together with what is related to it. More in Sleep, knowledge and the morning briefing.

Pay as you go or keep a balance#

• Pay per call. When the balance cannot cover a call, tools/call answers HTTP 402 with a challenge for exactly one call price. Your client pays that single call with an X-PAYMENT header from the account's wallet and the call goes through. No minimum, no balance needed.
• Keep a balance. POST /topup works like registration (from $0.01, no maximum) and saves the payment round trip on every call. Send your bearer key along, and the payment must come from the wallet bound to that key.

Prices, the storage fee, warnings and the daily cap are covered in Pricing and limits.

Watch it from the dashboard#

An agent can use and pay for its memory without a person. To see the balance and get warned before the storage fee runs out, link the memory to your Tulimoa account: the agent calls tulimoa__link_account (free) and gets a code like ABCD-2345, valid for 30 minutes. Enter it under Memory in the dashboard. Pass email or webhook_url to the tool to receive the warnings directly.

In the dashboard a person sees everything about the memory: knowledge and single entries, contradictions to review, personal data in the vault, keys, balance and briefings. Without an account, memory.tulimoa.com/briefing shows the last 14 morning briefings for free once you enter your key in the form; the key never becomes part of a URL.