⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

lycheemem

@lycheemem⭐ 1.1k stars

Forceful operating rules for using LycheeMem as the primary structured long-term memory path inside OpenClaw.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐⭐ 1.1k on GitHubGitHub ↗

Very popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

LycheeMemory is a compact memory framework for LLM agents. It starts from efficient conversational memory—through structured organization, lightweight consolidation, and adaptive retrieval—and gradually extends toward action-aware, usage-aware memory for more capable agentic systems.



🔥 News

  • [07/07/2026] OpenAI-compatible Chat Completions endpoints are now available, with request-level consolidation control via consolidate or store.
  • [05/08/2026] Transformer memory reranker v0 improves evidence selection in semantic memory search, with positive hit@10 gains on LoCoMo and zero-shot LongMemEval-S / MSC-MemFuse / HotpotQA fixtures. See Transformer Reranker v0.
  • [04/29/2026] Hermes and Claude Code plugin integrations are now available, bringing LycheeMemory's automatic recall, turn mirroring, and consolidation workflow to more agent runtimes. Setup guides: Hermes · Claude Code
  • [04/26/2026] Visual (Multimodal) Memory module added! See Visual Memory.
  • [04/13/2026] LycheeMem is now LycheeMemory.
  • [04/03/2026] The project now supports installation via pip install lycheemem. You can easily start the service from anywhere using lycheemem-cli!
  • [03/30/2026] We evaluated LycheeMemory on PinchBench with the OpenClaw plugin: compared to OpenClaw's native memory, it achieved an ~6% score improvement, while reducing token consumption by ~71% and cost by ~55%!
  • [03/28/2026] Semantic memory has been upgraded to Compact Semantic Memory (SQLite + LanceDB), no Neo4j required. See /quick-start for details.
  • [03/27/2026] OpenClaw Plugin is now available at /openclaw-plugin ! Setup guide →
  • [03/26/2026] MCP support is available at /mcp !
  • [03/23/2026] LycheeMemory is now open source: GitHub Repository →

🔗 Related Projects

LycheeMemory is part of the 3rd-generation Lychee (立知) large model series, which focuses on memory intelligence, continual learning, and long-context reasoning.

We welcome you to explore our related works:

  • LycheeMemory (ACL 2026, CCF-A): a unified framework for implicit long-term memory and explicit working memory collaboration in large language models
    arXiv GitHub Hugging Face

  • LycheeMem (this project): long-term memory infrastructure for LLM-based agents
    Project Page GitHub

  • LycheeDecode (ICLR 2026, CCF-A): selective recall from massive KV-cache context memory
    Project Page arXiv GitHub

  • LycheeCluster (ACL 2026, CCF-A): structured organization and hierarchical indexing for context memory
    arXiv


⚡ Quick Start

Prerequisites

  • Python 3.9+
  • An LLM API key (OpenAI, Gemini, or any litellm-compatible provider)

Installation

Install the core package:

pip install lycheemem

Recommended install with the default transformer memory reranker:

pip install "lycheemem[rerank]"

The rerank extra adds PyTorch / Transformers runtime dependencies. With it installed, LycheeMemory enables the hosted LycheeMem/reranker checkpoint by default. Without the extra, the core memory system still works and reranki

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • openclaw-plugin/skills/lycheemem/SKILL.md5.4 KBupstream ↗
    ---
    name: lycheemem
    description: Forceful operating rules for using LycheeMem as the primary structured long-term memory path inside OpenClaw.
    requires:
      config:
        - plugins.entries.lycheemem-tools.enabled
    ---
    
    # LycheeMem
    
    ## Mission
    
    Use LycheeMem as the default structured long-term memory layer.
    
    When the answer depends on prior conversations, historical facts, entity relationships, project background, preferences, procedures, or timeline reconstruction, prefer LycheeMem first.
    
    Do not wait for the user to explicitly say `lycheemem`, `memory`, or `smart_search`.
    
    ## Default Priority
    
    For long-horizon recall, use this order:
    
    1. `lychee_memory_smart_search`
    2. answer using the returned `background_context` or retrieval payload
    3. `lychee_memory_consolidate` when important durable knowledge was added or clarified
    
    Treat `lychee_memory_smart_search` as the primary recall tool.
    
    Treat `lychee_memory_search` as a debugging tool, not the normal path.
    
    ## When Smart Search Is Expected
    
    Call `lychee_memory_smart_search` by default before answering if any of the following is true:
    
    - the user asks about earlier dialogue, prior sessions, or historical context
    - the user asks who/when/where/why/how about a person, relationship, event, preference, or decision that was not stated in the current message
    - the answer requires reconstructing a timeline or resolving relative dates such as "昨天", "上周", "之前", "上次"
    - the answer is about project standards, long-term project background, reusable workflows, or previously agreed rules
    - the conversation is benchmark-like, memory-evaluation-like, or asks factual questions about prior dialogue turns
    - there is any serious chance that host-local memory is incomplete, stale, or missing
    
    In short: if the question is not answerable from the current message alone, try `lychee_memory_smart_search` first.
    
    Use `response_level=minimal` by default so retrieval details stay trimmed unless you are explicitly debugging memory retrieval.
    
    ## When Not To Skip Smart Search
    
    Do not skip `lychee_memory_smart_search` merely because:
    
    - OpenClaw has some local workspace context
    - you vaguely remember the answer
    - `MEMORY.md` or `memory/*.md` might contain something related
    - the user did not explicitly request a memory lookup
    
    If the question is a factual recall question about prior dialogue, skipping `lychee_memory_smart_search` should be the exception, not the default.
    
    ## How To Use The Result
    
    - Prefer the returned `background_context` when present
    - use the retrieval result as supplemental long-term evidence
    - if LycheeMem returns useful memory, answer from it directly instead of improvising from uncertain host memory
    - if LycheeMem returns insufficient evidence, say so clearly instead of hallucinating
    
    Do not call OpenClaw native memory search and LycheeMem retrieval for the same recall question unless the user explicitly wants comparison.
    
    ## Consolidation Rules
    
    Use `lychee_memory_consolidate` more aggressively than before.
    
    Call `lychee_memory_consolidate` with `background=true` when any of the following is true:
    
    - the turn introduced a durable new fact, preference, rule, identity detail, relationship, or project standard
    - a transcript/session/chunk of conversation was just ingested and should become long-term memory
    - the user explicitly asked to remember, store, retain, or save something
    - the conversation resolved an ambiguity and produced a stable final answer worth preserving
    - a benchmark or evaluation workflow is intentionally feeding conversations into long-term memory
    
    When in doubt, prefer one timely background consolidation over waiting too long and losing the memory.
    
    ## Append Turn Rules
    
    If host lifecycle integration is enabled and working, assume natural-language user and assistant turns are usually mirrored automatically.
    
    In that case:
    
    - do not manually duplicate `lychee_memory_append_turn`
    - but you may still call `lychee_memory_consolidate` after important memory-worthy turns
    
    If host lifecycle integration is unavailable, disabled, or clearly not working:
    
    - call `lychee_memory_append_turn` after each completed natural-language user turn and assistant turn
    - then call `lychee_memory_consolidate` when important durable knowledge appeared
    
    Do not append raw tool invocations, tool arguments, scratchpad, or raw tool outputs unless explicitly requested.
    
    ## Benchmark And Evaluation Guidance
    
    In benchmark, QA, or dialogue-memory evaluation settings:
    
    - assume factual recall questions should usually trigger `lychee_memory_smart_search`
    - do not rely only on host-local memory for answers about prior dialogue
    - after ingesting a conversation session or transcript chunk, prefer timely `lychee_memory_consolidate(background=true)` so later QA can retrieve the result
    
    For benchmark-style recall, the intended pattern is:
    
    1. ingest or mirror the conversation
    2. consolidate important memory in the background
    3. on each factual recall question, call `lychee_memory_smart_search`
    4. answer from retrieved long-term memory
    
    ## Normal Operating Pattern
    
    1. decide whether the question depends on prior dialogue or long-term memory
    2. if yes, call `lychee_memory_smart_search` first
    3. answer from the returned context
    4. if the turn introduced durable new memory, call `lychee_memory_consolidate(background=true)`
    
    ## Debugging Path
    
    Only during development or debugging:
    
    1. call `lychee_memory_search`
    2. inspect raw retrieval
    
    Outside debugging, prefer `lychee_memory_smart_search`.
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/lycheemem-lycheemem-openclaw-plugin-skills-lycheemem.md

// REPO STATS

1.1k stars