API

mem9 API reference

Use the mem9 API to provision a space, write or search memory, isolate sub-spaces with appId, import existing files, and inspect captured session messages. The examples use mem9.ai; self-hosted deployments use the same routes under your own base URL.

Prefer `v1alpha2` for day-to-day usage. `v1alpha1` stays available for key provisioning and tenant-scoped compatibility.

Base URL & authentication

Base URL

For mem9.ai, use `https://api.mem9.ai`. For self-hosting, replace it with your deployment origin; runtime memory calls live under `/v1alpha2/mem9s/...`.

API key header

Send the space API key in `X-API-Key` for `v1alpha2` runtime calls. mem9.ai keys can be provisioned with `POST /v1alpha1/mem9s`; self-hosted deployments use keys from their own control plane.

Agent identity

`X-Mnemo-Agent-Id` is optional. Use it to attribute writes and imports to a specific agent; request body `agent_id` takes precedence when both are present.

appId isolation

`appId` partitions memories and raw sessions under the same API key. Omit `appId` to search all appIds, pass a value for exact scope, or pass `null`/empty for default global memory.

Quick start

A minimal mem9.ai flow is: provision a key, export it into your shell, then create and search memories. For self-hosting, keep the same paths and replace the base URL.

  1. Provision a new API key with `POST /v1alpha1/mem9s`.
  2. Export that key as `API_KEY` and set `API=https://api.mem9.ai/v1alpha2/mem9s`.
  3. Create a memory with `POST /memories`. Add `appId` when one API key should hold separate app-specific memory pools.
  4. Search it back with `GET /memories?q=...`. Omit `appId` to search all appIds, or pass one appId to isolate the result set.

Provision key

curl -sX POST https://api.mem9.ai/v1alpha1/mem9s

Export env vars

export API_KEY="your-api-key"
export API="https://api.mem9.ai/v1alpha2/mem9s"

Create memory

curl -sX POST "$API/memories" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-Mnemo-Agent-Id: openclaw-main" \
  -d '{"appId":"docs","content":"Project uses PostgreSQL 15","tags":["tech","database"],"metadata":{"source":"setup-note"}}'

Search memories

curl -s -H "X-API-Key: $API_KEY" "$API/memories?q=postgres&appId=docs&limit=5"

Provisioning

Create the initial key you will reuse for mem9.ai API access.

POST /v1alpha1/mem9s

Provision a new mem9 API key.

No auth or request body is required. The mem9.ai service returns `201` with an `id` field, and that `id` is the key you store and reuse.

Response Body

id Required
The newly provisioned mem9 API key / space identifier.

Examples

Provision key

curl -sX POST https://api.mem9.ai/v1alpha1/mem9s

Key Status

Validate whether a Space key or Space Chain key is currently usable before making runtime calls.

GET /v1alpha2/status

Check API key status.

Send either a normal mem9 Space key or a Space Chain key in `X-API-Key`. The response is `active` or `inactive`; unknown keys return `404`.

Headers

X-API-Key Required
Space API key or Space Chain API key.

Response Body

status Required
`active` when the key can be used, otherwise `inactive`.

Examples

Check Space key

curl -s -H "X-API-Key: $API_KEY" https://api.mem9.ai/v1alpha2/status

Check Space Chain key

curl -s -H "X-API-Key: $CHAIN_API_KEY" https://api.mem9.ai/v1alpha2/status

Memories

Create, search, read, update, and delete stored memories in your mem9 space. The optional `appId` field lets one API key host multiple isolated application sub-spaces.

POST /v1alpha2/mem9s/memories

Create a memory or ingest messages.

Use `content` for direct writes or `messages` for ingest-driven writes. Do not send both in the same request. `appId` is optional; omitted, null, empty, and whitespace values are stored as the default/global appId.

Headers

X-API-Key Required
mem9 API key for your space.
Content-Type Required
Set to `application/json` for JSON request bodies.
X-Mnemo-Agent-Id
Optional agent identity header for attribution.

Body

content
Plain memory content for direct writes. Required when `messages` is absent.
messages
Conversation messages for ingest-based writes. Required when `content` is absent.
appId
Optional application isolation id, max 100 characters. Omitted, null, empty, or whitespace values write to the default/global appId; non-empty values are trimmed and stored exactly.
memory_type
Only accepted with `content` writes. Use `insight` or `pinned`; defaults to `insight`.
agent_id
Optional agent id to store with the write.
session_id
Optional session id for ingest or attribution.
tags
Optional string tags stored on the memory.
metadata
Optional JSON metadata payload.
mode
Ingest mode such as `smart` or `raw` when using `messages`.
sync
When true, wait for completion before returning.
disableSessionSave
Message ingest only. When true, skip raw session persistence and only extract/reconcile facts.

Response Body

status Required
Handler result such as `ok` or `accepted`.

Examples

Create memory

curl -sX POST "$API/memories" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-Mnemo-Agent-Id: openclaw-main" \
  -d '{"appId":"docs","content":"Project uses PostgreSQL 15","tags":["tech","database"],"metadata":{"source":"setup-note"}}'

Smart ingest

curl -sX POST "$API/memories" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "X-Mnemo-Agent-Id: openclaw-main" \
  -d '{"appId":"docs","session_id":"ses-001","mode":"smart","sync":true,"messages":[{"role":"user","content":"We use PostgreSQL 15"},{"role":"assistant","content":"Noted."}]}'
GET /v1alpha2/mem9s/memories

List or search memories.

When `q` is present, the handler runs recall search by default. Use `search_mode=keyword` for direct content substring matching. `appId` has three-state query semantics: omit it to search all appIds, pass a non-empty value for exact isolation, or pass `appId=null` / `appId=` for the default/global appId.

Headers

X-API-Key Required
mem9 API key for your space.
X-Mnemo-Agent-Id
Optional agent identity header for attribution.

Query Params

q
Search query. Omit to list memories by filters.
search_mode
Optional search behavior. Use `keyword` for direct content substring matching in list UIs; omit it for the default recall-style search.
tags
Comma-separated tag filter.
source
Filter by stored source value.
state
Filter by lifecycle state such as `active` or `archived`.
memory_type
Filter by `insight`, `pinned`, or `session`.
agent_id
Filter by agent id.
session_id
Filter by session id.
appId
Optional appId filter. Omit to search all appIds, pass a value for exact isolation, or use `appId=null` / `appId=` for default/global.
limit
Page size. The handler caps large values.
offset
Offset for pagination.
sort_by
Sort field used when listing memories, such as `updated_at`.
sort_dir
Sort direction, `asc` or `desc`.
scanAll
Space Chain keys only. When true, recall searches every node and globally reranks the merged facts.

Response Body

memories Required
Array of memory objects for the current page.
total Required
Total matched rows before pagination.
limit Required
Applied page size.
offset Required
Applied page offset.

Examples

Search memories

curl -s -H "X-API-Key: $API_KEY" "$API/memories?q=postgres&appId=docs&limit=5"

Filter by tags / source

curl -s -H "X-API-Key: $API_KEY" "$API/memories?tags=tech&source=openclaw-main&appId=null&limit=10"

Direct content keyword search

curl -s -H "X-API-Key: $API_KEY" "$API/memories?q=postgres&search_mode=keyword&appId=docs&limit=10&sort_by=updated_at&sort_dir=desc"
GET /v1alpha2/mem9s/memories/{id}

Read one memory by id.

Fetch a single stored memory object from the mem9 API.

Headers

X-API-Key Required
mem9 API key for your space.
X-Mnemo-Agent-Id
Optional agent identity header for attribution.

Response Body

id Required
Memory id.
content Required
Stored memory content.
memory_type Required
Memory type such as `insight`, `pinned`, or `session`.
appId
Application isolation id. Empty string means default/global.
source
Stored source value when present.
tags
String tag array when present.
metadata
Raw JSON metadata when present.
agent_id
Agent id associated with the memory when present.
session_id
Session id associated with the memory when present.
updated_by
Agent or actor that last updated the memory when present.
superseded_by
Replacement memory id when this memory has been superseded.
state Required
Lifecycle state.
version Required
Current integer version.
created_at Required
Creation timestamp.
updated_at Required
Last update timestamp.
score
Search relevance score when returned by search endpoints.
confidence
Recall confidence score when returned by recall-style search.
relative_age
Human-readable recency string populated for query-time search results.

Examples

Get memory

curl -s -H "X-API-Key: $API_KEY" "$API/memories/{id}"
PUT /v1alpha2/mem9s/memories/{id}

Update one memory.

Update content, tags, or metadata. Send `If-Match` when you want optimistic version checks.

Headers

X-API-Key Required
mem9 API key for your space.
Content-Type Required
Set to `application/json` for JSON request bodies.
X-Mnemo-Agent-Id
Optional agent identity header for attribution.
If-Match
Optional version guard for optimistic updates.

Body

content
Updated memory content.
tags
Updated tag array.
metadata
Updated JSON metadata payload.

Response Body

id Required
Memory id.
content Required
Stored memory content.
memory_type Required
Memory type such as `insight`, `pinned`, or `session`.
appId
Application isolation id. Empty string means default/global.
source
Stored source value when present.
tags
String tag array when present.
metadata
Raw JSON metadata when present.
agent_id
Agent id associated with the memory when present.
session_id
Session id associated with the memory when present.
updated_by
Agent or actor that last updated the memory when present.
superseded_by
Replacement memory id when this memory has been superseded.
state Required
Lifecycle state.
version Required
Current integer version.
created_at Required
Creation timestamp.
updated_at Required
Last update timestamp.
score
Search relevance score when returned by search endpoints.
confidence
Recall confidence score when returned by recall-style search.
relative_age
Human-readable recency string populated for query-time search results.

Examples

Update memory

curl -sX PUT "$API/memories/{id}" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -H "If-Match: 3" \
  -d '{"content":"Project uses PostgreSQL 16","tags":["tech","database"]}'
DELETE /v1alpha2/mem9s/memories/{id}

Delete one memory.

Deletes the selected memory row and returns `204 No Content` on success.

Headers

X-API-Key Required
mem9 API key for your space.
X-Mnemo-Agent-Id
Optional agent identity header for attribution.

Examples

Delete memory

curl -sX DELETE -H "X-API-Key: $API_KEY" "$API/memories/{id}"
POST /v1alpha2/mem9s/memories/batch-delete

Delete multiple memories.

Deletes the provided memory ids in one request. When authenticated with a Space Chain key, the handler resolves each id to the node that owns it.

Headers

X-API-Key Required
mem9 API key for your space.
Content-Type Required
Set to `application/json` for JSON request bodies.
X-Mnemo-Agent-Id
Optional agent identity header for attribution.

Body

ids Required
Array of memory ids to delete.

Examples

Batch delete memories

curl -sX POST "$API/memories/batch-delete" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -d '{"ids":["memory-id-1","memory-id-2"]}'

Space Chains

Create and manage ordered chains of Spaces. Runtime memory endpoints accept a Space Chain key and search the chain in node order, or all nodes when `scanAll=true`.

POST /v1alpha2/space-chains

Create a Space Chain.

Creates a Space Chain and returns its first plaintext chain key once. Store `chain_api_key` securely; later list responses only expose masked or bound key records.

Headers

Content-Type Required
Set to `application/json` for JSON request bodies.

Body

name Required
Human-readable Space Chain name.
project_id
Optional project id for control-plane ownership.
description
Optional Space Chain description.
created_by_user_id
Optional user id for audit attribution.

Response Body

chain Required
Created Space Chain object.
chain_api_key Required
New plaintext Space Chain API key. Store it now.
binding_id Required
Identifier of the initial key binding.
key_prefix Required
Space Chain key prefix, currently `chain_`.
key_preview Required
Short masked preview of the new key.

Examples

Create Space Chain

curl -sX POST https://api.mem9.ai/v1alpha2/space-chains \
  -H "Content-Type: application/json" \
  -d '{"name":"Team Knowledge Chain","description":"Ordered recall across team spaces"}'

Export Space Chain env vars

export CHAIN_API_KEY="your-chain-api-key"
export API="https://api.mem9.ai/v1alpha2/mem9s"
export CHAIN_API="https://api.mem9.ai/v1alpha2/space-chains"
GET /v1alpha2/space-chains/by-key

Read the Space Chain for a key.

Looks up the active Space Chain associated with the `X-API-Key` chain key.

Headers

X-API-Key Required
Active Space Chain API key for this chain.

Response Body

id Required
Space Chain id.
project_id
Owning project id when present.
name Required
Space Chain name.
description
Space Chain description.
bindings
Key bindings when included.
nodes
Ordered node list when included.
created_at Required
Creation timestamp.
updated_at Required
Last update timestamp.

Examples

Get by key

curl -s -H "X-API-Key: $CHAIN_API_KEY" "$CHAIN_API/by-key"
GET /v1alpha2/space-chains/{chain_id}

Read one Space Chain.

Returns chain metadata, nodes, and bindings for a chain key authorized to manage this Space Chain.

Headers

X-API-Key Required
Active Space Chain API key for this chain.

Response Body

id Required
Space Chain id.
project_id
Owning project id when present.
name Required
Space Chain name.
description
Space Chain description.
bindings
Key bindings when included.
nodes
Ordered node list when included.
created_at Required
Creation timestamp.
updated_at Required
Last update timestamp.

Examples

Get Space Chain

curl -s -H "X-API-Key: $CHAIN_API_KEY" "$CHAIN_API/{chain_id}"
PATCH /v1alpha2/space-chains/{chain_id}

Update Space Chain details.

Updates the display name and description for a Space Chain.

Headers

X-API-Key Required
Active Space Chain API key for this chain.
Content-Type Required
Set to `application/json` for JSON request bodies.

Body

name Required
Updated Space Chain name.
description
Updated description.

Response Body

id Required
Space Chain id.
project_id
Owning project id when present.
name Required
Space Chain name.
description
Space Chain description.
bindings
Key bindings when included.
nodes
Ordered node list when included.
created_at Required
Creation timestamp.
updated_at Required
Last update timestamp.

Examples

Update Space Chain

curl -sX PATCH "$CHAIN_API/{chain_id}" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $CHAIN_API_KEY" \
  -d '{"name":"Team Knowledge Chain","description":"Updated description"}'
DELETE /v1alpha2/space-chains/{chain_id}

Delete a Space Chain.

Soft-deletes the Space Chain. A successful delete returns `204 No Content`.

Headers

X-API-Key Required
Active Space Chain API key for this chain.
Content-Type Required
Set to `application/json` for JSON request bodies.

Body

deleted_by_user_id
Optional user id for audit attribution.

Examples

Delete Space Chain

curl -sX DELETE "$CHAIN_API/{chain_id}" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $CHAIN_API_KEY" \
  -d '{"deleted_by_user_id":"user-123"}'
GET /v1alpha2/space-chains/{chain_id}/nodes

List Space Chain nodes.

Returns the ordered node list. Node positions are zero-based and define sequential recall order.

Headers

X-API-Key Required
Active Space Chain API key for this chain.

Response Body

nodes Required
Ordered node list. Positions are zero-based.

Examples

List nodes

curl -s -H "X-API-Key: $CHAIN_API_KEY" "$CHAIN_API/{chain_id}/nodes"
PUT /v1alpha2/space-chains/{chain_id}/nodes

Replace Space Chain nodes.

Replaces the entire ordered node list. Each node must reference a normal Space key / tenant id, not another Space Chain key.

Headers

X-API-Key Required
Active Space Chain API key for this chain.
Content-Type Required
Set to `application/json` for JSON request bodies.

Body

nodes Required
Ordered array of Space Chain node inputs.
nodes[].tenant_id Required
Space API key / tenant id for the node.
nodes[].external_space_id
Optional console Space id for display and sync.
nodes[].display_name
Optional display name for the node.

Response Body

nodes Required
Ordered node list. Positions are zero-based.

Examples

Replace nodes

curl -sX PUT "$CHAIN_API/{chain_id}/nodes" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $CHAIN_API_KEY" \
  -d '{"nodes":[{"tenant_id":"space_key_a","display_name":"Team"},{"tenant_id":"space_key_b","display_name":"Company"}]}'
GET /v1alpha2/space-chains/{chain_id}/bindings

List Space Chain key bindings.

Returns all key bindings visible to the management key for this Space Chain.

Headers

X-API-Key Required
Active Space Chain API key for this chain.

Response Body

bindings Required
Array of Space Chain API key bindings.

Examples

List bindings

curl -s -H "X-API-Key: $CHAIN_API_KEY" "$CHAIN_API/{chain_id}/bindings"
POST /v1alpha2/space-chains/{chain_id}/bindings

Create a Space Chain key binding.

Creates another chain key. Omit `chain_api_key` to let mem9 generate a key.

Headers

X-API-Key Required
Active Space Chain API key for this chain.
Content-Type Required
Set to `application/json` for JSON request bodies.

Body

chain_api_key
Optional caller-supplied key. Omit to generate one.
created_by_user_id
Optional user id for audit attribution.

Response Body

id Required
Binding id.
chain_id Required
Space Chain id.
chain_api_key Required
Plaintext key for newly created bindings.
disabled Required
Whether this key binding is disabled.
created_at Required
Creation timestamp.

Examples

Create binding

curl -sX POST "$CHAIN_API/{chain_id}/bindings" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $CHAIN_API_KEY" \
  -d '{}'
PATCH /v1alpha2/space-chains/{chain_id}/bindings/{binding_id}

Disable a Space Chain key binding.

Disables an active binding. The API rejects disabling the last active key for a chain.

Headers

X-API-Key Required
Active Space Chain API key for this chain.
Content-Type Required
Set to `application/json` for JSON request bodies.

Body

disabled Required
Must be `true`.
disabled_by_user_id
Optional user id for audit attribution.

Examples

Disable binding

curl -sX PATCH "$CHAIN_API/{chain_id}/bindings/{binding_id}" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $CHAIN_API_KEY" \
  -d '{"disabled":true,"disabled_by_user_id":"user-123"}'
GET /v1alpha2/mem9s/memories

Recall across a Space Chain.

Use the normal memory search endpoint with a Space Chain key. By default recall visits nodes in order and stops early on high confidence; pass `scanAll=true` to search every node and globally rerank.

Headers

X-API-Key Required
Active Space Chain API key for this chain.

Query Params

q
Search query. Omit to list memories by filters.
search_mode
Optional search behavior. Use `keyword` for direct content substring matching in list UIs; omit it for the default recall-style search.
tags
Comma-separated tag filter.
source
Filter by stored source value.
state
Filter by lifecycle state such as `active` or `archived`.
memory_type
Filter by `insight`, `pinned`, or `session`.
agent_id
Filter by agent id.
session_id
Filter by session id.
appId
Optional appId filter. Omit to search all appIds, pass a value for exact isolation, or use `appId=null` / `appId=` for default/global.
limit
Page size. The handler caps large values.
offset
Offset for pagination.
sort_by
Sort field used when listing memories, such as `updated_at`.
sort_dir
Sort direction, `asc` or `desc`.
scanAll
Space Chain keys only. When true, recall searches every node and globally reranks the merged facts.

Response Body

memories Required
Merged memories from the visited Space Chain nodes.
total Required
Matched rows before pagination after chain-level de-duplication.
limit Required
Applied page size.
offset Required
Applied page offset.

Examples

Recall with scanAll

curl -s -H "X-API-Key: $CHAIN_API_KEY" "$API/memories?q=postgres&scanAll=true&limit=10"

Imports

Upload memory or session files and poll their background task status. Imported memories and raw sessions can carry `appId` at the file, memory, or session level.

POST /v1alpha2/mem9s/imports

Create an import task.

Upload a file as `memory` or `session`. The handler queues asynchronous processing and returns a task id immediately.

Headers

X-API-Key Required
mem9 API key for your space.
Content-Type Required
Your HTTP client sends this as `multipart/form-data`.
X-Mnemo-Agent-Id
Optional agent identity header for attribution.

Body

file Required
Uploaded file payload.
file_type Required
Use `memory` or `session`.
agent_id
Optional agent id for attribution.
session_id
Required when uploading `session` files.
file.appId
Optional top-level appId inside JSON memory/session files.
file.memories[].appId
Optional per-memory appId override inside JSON memory files.
file.sessions[].appId
Optional per-session appId override inside JSON session files.

Response Body

id Required
Task id for polling.
status Required
Initial task status such as `pending`.

Examples

Import memory file

curl -sX POST "$API/imports" \
  -H "X-API-Key: $API_KEY" \
  -F "file=@memory.json" \
  -F "file_type=memory" \
  -F "agent_id=openclaw-main"

# memory.json may include:
# {"appId":"docs","memories":[{"content":"Project uses PostgreSQL 15","appId":"docs"}]}

Import session file

curl -sX POST "$API/imports" \
  -H "X-API-Key: $API_KEY" \
  -F "file=@session.json" \
  -F "file_type=session" \
  -F "session_id=ses-001" \
  -F "agent_id=openclaw-main"

# session.json may include:
# {"appId":"docs","session_id":"ses-001","messages":[{"role":"user","content":"..."}]}
GET /v1alpha2/mem9s/imports

List import tasks.

Return all import tasks visible in the current mem9 space.

Headers

X-API-Key Required
mem9 API key for your space.
X-Mnemo-Agent-Id
Optional agent identity header for attribution.

Response Body

status Required
Aggregate task status for the tenant.
tasks Required
Array of import task summaries.

Examples

List import tasks

curl -s -H "X-API-Key: $API_KEY" "$API/imports"
GET /v1alpha2/mem9s/imports/{id}

Read one import task.

Poll a single task until it becomes `done` or `failed`.

Headers

X-API-Key Required
mem9 API key for your space.
X-Mnemo-Agent-Id
Optional agent identity header for attribution.

Response Body

id Required
Task id.
file Required
Uploaded file name.
status Required
Task status.
total Required
Total chunk count.
done Required
Completed chunk count.
error
Error message when the task fails.

Examples

Get import task

curl -s -H "X-API-Key: $API_KEY" "$API/imports/{id}"

Session Messages

Inspect raw captured conversation rows that were stored during ingest. `appId` uses the same omitted / exact / default-global filtering behavior as memory search.

GET /v1alpha2/mem9s/session-messages

List session messages by session id.

Repeat `session_id` in the query string for each session you want to fetch. Use `limit_per_session` to cap rows per session. If different appIds reused the same session id, pass `appId` to prevent cross-app raw session mixing.

Headers

X-API-Key Required
mem9 API key for your space.
X-Mnemo-Agent-Id
Optional agent identity header for attribution.

Query Params

session_id Required
Repeat this query param for each session to fetch.
appId
Optional appId filter. Omit to fetch matching sessions across all appIds, or use `appId=null` / `appId=` for default/global.
limit_per_session
Optional per-session row limit.

Response Body

messages Required
Array of captured session message rows.
messages[].id Required
Session message row id.
messages[].session_id
Session id for the row.
messages[].agent_id
Agent id for the row when present.
messages[].appId
Application isolation id for each raw session row.
messages[].seq Required
Sequence number within the session.
messages[].role Required
Message role such as `user` or `assistant`.
messages[].content Required
Message content.
messages[].content_type Required
Content type for the captured message.
messages[].tags Required
Captured tags for the row.
messages[].state Required
Lifecycle state for the row.
messages[].created_at Required
Creation timestamp.
messages[].updated_at Required
Last update timestamp.
limit_per_session Required
Applied per-session limit.

Examples

Read session messages

curl -s -H "X-API-Key: $API_KEY" "$API/session-messages?session_id=ses-001&session_id=ses-002&appId=docs&limit_per_session=20"

Health & Compatibility

Use `/healthz` for liveness checks. Legacy tenant-scoped routes still exist under `/v1alpha1/mem9s/{tenantID}/...`, but most clients should prefer `v1alpha2` plus `X-API-Key`.

GET /healthz

Check service health.

Useful before onboarding or when debugging network reachability.

Response Body

status Required
Health status string. Hosted service returns `ok`.

Examples

Health check

curl -s https://api.mem9.ai/healthz
GET /versionz

Check server version metadata.

Returns runtime metadata that is useful for support and deployment verification.

Response Body

go_version Required
Go runtime version used by the server.
started_at Required
Server start timestamp.

Examples

Version check

curl -s https://api.mem9.ai/versionz

Next

Need the guided path instead?

If you are onboarding OpenClaw rather than building a direct integration, start from the public SKILL.md. Use the same API key later in Your Memory.

SKILL.md Your Memory GitHub