CONNECTORS

Memuron CLI

MCP covers the conversation. The CLI covers everything around it — pulling a folder into a space, running ingest from CI, and querying the graph without opening an editor. It talks to the hosted API; there is no local database to stand up.

Install

uv tool install memuron

zsh — ~/code/acme

❯

Install to first sync. The manifest lives in .memuron/sync-manifest.json, so re-runs only ship what changed.

Set up the CLI in 5 steps

No API keys to paste, no glue code — sign in once and your agent keeps the memory.

CLI5 steps · about 2 minutes

uv tool install memuron
Create a managed API key in the console
memuron config set with the key and base URL
memuron sync init on a folder
memuron sync run

Install and authenticate

1. Install

shell

# Install once — ships the memuron and memuron-mcp binaries
uv tool install memuron --reinstall --force
memuron --version

2. Point it at your org

Create a managed key on the console API Keys page. Unlike MCP, the CLI is built for unattended runs, so it uses a key rather than OAuth.

shell

export MEMURON_API_KEY="arth_sk_…"

memuron config set \
  --base-url https://api.memuron.com \
  --api-key "$MEMURON_API_KEY"

Config is written in plain text to ~/.config/memuron/config.json. On shared machines and in CI, pass --api-key per command or export MEMURON_API_KEY instead.

Folder sync

Sync is one-way: a local folder into a Memuron space. It never writes back to disk. Change detection is sha256 per file, so a re-run only ships what actually moved.

shell

# Create the manifest once
memuron sync init \
  --path ./docs \
  --space-ref space.work \
  --include '*.md'

# Preview, then ingest
memuron sync run --path ./docs --dry-run
memuron sync run --path ./docs

Manifest-backed

State lives in .memuron/sync-manifest.json beside the folder, so the identity of each document is stable across runs.

Key, not OAuth

Managed keys bind to your org and survive unattended runs — no browser round trip in a pipeline.

Dry run first

--dry-run reports exactly what would ingest, change, or be skipped before anything is written.

Manifest field	Role
`space_ref`	Target space — token, slug, UUID, or `/spaces/…` path.
`include` / `exclude`	Glob patterns. Defaults to `*.md`.
`files`	Per-file sha256, document id, and last sync status.
`max_file_bytes`	Skips oversized files. Defaults to 8 MiB.

Query from the shell

The same graph-filesystem language the MCP memuron_query tool uses, piped from your terminal. Run memuron space manual for the full operator list.

shell

memuron query \
  --cwd /spaces/space.work \
  --query 'rg "deploy preferences" | head 5 | select id,preview'

In CI

Nothing about the CLI assumes a human. Point it at a key from your secret store and it will keep a space in step with a repository on every merge.

workflow

# .github/workflows/memuron.yml
- name: Sync docs into Memuron
  env:
    MEMURON_API_KEY: ${{ secrets.MEMURON_API_KEY }}
  run: |
    uv tool install memuron
    memuron config set --base-url https://api.memuron.com --api-key "$MEMURON_API_KEY"
    memuron sync run --path ./docs

Command groups

Group	Purpose
`config set`	Write `~/.config/memuron/config.json`
`api-key`	Create, list, and revoke managed API keys
`space`	List, create, and update spaces; read the query manual
`query`	Graph-filesystem queries inside a space
`memory`, `node`, `document`, `graph`	CRUD and graph operations
`sync`	One-way local folder → remote space

Manifest internals and identity rules are covered on the Folder Sync page.

When something looks wrong

401 on every call. The managed key was revoked or never written — re-run memuron config set.
Files silently skipped. They exceed max_file_bytes or fall outside the include globs. A dry run names each one.
Sync re-ingests everything. The manifest was deleted or the folder moved. Re-run sync init at the new path.
Wrong space. Use sync add --overwrite to retarget an existing manifest instead of editing it by hand.