M2Wise

Memory-to-Wisdom Engine for AI agents. Use this skill to give yourself long-term memory, extract user preferences/facts from conversations, and track wisdom...

Security Scan

The skill's behavior (install instructions, required API keys, and proactive persistent storage of user data) is coherent with a memory engine, but the package asks you to install external code and the SKILL.md declares environment/binary requirements that conflict with the registry metadata — you should verify sources, storage/retention, and privacy before installing.

Purpose & Capability

The claimed purpose (long-term memory and wisdom extraction) matches the instructions to install an SDK/CLI, save/retrieve memories, and run consolidation (sleep/dream). However the SKILL.md declares required binaries and environment variables (python3, pip, m2wise-mcp, OPENAI_API_KEY, M2WISE_SILICONFLOW_API_KEY) while the registry metadata lists none — this inconsistency needs clarification.

Instruction Scope

Runtime instructions tell the agent to pip install m2wise[all], run Python SDK calls to add/get context/trigger background processing, and start an MCP server. They explicitly instruct the agent to proactively save user preferences/facts (including potentially sensitive content) and to query memory before answering. That is within the stated purpose but expands agent behavior (proactive persistent writes and background consolidation) and depends on external packages and networked embedder services.

Install Mechanism

There is no platform install spec, but SKILL.md directs pip install and npx clawdhub install, and references an m2wise-mcp binary. Installing via pip/npx will execute third-party code on the host — this is expected for an SDK/CLI but raises standard supply-chain risks. No direct download URLs or extract operations are present in the skill files, but you should inspect the PyPI package and GitHub repo before installing.

Credentials

The skill expects API keys for embedding/LLM providers (OPENAI_API_KEY, M2WISE_SILICONFLOW_API_KEY), which are reasonable for an embedding/LLM-backed memory engine. However the registry metadata did not declare any required env vars while SKILL.md does — a red flag for incomplete metadata. The skill will store long-term user data, so providing API keys or DB credentials grants access to systems that will hold potentially sensitive personal information; the skill’s examples also show adding passwords to memory (and deleting them), underlining privacy risk.

Persistence & Privilege

The skill is designed to persist user memories to disk or a vector DB (data_dir, postgres examples) and to run background consolidation. It is not set always:true, but it will create persistent data and may call external services. The agent instructions encourage proactive saving of user statements (including sensitive items), so confirm data retention, storage location, encryption, and deletion semantics before use.

What to consider before installing

Key things to consider before installing: - Metadata mismatch: SKILL.md requires python, pip, m2wise-mcp and environment keys (OPENAI_API_KEY, M2WISE_SILICONFLOW_API_KEY), but the registry lists none. Ask the author to reconcile the declared requirements. - Source review: SKILL.md points to a GitHub repo and a PyPI package name; inspect the package source (GitHub/PyPI) yourself to ensure there is no unexpected network exfiltration or malicious install scripts. - Privacy and retention: This skill stores long-term memories (possibly in local files or external DBs). Confirm where data is stored (local vs remote), whether it is encrypted at rest/in transit, retention policies, and an easy/complete forget/delete API. - API keys and scope: Only provide API keys with the minimum necessary scope, and consider using scoped/test keys first. Understand which remote LLM/embedder endpoints the skill will call. - Containment: If you test the skill, run it in a sandboxed environment (isolated VM or container) and avoid adding extremely sensitive data (passwords, secrets) as memories until you trust the implementation. - Operational controls: Verify how automatic/background consolidation is triggered and whether you can disable proactive saving or auto-dream/sleep. If you do not trust the package source or cannot confirm storage/retention and network behavior, do not install. If you proceed, audit the installed package code and run it in an isolated environment, and ensure you have a way to purge any stored memories.

M2Wise - Memory-to-Wisdom Engine

This is a skill for the OpenClaw AI Agent to enable long-term memory and self-evolving wisdom.

🎯 Purpose

As an AI agent, you inherently lack persistent memory across distinct sessions. The M2Wise skill bridges this gap. It allows you to:

1. Extract and store memories (facts, preferences, commitments) from user conversations.
2. Retrieve contextual memories and aggregated wisdom before answering.
3. Consolidate raw memories into overarching "Wisdom" (rules, schemas, and skills) during idle time.

🚦 When to Use This Skill

You should proactively invoke this skill in the following scenarios:

• User expresses a preference: e.g., "I prefer short answers", "Don't use emojis."
• User shares a personal fact: e.g., "I work as a Python developer", "I live in Beijing."
• User asks you to remember: e.g., "Remember that I hate spam."
• Before answering complex questions: To recall the user's past preferences or facts to personalize your response.

🛠️ How to Use (Agent Instructions)

You can interact with M2Wise via its Python SDK. Use your shell/execution environment to run these scripts snippet by snippet.

1. Installation Requirements

Make sure the environment has M2Wise installed before calling its Python API:

pip install m2wise[all]

2. Saving Memories (Online Phase)

When you detect a fact or preference in the conversation, run a quick python script to save it:

from m2wise_sdk import M2WiseSDK

sdk = M2WiseSDK()
# Extract and save the user's message
sdk.add_message("current_user_id", "I prefer concise Chinese answers for technical questions")

3. Retrieving Context (Online Phase)

Before fulfilling a user's request, fetch their relevant memories:

from m2wise_sdk import M2WiseSDK

sdk = M2WiseSDK()
context = sdk.get_context("current_user_id", "How should I answer this technical question?")
print("Retrieved Context:", context)

Action: Read the output of this script and adapt your final response to the user based on the retrieved context.

4. Background Processing (Sleep & Dream)

It is a good practice to trigger memory consolidation periodically (e.g., at the end of a long task).

from m2wise_sdk import M2WiseSDK

sdk = M2WiseSDK()
# Sleep: Extracts memories and groups them into Wisdom Drafts
sdk.trigger_sleep("current_user_id")

# Dream: Verifies drafts against counterexamples and publishes them
sdk.trigger_dream("current_user_id")

🧩 MCP Server Alternative

If your OpenClaw runtime supports MCP (Model Context Protocol), you can start the M2Wise MCP server and use its native tools instead of writing Python scripts:

# Start the MCP server
m2wise-mcp --data-dir ./data

Available MCP Tools:

• m2wise_add: Add memory from conversation.
• m2wise_search: Search memories and wisdom.
• m2wise_sleep: Generate wisdom drafts.
• m2wise_dream: Verify and publish wisdom.

🧠 Memory and Wisdom Types You Will Encounter

• Memories: preference (likes/dislikes), fact (states/attributes), commitment (future actions).
• Wisdoms: principle (interaction guidelines), schema (behavioral patterns), skill (operational tactics).

🚀 Best Practices

1. Be Proactive: Don't wait for the user to explicitly say "remember this". If they state a strong preference, save it using sdk.add_message().
2. Context First: For ambiguous requests, always query the memory bank first.
3. Consolidate Often: Run trigger_sleep() and trigger_dream() after completing a major task to ensure your wisdom evolves and stays clean.

🔗 Resources

• GitHub Repository: https://github.com/zengyi-thinking/M2Wise.git
• Installation via OpenClaw (ClawHub):

  npx clawdhub@latest install m2wise