Nowledge Mem CLI

pip install nmem-cli

# or with uv
uv pip install nmem-cli

# on Fedora / RPM-based Linux, use the community-maintained COPR package
sudo dnf copr enable abn/nowledge-mem
sudo dnf install nowledge-mem-cli

# on Arch Linux, use the community-maintained AUR package
yay -S nmem-cli
# or: paru -S nmem-cli

# or run without installing
uvx --from nmem-cli nmem --help

nmem status                              # Check connection
nmem ask "What did we decide about deployment?"
nmem ask "What changed?" --space work --ephemeral
nmem m search "project notes"           # Search memories
nmem m search "project notes" --space work
nmem m add "Key insight" --title "Learning"
nmem wm                                  # Read today's Working Memory
nmem wm --space work                     # Read Working Memory for one space
nmem spaces                              # List known spaces
nmem f --days 1                          # Today's activity
nmem g expand <memory-id>               # Explore graph connections
nmem tui                                 # Interactive terminal UI

nmem ask "What did we decide about the authentication migration?"
nmem ask "Summarize the evidence" --space "Research"
nmem ask "Is this documented anywhere?" --ephemeral
nmem --json ask "Which sources support this decision?"

nmem m list                   # Recent 10 memories
nmem m list -n 50             # List 50
nmem m list --importance-min 0.7  # Minimum importance filter

nmem m search "authentication patterns"
nmem m search "authentication patterns" --space work
nmem m search "API design" --importance 0.8
nmem m search "deploy" -l devops -l backend    # Filter by labels (AND)
nmem m search "renewal" --metadata customer=acme --metadata purpose=contract-review
nmem m search "sprint" --mode deep             # Graph + LLM-enhanced results
nmem m search "old deployment notes" --include-history

nmem m search "database decision" --event-from 2025-01 --event-to 2025-06
nmem m search "meeting notes" --recorded-from 2026-01-01

nmem m add "We chose PostgreSQL for task events"
nmem m add "Prefer functional components in React" \
  --title "Frontend conventions" \
  --unit-type preference \
  --importance 0.8 \
  -l frontend -l react

# Record when something actually happened (bi-temporal)
nmem m add "Decided to sunset the legacy API" \
  --unit-type decision \
  --event-start 2025-11 \
  --when past

# Preserve provenance when an agent distills a thread
nmem m add "The migration script must run after the schema check" \
  --unit-type learning \
  --source claude-code \
  --source-thread thread_abc \
  --source-msg msg_042

nmem m reclassify-types
nmem m reclassify-types --target-type procedure
nmem m reclassify-types --unit-type learning --unit-type decision --target-type procedure
nmem --json m reclassify-types --target-type procedure --wait
nmem m reclassify-types --apply --target-type procedure --limit 50

nmem m show <id>

nmem m update <id> --title "New title"
nmem m update <id> --importance 0.9
nmem m update <id> --content "Updated content"

nmem m deprecate mem_old --reason "The API changed"
nmem m supersede mem_old mem_new --reason "The newer deployment decision replaced it"

nmem m move <id> --space "Research Agent" --to-space "Archive"
nmem m move <id1> <id2> --space "Research Agent" --to-space "Archive" -f
nmem m move --all-in-space "Research Agent" --to-space "Archive" --dry-run
nmem m move --all-in-space "Research Agent" --to-space "Archive" -f

nmem m delete <id>
nmem m delete <id> -f          # Skip confirmation
nmem m delete <id1> <id2>      # Multiple IDs

nmem t list                             # Recent threads
nmem t list --source openclaw -n 20     # Recent OpenClaw threads only
nmem t list --offset 20 -n 20           # Next page of recent threads
nmem t search "architecture decisions"

nmem t show <id>
nmem t show <id> -n 50                 # Show up to 50 messages
nmem t show <id> --content-limit 200

# From text
nmem t create -t "Quick note" -c "Remember to review the API changes"

# From a file
nmem t create -t "Meeting notes" -f notes.md

# With structured messages
nmem t create -t "Chat session" \
  -m '[{"role":"user","content":"Hello"},{"role":"assistant","content":"Hi!"}]'

# With a stable ID (idempotent, safe to re-run)
nmem t create -t "OpenClaw session" --id "openclaw-abc123-session"

# Single message
nmem t append <id> -c "Follow-up note"

# Structured messages
nmem t append <id> \
  -m '[{"role":"user","content":"Question"},{"role":"assistant","content":"Answer"}]'

# With idempotency key (safe for retries / repeated hook fires)
nmem t append <id> \
  -m '[{"role":"user","content":"msg"}]' \
  --idempotency-key "oc-batch-session-001"

nmem t save --from claude-code         # Save Claude Code session
nmem t save --from grok                # Save Grok Build session
nmem t save --from codex               # Save Codex session
nmem t save --from codex -s "Summary"  # With session summary
nmem t save --from gemini-cli           # Save Gemini CLI session

nmem t delete <id>
nmem t delete <id> -f                  # Force
nmem t delete <id> --cascade           # Also delete associated memories

nmem t move <id> --space "Research Agent" --to-space "Archive"
nmem t move <id1> <id2> --space "Research Agent" --to-space "Archive" -f
nmem t move --all-in-space "Research Agent" --to-space "Archive" --dry-run
nmem t move --all-in-space "Research Agent" --to-space "Archive" -f

nmem fs capabilities --json                   # Discover roots, verbs, and limits
nmem fs ls /                                # Top-level branches
nmem fs cat /wiki/entities/PostgreSQL.entity.md
nmem fs cat /sources/research-report-abc123.pdf --line 120 --lines 80
nmem fs stat /memories/by-id/mem_abc.memory.md
nmem fs find /memories --label decisions --since 2026-01-01
nmem fs grep "JWT rotation" /memories
nmem fs grep "JWT rotation" /threads
nmem fs grep "JWT rotation" /sources
nmem fs grep -E "JWT|token" /threads --jsonl
nmem fs grep "JWT rotation" /threads --jsonl
nmem fs recall "session token strategy" --in /memories

nmem fs recall "why did we change token refresh?" --in /memories -k 5 --paths \
  | while IFS= read -r kfs_path; do nmem fs cat "$kfs_path"; done

nmem fs grep "JWT rotation" /threads --jsonl \
  | while IFS= read -r hit; do
      kfs_path=$(printf '%s' "$hit" | jq -r '.path')
      kfs_line=$(printf '%s' "$hit" | jq -r '.line')
      nmem fs cat "$kfs_path" --line "$kfs_line" --lines 12
    done

cat note.md | nmem fs write /memories/by-id/mem_abc.memory.md --stdin
nmem fs rm /memories/by-id/mem_abc.memory.md --force

nmem sources list                       # Sources in the current space
nmem sources add notes.pdf               # Import a file
nmem sources add https://example.com/doc # Capture a URL
nmem sources show src_abc123             # Metadata for one source
nmem sources delete src_abc123 -f        # Delete (non-interactive)

nmem sources search "meeting notes"
nmem sources search roadmap -n 10
nmem sources search "renewal terms" --label customer-acme
nmem sources list --label case-study

nmem sources read src_abc123                         # First 8000 characters
nmem sources read src_abc123 --offset 8000           # Next page
nmem sources read src_abc123 --limit 16000           # Larger window

nmem sources search-chunks src_abc123 "risk factors"
nmem sources search-chunks src_abc123 budget -n 3

nmem sources analyze src_abc123                                # All columns
nmem sources analyze src_abc123 --column price --column region # Specific columns

nmem wm                                # Today's Working Memory
nmem wm --space work                    # Working Memory for one space
nmem wm --date 2026-02-12             # Archived date
nmem wm history                        # List available archived dates

nmem wm edit -m "## Focus Areas\n- Ship v0.6"   # Set directly
nmem wm edit --space work -m "## Focus Areas\n- Ship v0.6"   # Set one space

# Replace a section
nmem wm patch --heading "## Focus Areas" --content "- Finish OpenClaw plugin release"

# Append to a section
nmem wm patch --heading "## Notes" --append "Reminder: deploy to staging tonight"

nmem spaces
nmem spaces create "Research Agent"
nmem spaces update "Research Agent" --instructions "Prefer research notes and hypotheses"
nmem spaces show "Research Agent"

nmem g expand <memory-id>
nmem g expand <memory-id> --depth 2   # Two hops out
nmem g expand <memory-id> -n 10       # Limit neighbors per hop

nmem g evolves <memory-id>

nmem f                                  # Last 7 days (high-signal events)
nmem f --days 1                         # Today only
nmem f --days 30                        # Last 30 days
nmem f --type crystal_created           # Only crystal synthesis events
nmem f --from 2026-02-10 --to 2026-02-14   # Exact date range
nmem f --all                            # Include low-signal background events
nmem f -n 50                            # Limit events (default: 100)

nmem c                                  # List communities
nmem c -n 20
nmem c show <community-id>              # Show community details (entities, memories)
nmem c detect                            # Trigger community detection (background)

nmem models status                      # Check current model status
nmem models download                    # Download the Search Index Model
nmem models reindex                     # Rebuild the search index

nmem config provider list
nmem config provider set openai --api-key sk-xxx --model gpt-4o
nmem config provider test

nmem config settings                               # Show all settings
nmem config settings set briefingHour 8            # Change morning briefing time

nmem config client show
nmem config client set url https://mem.example.com
nmem config client set api-key nmem_...
nmem config client clear api-key

nmem config mcp show --host claude-code
nmem config mcp show --host codex
nmem config mcp show --host cursor
nmem config mcp show --host gemini-cli
nmem config mcp show --host google-antigravity

nmem license status
nmem license activate <key> [email]   # Email is inferred from the license key when possible
nmem license renew                    # Refresh or renew this device's authorization
nmem license deactivate                 # Deactivate license on this device

# LAN / private network
export NMEM_API_URL=http://192.168.1.100:14242
nmem status

# Cloudflare tunnel (from desktop app: Settings → Access Anywhere)
export NMEM_API_URL=https://<your-url>
export NMEM_API_KEY=nmem_...
nmem m search "notes"

# One-off without env vars
nmem --api-url https://<your-url> status

nmem --json m search "API design" | jq '.memories[0].id'
nmem --json m add "Note" | jq -r '.id'
nmem --json f --days 1 | jq '.events[].title'

{
  "query": "API design",
  "total": 3,
  "search_mode": "fast_bm25_vector",
  "memories": [
    {
      "id": "abc123-def456-...",
      "title": "REST API versioning decision",
      "content": "We use /v1/ prefix for all public endpoints...",
      "score": 0.91,
      "relevance_reason": "Text Match (89%) + Semantic Match (73%) | decay[imp:high]",
      "importance": 0.8,
      "labels": ["architecture", "api"],
      "event_start": "2025-09",
      "temporal_context": "past",
      "source": "cli"
    }
  ]
}

{
  "events": [
    {
      "id": "evt-...",
      "event_type": "memory_created",
      "severity": "info",
      "title": "Memory or event title",
      "description": "Summary text...",
      "metadata": { "source": "claude", "unit_type": "fact" },
      "related_memory_ids": ["..."],
      "created_at": "2026-02-20T02:35:28+00:00"
    }
  ]
}

{
  "error": "api_error",
  "status_code": 404,
  "detail": "Memory not found"
}

nmem status
# nmem v0.6.2
#   status   ok
#   api      http://127.0.0.1:14242
#   database connected
#   search   ready

nmem stats
# Database Statistics
#   memories    83
#   threads     27
#   entities    248
#   labels      177
#   communities 32

nmem tasks
# Running
# ┌───────────────────────────────────────────────────────────┐
# │ WHEN   TASK                   LANE                   LAST │
# ╞═══════════════════════════════════════════════════════════╡
# │ now    Community detection    community_detection    -    │
# └───────────────────────────────────────────────────────────┘
#
# Scheduled once
# ┌──────────────────────────────────────────────────────────────────────────┐
# │ WHEN     TASK                            LANE                  LAST      │
# ╞══════════════════════════════════════════════════════════════════════════╡
# │ in 19h   Migration 0086 on staging — …   scheduled_follow_up   -         │
# └──────────────────────────────────────────────────────────────────────────┘
#
# Recurring
# ┌───────────────────────────────────────────────────────────────┐
# │ WHEN     TASK                           LANE             LAST │
# ╞═══════════════════════════════════════════════════════════════╡
# │ in 14h   Morning research digest        recurring_task   -    │
# │ paused   Friday knowledge sweep         recurring_task   -    │
# │ draft    Weekly investor update draft   recurring_task   -    │
# └───────────────────────────────────────────────────────────────┘

nmem --json tasks | jq '.recurring[].title'

# Search for context before responding
nmem --json m search "authentication flow" | jq '.memories[:3]'

# Save an insight
nmem m add "Rate limiting is per-user, not per-IP" \
  --unit-type learning --importance 0.8 -l backend

# Save a decision with when it was made
nmem m add "Chose Postgres over MySQL for task events" \
  --unit-type decision --event-start 2026-02 -l architecture

# Browse what was worked on last week
nmem --json f --days 7 | jq '.events[].title'

# Create a session thread backup
nmem t create -t "Debug session $(date +%Y%m%d)" \
  -m '[{"role":"user","content":"Investigate auth failures"},{"role":"assistant","content":"Found rate limit issue"}]'

nmem tui