# Pass the key as a Bearer token
curl https://mnemonx.ai/api/v1/context \
  -H "Authorization: Bearer mnx_live_your_key_here"

curl https://mnemonx.ai/api/v1/memory \
  -H "Authorization: Bearer mxa_xxxxxxxxxxxxxxxxxxxx"

# Return all domains as structured JSON
curl https://mnemonx.ai/api/v1/memory \
  -H "Authorization: Bearer mnx_live_your_key"

# Return as plain text (ready for AI system prompt)
curl "https://mnemonx.ai/api/v1/memory?format=text" \
  -H "Authorization: Bearer mnx_live_your_key"

# Filter to specific domains
curl "https://mnemonx.ai/api/v1/memory?domains=tech,finance" \
  -H "Authorization: Bearer mnx_live_your_key"

{
  "domains": [
    {
      "id": "tech",
      "name": "Technology",
      "value": "Senior software engineer...",
      "context": "Expert in TypeScript, React, Next.js...",
      "order": 0
    }
  ],
  "wallet_name": "My Wallet",
  "total_domains": 12,
  "generated_at": "2026-06-13T12:00:00Z"
}

curl -X POST https://mnemonx.ai/api/v1/memory \
  -H "Authorization: Bearer mxa_xxxxxxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "domains": [
      {
        "id": "tech",
        "value": "Principal engineer with 10 years TypeScript experience",
        "context": "Currently building MnemonX — AI memory infrastructure"
      }
    ],
    "source": "my-ai-tool"
  }'

{
  "success": true,
  "updated": 1,
  "version_id": "vhst_xxxxxxxxxxxxxxxx",
  "timestamp": "2026-06-13T12:00:00Z"
}

# JSON (structured)
curl https://mnemonx.ai/api/v1/context \
  -H "Authorization: Bearer mnx_live_your_api_key"

# Plain text — paste directly into a system prompt
curl "https://mnemonx.ai/api/v1/context?format=text" \
  -H "Authorization: Bearer mnx_live_your_api_key"

[CONTEXT: MnemonX User Profile]
Name: Alex Chen
Technology: Principal engineer, 10y TypeScript, React, Node.js
Finance: Long-term investor, ETF focused, risk-averse
Languages: English (native), Mandarin (conversational)
[END CONTEXT]

GET https://mnemonx.ai/authorize
  ?client_id=YOUR_CLIENT_ID
  &redirect_uri=https://yourapp.com/callback
  &response_type=code
  &scope=memory.read memory.write
  &state=random_csrf_token

curl -X POST https://mnemonx.ai/api/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "authorization_code",
    "code": "AUTH_CODE_FROM_CALLBACK",
    "redirect_uri": "https://yourapp.com/callback",
    "client_id": "YOUR_CLIENT_ID",
    "client_secret": "YOUR_CLIENT_SECRET"
  }'

{
  "access_token":  "mxa_xxxxxxxxxxxxxxxxxxxx",
  "token_type":    "Bearer",
  "expires_in":    86400,
  "refresh_token": "mxr_xxxxxxxxxxxxxxxxxxxx",
  "scope":         "memory.read memory.write"
}

curl -X POST https://mnemonx.ai/api/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type":    "refresh_token",
    "refresh_token": "mxr_xxxxxxxxxxxxxxxxxxxx",
    "client_id":     "YOUR_CLIENT_ID",
    "client_secret": "YOUR_CLIENT_SECRET"
  }'

curl -X DELETE https://mnemonx.ai/api/oauth/revoke \
  -H "Authorization: Bearer mxa_xxxxxxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{ "token": "mxa_xxxxxxxxxxxxxxxxxxxx" }'

// Fetch user context and inject into a system prompt
const res = await fetch('https://mnemonx.ai/api/v1/context?format=text', {
  headers: { Authorization: `Bearer ${process.env.MNEMONX_API_KEY}` },
})
const context = await res.text()

const completion = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    { role: 'system', content: `You are a helpful assistant.\n\n${context}` },
    { role: 'user',   content: userMessage },
  ],
})

import os, requests

MNEMONX_KEY = os.environ["MNEMONX_API_KEY"]
BASE = "https://mnemonx.ai"

def get_context(format="text"):
    r = requests.get(
        f"{BASE}/api/v1/context",
        params={"format": format},
        headers={"Authorization": f"Bearer {MNEMONX_KEY}"},
    )
    r.raise_for_status()
    return r.text if format == "text" else r.json()

def update_domain(domain_id: str, value: str, source="my-app"):
    r = requests.post(
        f"{BASE}/api/v1/memory",
        json={"domains": [{"id": domain_id, "value": value}], "source": source},
        headers={"Authorization": f"Bearer {MNEMONX_KEY}"},
    )
    r.raise_for_status()
    return r.json()

BASE="https://mnemonx.ai"
KEY="mnx_live_your_key_here"

# Read all domains (JSON)
curl "$BASE/api/v1/memory" -H "Authorization: Bearer $KEY"

# Read as plain text (for system prompt)
curl "$BASE/api/v1/context?format=text" -H "Authorization: Bearer $KEY"

# Write a domain
curl -X POST "$BASE/api/v1/memory" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{"domains":[{"id":"tech","value":"Expert in TypeScript and React"}]}'

# Revoke an OAuth token
curl -X DELETE "$BASE/api/oauth/revoke" \
  -H "Authorization: Bearer mxa_xxxx" \
  -d '{"token":"mxa_xxxx"}'

POST https://mnemonx.ai/api/webhooks
Authorization: Bearer <oauth_access_token>
Content-Type: application/json

{
  "url":    "https://your-app.com/webhooks/mnemonx",
  "events": ["memory.update", "user.revoke"]
}

{
  "webhook": { "id": "wh_xxxx", "url": "https://your-app.com/webhooks/mnemonx", "events": ["memory.update", "user.revoke"], "is_active": true, "created_at": "2026-06-22T14:30:00Z" },
  "secret":  "whsec_...",
  "note":    "Save the secret now — it will not be shown again."
}

{
  "event":     "memory.update",
  "timestamp": "2026-06-22T14:30:00Z",
  "data": {
    "user_id":   "usr_xxxx",
    "domain_id": "coding",
    "source":    "api"
  }
}

// Node.js / TypeScript
import { createHmac } from 'crypto'

function verifyWebhook(
  payload: string,          // raw request body as string
  signature: string,        // X-MnemonX-Sig-256 header value
  secret: string
): boolean {
  const expected = createHmac('sha256', secret)
    .update(payload)
    .digest('hex')
  return `sha256=${expected}` === signature
}

// Express example
app.post('/webhooks/mnemonx', express.raw({ type: '*/*' }), (req, res) => {
  const sig = req.headers['x-mnemonx-sig-256'] as string
  if (!verifyWebhook(req.body.toString(), sig, process.env.WEBHOOK_SECRET!)) {
    return res.status(401).send('Invalid signature')
  }
  const event = JSON.parse(req.body)
  // handle event...
  res.sendStatus(200)
})