### Manual MemClaw Installation with Python

Source: https://github.com/caura-ai/caura-memclaw/blob/main/AGENT-INSTALL.md

This option is for users who prefer not to use Docker. It requires Python 3.11+, PostgreSQL 16+ with pgvector, and involves cloning the repo, setting up a virtual environment, installing dependencies, configuring environment variables, creating the database, running migrations, and starting the server.

```bash
git clone https://github.com/caura-ai/caura-memclaw.git
cd caura-memclaw

python -m venv venv
source venv/bin/activate        # Linux/Mac
# venv\Scripts\activate         # Windows

pip install -r requirements.txt

cat > .env << 'EOF'
ENVIRONMENT=development
POSTGRES_HOST=127.0.0.1
POSTGRES_PORT=5432
POSTGRES_USER=memclaw
POSTGRES_PASSWORD=changeme
POSTGRES_DB=memclaw
POSTGRES_REQUIRE_SSL=false
IS_STANDALONE=true
EMBEDDING_PROVIDER=fake
ENTITY_EXTRACTION_PROVIDER=fake
USE_LLM_FOR_MEMORY_CREATION=false
CORS_ORIGINS=http://localhost:8000,http://localhost:3000
EOF

psql -U postgres -c "CREATE USER memclaw WITH PASSWORD 'changeme';"
psql -U postgres -c "CREATE DATABASE memclaw OWNER memclaw;"
psql -U memclaw -d memclaw -c "CREATE EXTENSION IF NOT EXISTS vector;"

alembic upgrade head

PYTHONPATH=core-api/src uvicorn core_api.app:app --host 0.0.0.0 --port 8000

# Verify (in another terminal)
curl http://localhost:8000/api/v1/health
# Expected: {"status":"ok","database":"connected",...}
```

--------------------------------

### Run Services Locally with Docker Compose

Source: https://github.com/caura-ai/caura-memclaw/blob/main/CONTRIBUTING.md

Start the necessary development services, including PostgreSQL, Redis, and the core API, using Docker Compose. This provides a quick way to get the development environment running.

```bash
docker compose -f docker-compose.dev.yml up -d
```

--------------------------------

### Install and Set Up Pre-commit Hook

Source: https://github.com/caura-ai/caura-memclaw/blob/main/CONTRIBUTING.md

Install the 'pre-commit' tool and set up the git hook. This ensures code formatting and linting checks are run automatically before each commit.

```bash
pip install pre-commit   # or: uv pip install pre-commit
pre-commit install
```

--------------------------------

### Install Usage Skill for Codex Only

Source: https://github.com/caura-ai/caura-memclaw/blob/main/static/docs/integration-guide.md

Install the usage skill specifically for Codex by appending the `agent=codex` query parameter to the installation URL.

```bash
curl -s "https://your-memclaw-instance.example.com/api/v1/install-skill?agent=codex" \
  -H "X-API-Key: mc_your_key" | bash
```

--------------------------------

### Clone and Start MemClaw with Docker

Source: https://github.com/caura-ai/caura-memclaw/blob/main/AGENT-INSTALL.md

Use this to quickly set up MemClaw with Docker Compose. It starts PostgreSQL, pgvector, Redis, and the MemClaw API. Verify the services are healthy and the API is responsive.

```bash
git clone https://github.com/caura-ai/caura-memclaw.git
cd caura-memclaw

docker compose up -d

docker compose ps   # all services should show "healthy"

curl http://localhost:8000/api/v1/health
# Expected: {"status":"ok","database":"connected",...}
```

--------------------------------

### Install MemClaw as OpenClaw Plugin (Self-Hosted)

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Install MemClaw as a plugin for a self-hosted OpenClaw stack. Ensure `MEMCLAW_KEY` is set to `standalone` if self-hosting.

```bash
export MEMCLAW_URL=http://localhost:8000  # self-hosted
export MEMCLAW_KEY=your-key                      # `standalone` works in self-hosted standalone mode
export MEMCLAW_FLEET=my-fleet

curl -sf -H "X-API-Key: $MEMCLAW_KEY" \
  "$MEMCLAW_URL/api/v1/install-plugin?fleet_id=$MEMCLAW_FLEET&api_url=$MEMCLAW_URL" | bash

openclaw gateway restart
```

--------------------------------

### Install Usage Skill for Claude Code Only

Source: https://github.com/caura-ai/caura-memclaw/blob/main/static/docs/integration-guide.md

Install the usage skill specifically for Claude Code by appending the `agent=claude-code` query parameter to the installation URL.

```bash
curl -s "https://your-memclaw-instance.example.com/api/v1/install-skill?agent=claude-code" \
  -H "X-API-Key: mc_your_key" | bash
```

--------------------------------

### Pull New Image and Start with Migration Opt-in

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Pulls the latest Docker image and starts the services with the MEMCLAW_RUN_DESTRUCTIVE_MIGRATIONS environment variable set to true to enable database migrations.

```bash
docker compose pull
MEMCLAW_RUN_DESTRUCTIVE_MIGRATIONS=true docker compose up -d
```

--------------------------------

### Clone Repository and Configure Environment

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Clone the project repository and copy the example environment file. Set your AI provider and API keys in the .env file.

```bash
git clone https://github.com/caura-ai/caura-memclaw.git
cd caura-memclaw
cp .env.example .env
```

```env
EMBEDDING_PROVIDER=openai
ENTITY_EXTRACTION_PROVIDER=openai
USE_LLM_FOR_MEMORY_CREATION=true
OPENAI_API_KEY=sk-...
```

--------------------------------

### Install MemClaw as OpenClaw Plugin (Managed)

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Install MemClaw as a plugin for a managed OpenClaw platform. Ensure `MEMCLAW_KEY` is set to `standalone` if self-hosting.

```bash
export MEMCLAW_URL=https://memclaw.net          # managed
export MEMCLAW_KEY=your-key                      # `standalone` works in self-hosted standalone mode
export MEMCLAW_FLEET=my-fleet

curl -sf -H "X-API-Key: $MEMCLAW_KEY" \
  "$MEMCLAW_URL/api/v1/install-plugin?fleet_id=$MEMCLAW_FLEET&api_url=$MEMCLAW_URL" | bash

openclaw gateway restart
```

--------------------------------

### Start Local Embedder Stack

Source: https://github.com/caura-ai/caura-memclaw/blob/main/docs/local-embedder.md

Bring up the Docker Compose stack with the 'embed-local' profile to start the TEI service and configure core-api to use it.

```bash
docker compose --profile embed-local up -d
```

--------------------------------

### Verify NVIDIA Container Toolkit Installation

Source: https://github.com/caura-ai/caura-memclaw/blob/main/docs/local-embedder.md

Run this command to verify that the nvidia-container-toolkit is correctly installed and configured on your host system. It should display the host's GPU information within the CUDA container.

```bash
docker run --rm --gpus all nvidia/cuda:12.4.0-base-ubuntu22.04 nvidia-smi
```

--------------------------------

### Example .env Configuration File

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

This file shows a reference for all available configuration options for Caura Memclaw. It is typically named .env.example.

```dotenv
# Full configuration reference
```

--------------------------------

### Minimal Manual Plugin Re-install

Source: https://github.com/caura-ai/caura-memclaw/blob/main/docs/plugin-upgrade.md

Use this command to perform a fresh install or an operator-driven re-install with explicit credentials. It downloads the plugin source, sets up the .env file, and builds the distribution.

```bash
curl -ks -X POST "$MEMCLAW_API_URL/api/v1/install-plugin" \
  -H "Content-Type: application/json" \
  -d '{ \
    "api_url":   "https://your-memclaw-server", \
    "api_key":   "mc_…", \
    "fleet_id":  "your-fleet", \
    "tenant_id": "your-tenant", \
    "node_name": "this-node" \
  }' | bash
```

--------------------------------

### Verify Skill Installation

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Check if the MemClaw skill is installed correctly for Claude Code or Codex.

```bash
ls -la ~/.claude/skills/memclaw/SKILL.md       # Claude Code
ls -la ~/.agents/skills/memclaw/SKILL.md       # Codex
```

--------------------------------

### Python mcp Library Example

Source: https://github.com/caura-ai/caura-memclaw/blob/main/docs/integration-without-plugin.md

Use the mcp library to interact with Memclaw services, including listing tools and calling them.

```python
import asyncio
from mcp.client.session import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async def main():
    headers = {"X-API-Key": "mc_..."}   # agent-scoped credential
    url = "https://memclaw.dev/mcp/"

    async with streamablehttp_client(url, headers=headers) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            tools = await session.list_tools()
            print([t.name for t in tools.tools])

            result = await session.call_tool(
                "memclaw_write",
                {"content": "First memory from the Python harness."},
            )
            print(result)

asyncio.run(main())
```

--------------------------------

### Install Memclaw Usage Skill

Source: https://github.com/caura-ai/caura-memclaw/blob/main/static/docs/integration-guide.md

Install the usage skill for Claude Code and Codex by running this curl command. The skill provides guidance on memory vs. doc search and other operational rules. Restart your agent after installation.

```bash
# Installs SKILL.md into ~/.claude/skills/memclaw/ (Claude Code)
# and/or ~/.agents/skills/memclaw/ (Codex).
curl -s "https://your-memclaw-instance.example.com/api/v1/install-skill" \
  -H "X-API-Key: mc_your_key" | bash
```

--------------------------------

### Start Docker Compose Stack

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Initiate the caura-memclaw services using Docker Compose. This command pulls necessary images and starts the containers in detached mode.

```bash
docker compose up -d
```

--------------------------------

### Install MemClaw Skill (Managed Platform)

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Installs the MemClaw skill for Claude Code and Codex using a one-liner curl command for the managed MemClaw platform.

```bash
curl -s "https://memclaw.net/api/v1/install-skill" | bash
```

--------------------------------

### Build MemClaw Plugin from Source

Source: https://github.com/caura-ai/caura-memclaw/blob/main/static/docs/integration-guide.md

Clone the repository, navigate to the plugin directory, install dependencies, and build the plugin. Requires Node.js v18+.

```bash
git clone https://github.com/caura-ai/caura-memclaw.git
cd caura-memclaw/plugin
npm install
npm run build            # emits plugin/dist/
```

--------------------------------

### Install MemClaw Skill (Self-hosted)

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Installs the MemClaw skill for Claude Code and Codex using a one-liner curl command for a self-hosted MCP server.

```bash
curl -s "http://localhost:8000/api/v1/install-skill" | bash
```

--------------------------------

### Install MemClaw Plugin on OpenClaw Gateway

Source: https://github.com/caura-ai/caura-memclaw/blob/main/static/docs/integration-guide.md

Copy the built plugin files to the OpenClaw plugins directory on the gateway machine.

```bash
# On the gateway machine
mkdir -p ~/.openclaw/plugins/memclaw
# Copy the built plugin from your build machine (or rebuild here):
scp -r plugin/dist plugin/package.json plugin/openclaw.plugin.json \
    user@gateway:~/.openclaw/plugins/memclaw/
```

--------------------------------

### Install OpenClaw Plugin for MemClaw

Source: https://github.com/caura-ai/caura-memclaw/blob/main/AGENT-INSTALL.md

Use this bash script to install the OpenClaw plugin for MemClaw. Set your MemClaw URL, API key, and fleet ID before running the curl command.

```bash
# Set your base URL and API key
MEMCLAW_URL=http://localhost:8000
MEMCLAW_KEY=YOUR_KEY_HERE      # admin key (Path 2) or shared gate key (Path 3)
MEMCLAW_FLEET=my-fleet

# Run the install script (API key in header, not query param)
curl -sf -H "X-API-Key: $MEMCLAW_KEY" "$MEMCLAW_URL/api/v1/install-plugin?fleet_id=$MEMCLAW_FLEET&api_url=$MEMCLAW_URL" | bash
```

--------------------------------

### Verify MemClaw Installation and Registration

Source: https://github.com/caura-ai/caura-memclaw/blob/main/static/docs/integration-guide.md

Check OpenClaw startup logs to confirm MemClaw registration, ContextEngine status, and successful smoke tests. The node should appear in the Fleet page shortly after.

```text
[memclaw] Auto-educated 20 workspace(s), SKILL.md in 20, TOOLS.md in 20, AGENTS.md in 20
[memclaw] ContextEngine 'memclaw' registered
[memclaw] Smoke test passed (score: 0.953)
```

--------------------------------

### Download and Inspect MemClaw Skill Script

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Downloads the MemClaw skill installation script for manual inspection before execution, recommended for automated agents. This script performs directory creation and downloads the skill file.

```bash
curl -s "http://localhost:8000/api/v1/install-skill" > /tmp/install-memclaw-skill.sh
less /tmp/install-memclaw-skill.sh      # review — it only does mkdir + curl + write
bash /tmp/install-memclaw-skill.sh
```

--------------------------------

### Verify Plugin Version

Source: https://github.com/caura-ai/caura-memclaw/blob/main/docs/plugin-upgrade.md

After the installer exits, use this command to confirm the new plugin version is present on disk. Note that the in-memory code will only reflect the new version after the next OpenClaw restart.

```bash
grep PLUGIN_VERSION $HOME/.openclaw/plugins/memclaw/dist/version.js
# → export const PLUGIN_VERSION = "<new version>";
```

--------------------------------

### Restart TEI Service with GPU Enabled

Source: https://github.com/caura-ai/caura-memclaw/blob/main/docs/local-embedder.md

Use this command to restart the TEI service, forcing a recreation of the container to apply the new GPU configuration. The first start may take longer due to model weight downloads.

```bash
docker compose --profile embed-local up -d --force-recreate tei
```

--------------------------------

### Clone Repository and Set Up Python Virtual Environment

Source: https://github.com/caura-ai/caura-memclaw/blob/main/CONTRIBUTING.md

Clone the MemClaw repository and set up a Python virtual environment using 'uv'. This is the initial step for local development.

```bash
git clone https://github.com/caura-ai/caura-memclaw.git
cd caura-memclaw
uv venv .venv
source .venv/bin/activate
uv pip install -e "core-api/[dev]" -e "core-storage-api/[dev]"
```

--------------------------------

### Restart OpenClaw Gateway

Source: https://github.com/caura-ai/caura-memclaw/blob/main/AGENT-INSTALL.md

Restarts the OpenClaw gateway service. This is necessary after installing the MemClaw plugin.

```bash
openclaw gateway restart    # or: systemctl --user restart openclaw-gateway
```

--------------------------------

### End-to-End Agent Provisioning and Usage

Source: https://github.com/caura-ai/caura-memclaw/blob/main/docs/integration-without-plugin.md

Provision an agent, verify its identity, and make a memory write using a single bash script.

```bash
TENANT_KEY=mc_...   # tenant-scoped credential
AGENT_ID="quote-agent-na"
FLEET_ID="na-sales"

# 1. Provision agent + Agent row + trust + fleet in one call.
RESP=$(curl -s -X POST https://memclaw.dev/api/v1/admin/agent-keys/provision \
  -H "X-API-Key: $TENANT_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"agent_id\":\"$AGENT_ID\",\"initial_trust\":1,\"initial_fleet\":\"$FLEET_ID\"}")
AGENT_KEY=$(echo "$RESP" | python3 -c "import json,sys; print(json.load(sys.stdin)['raw_key'])")
# AGENT_KEY is an mc_… agent-scoped credential.

# 2. Verify.
curl -s https://memclaw.dev/api/v1/whoami -H "X-API-Key: $AGENT_KEY"

# 3. Use.
curl -s https://memclaw.dev/api/v1/memories \
  -H "X-API-Key: $AGENT_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"tenant_id\":\"$TENANT_ID\",\"agent_id\":\"$AGENT_ID\",\"fleet_id\":\"$FLEET_ID\",\"content\":\"Hello world\"}"
```

--------------------------------

### Build Docker Images from Local Source

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Build the Docker images directly from your local source code instead of pulling pre-built images. Use this when iterating on code changes.

```bash
docker compose up --build --no-pull
```

--------------------------------

### Memclaw Batch Write Response

Source: https://github.com/caura-ai/caura-memclaw/blob/main/static/docs/integration-guide.md

This is an example of the response received after a successful batch write operation, indicating the number of items created, duplicates, and errors.

```json
{
  "created": 3,
  "duplicates": 0,
  "errors": 0,
  "results": [
    {"index": 0, "status": "created", "id": "..."},
    {"index": 1, "status": "created", "id": "..."},
    {"index": 2, "status": "created", "id": "..."}
  ],
  "bulk_ms": 450
}
```

--------------------------------

### Agent System Prompt with MemClaw Integration

Source: https://github.com/caura-ai/caura-memclaw/blob/main/static/docs/integration-guide.md

Integrate this into your agent's system prompt to enable access to MemClaw. It outlines the usage of various memclaw tools for recall, writing, and management, along with explanations of parameters and behaviors.

```text
You have access to MemClaw, a shared memory system used by all agents.

BEFORE starting any task:
- Use memclaw_recall for semantic + keyword search with graph expansion
- Set include_brief=true when you want a concise LLM-summarized paragraph
  instead of raw results
- Include fleet_id to scope to this fleet, omit for tenant-wide search
- Filter by status="active" to skip deleted/archived memories
- Use valid_at for point-in-time queries (OpenClaw plugin and REST API only)

AFTER completing work:
- Store findings with memclaw_write — just provide content
- For batch writes, pass items=[...] (up to 100) to the same tool — batches
  embeddings and enrichment for much lower latency than looped single writes
- Type, weight, status, title, summary, tags are auto-inferred by LLM
- Dates auto-extracted: "deadline March 30" → ts_valid_end
- Contradictions auto-detected: conflicting older memories marked outdated
- Long content (>2000 chars) is auto-chunked into atomic facts
- Set visibility: "scope_agent" (you only), "scope_team" (default), "scope_org" (all fleets)
- Optionally override memory_type, weight, status
- RDF triples (subject_entity_id, predicate, object_value) available via OpenClaw plugin and REST API

MANAGING EXISTING MEMORIES:
- Use memclaw_manage with op="update" to correct content or metadata
- Use memclaw_manage with op="transition" to change status
- Use memclaw_manage with op="delete" to soft-delete
- Use memclaw_manage with op="read" to inspect a single memory by id
- Only provide fields you want to change — others are preserved
- If content changes, embedding and entities are re-extracted automatically
- You can only modify your own memories unless you have admin trust level

STATUS LIFECYCLE:
- Use memclaw_manage op="transition" when things change
- confirmed (done), cancelled (abandoned), outdated (superseded)
- Search status="pending" for unresolved items

VISIBILITY & CROSS-FLEET:
- Default visibility is "scope_team" — shared within your fleet
- Set visibility: "scope_org" to share across all fleets in the organization
- Set visibility: "scope_agent" for agent-only notes
- Use fleet_ids in recall to query multiple fleets at once

ENTITIES & GRAPH:
- Auto-extracted from every write — no manual creation needed
- Fuzzy entity matching: "OpenAI" and "Open AI" are auto-merged (cosine similarity ≥ 0.85)
- Recall automatically expands through entity relations (up to 2 hops)
  Example: searching "Project Atlas" also finds memories about people who work on Atlas
- Use memclaw_entity_get for direct relationship and linked memory inspection

OUTCOME REPORTING (Karpathy Loop):
- After acting on recalled memories, report what happened with memclaw_evolve
- outcome_type: "success" / "failure" / "partial"; pass related_ids=[...]
- Successful recalls get reinforced; failures generate preventive rules
- Use memclaw_insights periodically to surface contradictions, stale
  knowledge, cross-agent divergence, and emerging patterns
```

--------------------------------

### Write a decision memory

Source: https://github.com/caura-ai/caura-memclaw/blob/main/static/docs/integration-guide.md

Utilize `memclaw_write` to store a decision made by an agent. This memory can be recalled later by other agents to provide context or guide future actions.

```json
{
  "tool": "memclaw_write",
  "parameters": {
    "content": "Customer X should be migrated to managed Postgres in Phase 2 due to high transaction volume."
  }
}
```

--------------------------------

### Run MemClaw Core API with Uvicorn

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Manually deploy the MemClaw core API service using Uvicorn. Ensure Python 3.12+, PostgreSQL 16+ with pgvector, and optionally Redis are set up.

```bash
uvicorn core_api.app:app --host 0.0.0.0 --port 8000 --workers 2
```

--------------------------------

### Example RDF Triple for Memory

Source: https://github.com/caura-ai/caura-memclaw/blob/main/static/docs/integration-guide.md

This JSON structure represents an RDF triple that can be attached to a memory. It allows for structured data representation, enabling features like contradiction detection.

```json
{
  "subject_entity_id": "c5d5ee20-...",
```

```json
  "predicate": "uses",
```

```json
  "object_value": "PostgreSQL 16"
}
```

--------------------------------

### Run All Tests with PostgreSQL

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Execute all MemClaw tests, excluding benchmarks. This requires a PostgreSQL database to be running.

```bash
docker compose up -d db
pytest tests/ -m "not benchmark"
```

--------------------------------

### Start Docker Compose Without Pulling Images

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Run Docker Compose using only locally cached images. This is useful for offline operation or when you want to ensure no external registry is accessed.

```bash
docker compose up --no-pull
```

--------------------------------

### Run Unit Tests

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Execute unit tests for MemClaw. This command does not require a database connection.

```bash
pytest tests/ -m "unit"
```

--------------------------------

### Original memory structure for contradiction detection

Source: https://github.com/caura-ai/caura-memclaw/blob/main/static/docs/integration-guide.md

This is an example of an existing memory structure that can be superseded by a new, contradicting memory. It includes fields like `subject_entity_id`, `predicate`, and `object_value` for RDF triple representation.

```json
{
  "id": "aaa-111",
  "content": "Sarah Chen lives in Tel Aviv, Israel",
  "subject_entity_id": "e663...",
  "predicate": "lives_in",
  "object_value": "Tel Aviv, Israel",
  "status": "active"
}
```

--------------------------------

### Get entity details and linked memories

Source: https://github.com/caura-ai/caura-memclaw/blob/main/static/docs/integration-guide.md

Use `memclaw_entity_get` to retrieve attributes, linked memories, and outgoing relations for a specific entity. This provides a comprehensive view of an entity's information within the memory system.

```json
{
  "tool": "memclaw_entity_get",
  "parameters": {
    "entity_id": "c5d5ee20-78a4-4dd0-b9ca-6a41809a6ca5"
  }
}
```

--------------------------------

### Configure Git for automatic sign-off

Source: https://github.com/caura-ai/caura-memclaw/blob/main/CONTRIBUTING.md

Set up Git globally to automatically include the sign-off trailer in all future commits, simplifying the DCO process.

```bash
git config --global format.signoff true
```

--------------------------------

### Enable GPU Resources in docker-compose.yml

Source: https://github.com/caura-ai/caura-memclaw/blob/main/docs/local-embedder.md

Uncomment or add this deploy block to your docker-compose.yml (or docker-compose.override.yml) to allocate GPU resources to the TEI service. This is crucial for enabling GPU acceleration.

```yaml
services:
  tei:
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
```

--------------------------------

### Identity-Preserving Manual Plugin Re-install

Source: https://github.com/caura-ai/caura-memclaw/blob/main/docs/plugin-upgrade.md

This script re-installs the plugin over an existing node, preserving per-node identity by reading the current .env file. It ensures audit logs and fleet stats remain intact.

```bash
ENV=$HOME/.openclaw/plugins/memclaw/.env
URL=$(grep    '^MEMCLAW_API_URL='    "$ENV" | cut -d= -f2-)
KEY=$(grep    '^MEMCLAW_API_KEY='    "$ENV" | cut -d= -f2-)
FLEET=$(grep  '^MEMCLAW_FLEET_ID='   "$ENV" | cut -d= -f2-)
TENANT=$(grep '^MEMCLAW_TENANT_ID='  "$ENV" | cut -d= -f2-)
NODE=$(grep   '^MEMCLAW_NODE_NAME='  "$ENV" | cut -d= -f2-)

curl -ks -X POST "$URL/api/v1/install-plugin" \
  -H "Content-Type: application/json" \
  -d "$(jq -nc \
        --arg u "$URL" \
        --arg k "$KEY" \
        --arg f "$FLEET" \
        --arg t "$TENANT" \
        --arg n "$NODE" \
        '{api_url:$u, api_key:$k, fleet_id:$f, tenant_id:$t, node_name:$n}')" | bash
```

--------------------------------

### Discover Skills using MemClaw

Source: https://github.com/caura-ai/caura-memclaw/blob/main/static/skills/memclaw/SKILL.md

Use memclaw_doc to search for skills by natural language query, browse by recency, or read the full content of a specific skill document.

```bash
memclaw_doc op=search collection=skills query=<natural language>
```

```bash
memclaw_doc op=query  collection=skills              # browse by recency
```

```bash
memclaw_doc op=read   collection=skills doc_id=<slug>  # full body
```

--------------------------------

### Run Latency Benchmarks

Source: https://github.com/caura-ai/caura-memclaw/blob/main/README.md

Execute latency tests for Caura Memclaw operations. Ensure you replace <admin-key> with your actual admin key and specify the correct URL.

```bash
python scripts/latency_test.py --url http://localhost:8000 --api-key <admin-key> --runs 20
```

--------------------------------

### Write and Search Memories with Local Embedder

Source: https://github.com/caura-ai/caura-memclaw/blob/main/docs/local-embedder.md

Perform a write and search operation to verify the local embedder is functioning correctly. These commands assume IS_STANDALONE=true and use a placeholder API key.

```bash
curl -fsS -X POST http://localhost:8000/api/v1/memories \
  -H "X-API-Key: standalone" -H "content-type: application/json" \
  -d '{"tenant_id":"default","content":"smoke check for local embedder"}'
```

```bash
curl -fsS -X POST http://localhost:8000/api/v1/search \
  -H "X-API-Key: standalone" -H "content-type: application/json" \
  -d '{"tenant_id":"default","query":"smoke check","top_k":5}'
```

--------------------------------

### Read a Skill

Source: https://github.com/caura-ai/caura-memclaw/blob/main/static/skills/memclaw/SKILL.md

Direct-MCP clients can consume skills using this command. No filesystem write or plugin runtime is required.

```shell
memclaw_doc op=read collection=skills doc_id=<slug>
```