openclaw-siliconflow-memory

Configure OpenClaw semantic memory to use SiliconFlow embeddings through the OpenAI-compatible API, especially `BAAI/bge-m3`. Use when enabling or repairing...

Security Scan

The skill's instructions and requirements are coherent with its stated purpose (configuring OpenClaw to use SiliconFlow embeddings); it asks the operator to change OpenClaw config and index local Markdown paths but does not request unrelated credentials or install arbitrary code.

Purpose & Capability

Name/description match the instructions: the SKILL.md only covers switching OpenClaw's memory_search to SiliconFlow (OpenAI-compatible endpoint), setting model to BAAI/bge-m3, adding extraPaths, and validating indexing—these are the exact config and CLI actions described.

Instruction Scope

Instructions are scoped to reading and patching OpenClaw config (gateway config.get/patch), adding curated local Markdown paths, running OpenClaw memory status/index/search, and troubleshooting. There is no instruction to read unrelated system files or to exfiltrate data. It does recommend storing an API key in the config (see environment_proportionality note).

Install Mechanism

This is instruction-only with no install spec and no code files — nothing will be downloaded or written by the skill itself. Low installation risk.

Credentials

The skill declares no required env vars, but it explicitly instructs setting remote.apiKey in OpenClaw config. Requesting the SiliconFlow API key is proportionate to the task, but storing API keys in config can expose them to other users/tools or source control; the SKILL.md does not advise a secure storage method.

Persistence & Privilege

always:false and no install means the skill has no forced persistent presence. Note: agent autonomous invocation is allowed by platform default (not a red flag alone). If you place an API key in OpenClaw config, that credential will be accessible to components that can read that config, so consider the blast radius before storing secrets there.

Assessment

This skill appears to do what it says: help you switch OpenClaw to SiliconFlow embeddings and validate indexing. Before proceeding: (1) be prepared to provide a SiliconFlow API key — prefer a secure secret store instead of pasting it into a repo-tracked config file; (2) review the exact gateway config.patch commands and who/what can read OpenClaw config in your environment (storing the key in config increases its exposure to other tools/skills); (3) add external extraPaths conservatively to avoid indexing sensitive or noisy files; (4) test changes in a staging instance if possible and be ready to rotate/revoke the API key after testing. If you want stronger protections, request guidance from the skill author on using secret references or environment-backed config rather than embedding the key directly in JSON config patches.

Goal

Configure OpenClaw memory_search to use SiliconFlow embeddings reliably, then verify indexing and retrieval.

Use this skill to:

• switch memory embeddings to SiliconFlow
• standardize on BAAI/bge-m3
• set fallback: "none" for clearer debugging
• add curated external Markdown paths to semantic memory
• diagnose failed indexing or failed retrieval

Workflow

1. Inspect the memory config surface first

Before changing config, inspect the relevant schema paths:

• agents.defaults.memorySearch
• agents.defaults.memorySearch.remote
• agents.defaults.memorySearch.extraPaths

Then inspect the current config with gateway config.get so the patch is based on the latest hash.

Important:

• Configure memory under agents.defaults.memorySearch, not top-level memorySearch.
• For OpenAI-compatible embedding endpoints, set remote.apiKey explicitly.

2. Apply the recommended memorySearch config

Use gateway config.patch and keep the configuration explicit.

Recommended baseline:

agents: {
  defaults: {
    memorySearch: {
      provider: "openai",
      model: "BAAI/bge-m3",
      fallback: "none",
      remote: {
        baseUrl: "https://api.siliconflow.cn/v1/",
        apiKey: "YOUR_SILICONFLOW_API_KEY"
      }
    }
  }
}

Why this baseline works well:

• provider: "openai" matches SiliconFlow's OpenAI-compatible embeddings API
• model: "BAAI/bge-m3" is a strong default for mixed Chinese/English Markdown recall
• fallback: "none" avoids silently switching providers during debugging
• explicit remote.baseUrl and remote.apiKey remove ambiguity

3. Add external knowledge paths conservatively

When indexing a local knowledge base, prefer curated paths instead of adding the entire repo at once.

Good first candidates:

• source notes
• concepts
• project overviews
• indexes
• README-style top-level knowledge summaries

Avoid adding these in the first pass unless the user explicitly wants them indexed:

• inbox or capture folders
• daily journals
• templates
• archives
• noisy exports or generated files

Example:

agents: {
  defaults: {
    memorySearch: {
      extraPaths: [
        "D:/Knowledge/README.md",
        "D:/Knowledge/Notes/02-Sources",
        "D:/Knowledge/Notes/03-Concepts",
        "D:/Knowledge/Notes/05-Projects",
        "D:/Knowledge/Notes/09-Indexes"
      ]
    }
  }
}

4. Validate in this order

After config reload/restart, validate in a fixed order:

1. openclaw memory status --deep
2. openclaw memory index --force
3. openclaw memory search "<known phrase from indexed docs>"
4. tool-layer memory_search with the same query

Success signs:

• Embeddings: ready
• Indexed: N/N files increases as expected
• Dirty: no
• retrieval returns snippets from the intended external paths

5. Use known text for verification

Do not validate with vague keywords only.

Prefer a phrase that appears verbatim in the indexed notes, such as:

• a README opening sentence
• a project title
• a section heading
• a unique domain phrase

This makes it easier to distinguish:

• indexing failure
• retrieval quality issues
• query mismatch

Common failures

404 page not found

Interpret this as: the endpoint likely does not provide embeddings at the configured route.

Typical cause:

• using a chat/completions proxy that does not expose /embeddings

Action:

• switch to SiliconFlow's embeddings endpoint
• confirm remote.baseUrl is https://api.siliconflow.cn/v1/
• confirm the embedding model name is valid

fetch failed

Interpret this as: the request could not complete at all.

Typical causes:

• bad API key
• unreachable endpoint
• transient network issue
• provider auto-detection picked the wrong backend

Action:

• make provider, model, remote.baseUrl, and remote.apiKey explicit
• retry openclaw memory status --deep

EBUSY: resource busy or locked

Interpret this as: the SQLite memory store is locked during reindex.

Action order:

1. retry the index once after current memory operations settle
2. restart OpenClaw and retry
3. if the lock persists, reboot the machine and retry

Do not assume config is wrong just because reindex failed with EBUSY.

Recommended operating style

• keep the embedding provider explicit
• keep fallback: "none" during setup and debugging
• add knowledge paths in small batches
• validate with both CLI and tool-layer retrieval
• prefer high-signal Markdown sources over raw dumps

Completion checklist

Before declaring success, confirm all of the following:

• SiliconFlow API key is configured
• BAAI/bge-m3 is active
• openclaw memory status --deep shows Embeddings: ready
• reindex succeeds
• indexed file count reflects the intended extra paths
• at least one query returns a result from the external knowledge base