Qwen Code Memory: Native Auto-Memory, mem0 MCP, and MemPalace for Self-Improvement

QWEN.md — User-Written Instructions

QWEN.md is a plain text file loaded at the start of every session. Two locations:

Qwen reads both. It also reads AGENTS.md for cross-tool compatibility.

You can reference other files with @path/to/file:

1
See @README.md for project overview.
2

3
# Conventions
4

5
- Git workflow: @docs/git-workflow.md

Run /init and Qwen analyzes your codebase to generate a starter QWEN.md with build commands, test instructions, and conventions.

Auto-Memory — AI-Written Notes

After each conversation, Qwen saves useful things it learned. No configuration needed.

What gets saved:

Where it lives: ~/.qwen/projects/<project>/memory/ — plain markdown files you can open, edit, or delete. All branches of the same repo share the same memory folder.

Commands:

Developer API: The save_memory tool lets you programmatically save facts:

1
save_memory(fact="Project uses pnpm, not npm")
2
save_memory(fact="Auth module uses JWT tokens")

Each call appends to ~/.qwen/QWEN.md under ## Qwen Added Memories.

Periodic Cleanup

Qwen periodically deduplicates and removes outdated memories. Runs automatically once a day after enough sessions accumulate. Trigger manually with /dream — the UI shows ✦ dreaming in the corner while it runs.

Limitations

Native memory is good for basic cross-session recall but lacks:

• Semantic search — no vector embeddings, no fuzzy matching
• Entity linking — can’t connect “JWT auth” from session 1 with “refresh tokens” from session 3
• Temporal reasoning — can’t distinguish “what did we decide last week” from “what’s our current approach”
• Scalable retrieval — as memory files grow, loading them all into context wastes tokens

Enter third-party memory via MCP.

Architecture

Two deployment modes:

Self-hosted defaults:

• LLM: OpenAI gpt-4.1-nano-2025-04-14
• Embeddings: OpenAI text-embedding-3-small
• Vector store: Postgres + pgvector
• Bundled providers: openai, anthropic, gemini

New Algorithm (April 2026)

mem0 released a new memory algorithm with single-pass ADD-only extraction — one LLM call, no UPDATE/DELETE. Memories accumulate; nothing is overwritten.

Key changes:

• Single-pass ADD-only extraction — one LLM call, no UPDATE/DELETE
• Agent-generated facts are first-class — when an agent confirms an action, that information is stored with equal weight
• Entity linking — entities are extracted, embedded, and linked across memories for retrieval boosting
• Multi-signal retrieval — semantic, BM25 keyword, and entity matching scored in parallel and fused
• Temporal reasoning — time-aware retrieval that ranks the right dated instance for queries about current state, past events, and upcoming plans

9 MCP Tools

1
add_memory          — Save text or conversation history
2
search_memories     — Semantic search with filters
3
get_memories        — List memories with pagination
4
get_memory          — Retrieve by ID
5
update_memory       — Overwrite by ID
6
delete_memory       — Delete by ID
7
delete_all_memories — Bulk delete
8
delete_entities     — Delete entity and its memories
9
list_entities       — List users/agents/apps/runs

Integration with Qwen Code

Add mem0’s MCP server to ~/.qwen/settings.json:

1
{
2
  "mcpServers": {
3
    "mem0": {
4
      "type": "http",
5
      "url": "https://mcp.mem0.ai/mcp/",
6
      "headers": {
7
        "Authorization": "Token ${MEM0_API_KEY}"
8
      }
9
    }
10
  }
11
}

Or use the CLI for quick setup:

1
npm install -g @mem0/cli
2
mem0 init --agent --agent-caller qwen-code
3
mem0 add "Project uses pnpm, not npm"
4
mem0 search "what package manager"

Python SDK

1
from mem0 import Memory
2

3
memory = Memory()
4

5
# Add memory from conversation
6
messages = [
7
    {"role": "user", "content": "I'm working on JWT auth"},
8
    {"role": "assistant", "content": "Got it, I'll remember"}
9
]
10
memory.add(messages, user_id="qwen-code")
11

12
# Search memories
13
results = memory.search(
14
    "What auth approach?",
15
    filters={"user_id": "qwen-code"},
16
    top_k=3
17
)

Lifecycle Hooks (Claude Code Plugin)

The mem0 Claude Code plugin hooks into lifecycle events. Qwen Code supports MCP but not Claude Code’s hook system, so you’d wire these manually via save_memory calls:

Architecture

• Structured index — people/projects become wings, topics become rooms, content lives in drawers
• Pluggable backends — ChromaDB (default), sqlite_exact, qdrant, pgvector
• Knowledge graph — temporal entity-relationship graph with validity windows, backed by SQLite
• 29 MCP tools — palace reads/writes, knowledge-graph operations, agent diaries

Benchmarks (Zero API Calls)

The raw 96.6% requires no API key, no cloud, and no LLM at any stage. The hybrid pipeline adds keyword boosting, temporal-proximity boosting, and preference-pattern extraction.

Integration with Qwen Code

Install via uv:

1
uv tool install mempalace
2
mempalace init ~/projects/myapp
3
mempalace mine ~/.qwen/projects/ --mode convos  # mine sessions
4
mempalace search "why did we switch to GraphQL"

Or via Docker MCP:

1
{
2
  "mcpServers": {
3
    "mempalace": {
4
      "command": "docker",
5
      "args": ["run", "-i", "--rm", "-v", "mempalace-data:/data", "mempalace"]
6
    }
7
  }
8
}

Key Difference from mem0

mem0 extracts and summarizes — it uses an LLM to distill conversations into facts. MemPalace stores verbatim — every message is preserved exactly as written. This means:

• No information loss — you can always go back to the original text
• No LLM cost — storage is free, search is fast
• More context — when searching, you get the full conversation, not a summary

The tradeoff: MemPalace’s search is file-level chunking, not per-message. For per-message recall, run mempalace sweep <transcript-dir> to store one verbatim drawer per user/assistant message.