SynapCores Memory for Openclaw

SynapCores Memory gives an OpenClaw agent private, self-hosted long-term memory that persists across restarts and retrieves facts by meaning.

synapcores
v0.7.0
Aug 19, 2026
0
157
0

Install & Download

1. ClawHub CLI

The fastest way to install a skill directly from the registry.

npx clawhub@latest install synapcores-memory

2. Manual Installation

Copy the skill folder to one of these locations

Global
~/.openclaw/skills/
Workspace
<project>/skills/

Priority: Workspace > Local > Bundled

3. Prompt Installation

Copy this prompt to OpenClaw to install it automatically.

Help me install synapcores-memory using Clawhub. If Clawhub is not installed, install it first (npm i -g clawhub).

Prefer to download?

Get the raw skill files in a ZIP archive.

What is SynapCores Memory?

SynapCores Memory is an Openclaw Skills integration that lets an agent store user-approved facts, recall them semantically, and permanently forget them on request. Memories are embedded inside the self-hosted SynapCores engine, so data remains on your machine without an external embedding API or third-party service in the request path.

The skill communicates with SynapCores through authenticated SQL-over-HTTP calls. It supports namespaces for separating people or projects, optional JSON metadata for filtering, similarity-ranked recall, and hard deletion. This makes Openclaw Skills more useful for assistants that need reliable context across sessions while preserving deployment and data-control boundaries.

SynapCores Memory Use Cases

  • Remember user preferences, such as food, communication style, schedules, or recurring choices.
  • Recall facts from earlier sessions when answering personal or project-specific questions.
  • Correct, retract, or permanently delete a previously stored memory.
  • Maintain separate memory namespaces for different people, teams, or projects.
  • Retrieve semantically related facts when the original wording differs from the user’s query.
  • Keep long-term agent context on a self-hosted database instead of relying on a hosted memory provider.
  • Use Openclaw Skills manually when memory is relevant, or pair the store with the SynapCores OpenClaw plugin for automated capture and recall.

How SynapCores Memory Works

  1. The agent identifies a memory intent, such as “remember this,” “what do you know about,” or “forget that.”
  2. The agent connects to the configured SynapCores gateway using SYNAPCORES_URL and the bearer token in SYNAPCORES_API_KEY.
  3. To store a fact, it executes MEMORY_STORE(namespace, content [, metadata]), which embeds the concise statement and writes it to the namespace-backed memory table.
  4. To recall information, it executes the table-valued MEMORY_RECALL(namespace, query [, top_k]) function, which returns IDs, content, cosine similarity, metadata, and creation timestamps ordered by relevance.
  5. The agent evaluates similarity scores before treating a result as reliable. Low scores across all results indicate that no relevant memory may exist.
  6. When the user requests deletion, the agent identifies the memory ID and executes MEMORY_FORGET(namespace, id), producing a hard delete result of true or false.
  7. The agent keeps facts short and self-contained, recalls before storing to reduce duplicates, and asks for consent before saving sensitive information.
  8. If the companion plugin is installed, the integration may use the newer CREATE MEMORY object or the legacy MEMORY_* functions, depending on gateway and plugin versions.

SynapCores Memory Setup

1. Run the SynapCores gateway

Start a persistent local gateway with a Docker volume:

docker run -d --name synapcores -p 8080:8080 \
  -v synapcores-data:/var/lib/synapcores \
  -e SYNAPCORES_TELEMETRY=off \
  ghcr.io/synapcores/community:latest

Retrieve the initial administrator login and API key:

docker logs synapcores 2>&1 | grep -A2 'ADMIN LOGIN'

2. Configure environment variables

export SYNAPCORES_API_KEY="aidb_..."
export SYNAPCORES_URL="http://localhost:8080"

The skill requires curl, jq, and SYNAPCORES_API_KEY. On macOS with Homebrew, install jq with:

brew install jq

3. Verify the gateway

curl -s "$SYNAPCORES_URL/health"

A healthy instance returns a JSON status such as {"status":"ok"}.

4. Define the query helper

sc() {
  curl -s -m 120 -X POST "$SYNAPCORES_URL/v1/query/execute" \
    -H 'Content-Type: application/json' \
    -H "Authorization: Bearer $SYNAPCORES_API_KEY" \
    -d "$(jq -nc --arg sql "$1" '{sql:$sql}')"
}

Using jq -nc safely serializes memory text that contains quotes or apostrophes.

5. Optional: install automatic memory support

openclaw plugins install clawhub:@synapcores/openclaw-memory

The companion plugin uses the same API key and gateway. Verify which memory backend is active before assuming manually stored memories and plugin-managed memories share the same tables.

SynapCores Memory Data Schema & Taxonomy

Memory operations

Operation Purpose Result
MEMORY_STORE(namespace, content [, metadata]) Stores and embeds a concise fact Memory ID such as mem_...
MEMORY_RECALL(namespace, query [, top_k]) Performs semantic similarity search (id, content, similarity, metadata, created_at) rows
MEMORY_FORGET(namespace, id) Permanently deletes a memory Boolean true or false

Namespaces and tables

  • A namespace is passed as the first argument to every memory function.
  • The manual skill stores data in _memory_<namespace>.
  • Namespace names must match ^[A-Za-z_][A-Za-z0-9_]*$; hyphens are not allowed.
  • Use separate namespaces for different people, projects, or other isolation boundaries.
  • MEMORY_RECALL defaults to 10 results and caps top_k at 100.
  • Unknown namespaces return zero rows rather than an error.

Metadata taxonomy

Optional metadata is supplied as a JSON object, for example {"category":"decision"}. Metadata can support later filtering and organization by categories such as preferences, decisions, schedules, or project context. Store the fact rather than a full transcript so embeddings remain focused and retrieval quality stays high.

Plugin backend distinction

With plugin v0.7.0 on SynapCores v1.14.3-ce or newer, the plugin uses the CREATE MEMORY object and _mem_<name>_* tables, which are separate from the manual skill’s _memory_<namespace> tables. Older gateways, or configurations using memory.backend: "legacy", use the shared legacy store. Check the backend with:

curl -s -H "Authorization: Bearer $SYNAPCORES_API_KEY" "$SYNAPCORES_URL/v1/memory"

A JSON array indicates CREATE MEMORY support; HTTP 404 indicates the legacy MEMORY_* functions remain active.

SynapCores Memory Advanced Features

  • Semantic retrieval finds related meaning even when query and memory share no keywords.
  • Local embedding computation keeps memory content inside the self-hosted SynapCores deployment.
  • Namespace isolation separates memories across users, projects, or agent contexts.
  • Optional JSON metadata enables structured categorization and later SQL-based filtering.
  • Similarity scores expose retrieval confidence so the agent can avoid presenting weak matches as facts.
  • Hard-delete semantics support explicit user requests to forget stored information.
  • The companion OpenClaw plugin adds automatic capture and recall, SQL-filtered recall, graph relationships between memories, and AutoML relevance scoring.
  • The plugin can support CREATE MEMORY operations including REMEMBER, RECALL, CURRENT, FORGET, and TRACE when the gateway version supports them.
  • Persistent Docker volume storage allows memory to survive container and agent restarts.
  • Openclaw Skills workflows can follow privacy-aware operating practices: request consent for sensitive data and never store credentials, payment details, or regulated information.

SKILL.md


Loading

Related Openclaw Skills

METADATA

Github Stars: 0
forks: 0

Featured*