Skip to main content
Glama

kiro-recall

A local MCP memory server for Kiro CLI that gives your AI assistant persistent, semantic memory across sessions.

Inspired by Kiro Crew's memory architecture — reimplemented as a lightweight, self-contained system using SQLite + Ollama embeddings, with Obsidian as the human-readable sync target.

What it does

  • Semantic memory — structured key-value facts (pref.editor: Neovim, project.active: MyProject)

  • Episodic memory — conversation fragments that decay over time (~23 day half-life)

  • Lessons — corrections and rules that override all other memory (highest priority)

  • Semantic recall — vector similarity search via Qwen3-Embedding (1024-dim, runs locally)

  • Obsidian sync — renders memory to markdown with [[wikilinks]] for graph navigation

Related MCP server: tartarus-mcp

Architecture

┌──────────────────────────────────────────┐
│  Kiro CLI / any MCP client               │
│  Tools: Remember, Recall, Learn, Forget  │
└──────────────┬───────────────────────────┘
               │ stdio (MCP protocol)
       ┌───────▼───────┐          ┌─────────────────┐
       │  memory.db    │  sync →  │  Obsidian Vault  │
       │  (SQLite)     │          │  (Markdown)      │
       └───────┬───────┘          └─────────────────┘
               │
       ┌───────▼───────┐
       │  Ollama       │
       │  qwen3-embed  │
       │  (localhost)   │
       └───────────────┘

Requirements

  • macOS or Linux

  • Python 3.10+

  • Ollama (for local embeddings)

  • uv (recommended) or pip

Install

git clone https://github.com/fredluckham/kiro-recall.git
cd kiro-recall
bash install.sh

The install script will:

  1. Install Ollama (if not present) and start it as a service

  2. Pull the qwen3-embedding:0.6b model

  3. Create a Python venv and install dependencies

  4. Install the MCP server config into ~/.kiro/settings/mcp.json

  5. Install the steering file to ~/.kiro/steering/obsidian-memory.md

  6. Optionally seed memory from an existing Obsidian vault

Manual setup

If you prefer not to use the install script:#

# 1. Install Ollama and the embedding model
brew install ollama  # or: curl -fsSL https://ollama.com/install.sh | sh
brew services start ollama
ollama pull qwen3-embedding:0.6b

# 2. Create venv and install deps
uv venv .venv
uv pip install "mcp[cli]>=1.0.0" "httpx>=0.27.0"

# 3. Copy to ~/.kiro/recall
mkdir -p ~/.kiro/recall
cp server.py db.py embed.py obsidian_sync.py ~/.kiro/recall/

# 4. Add to MCP config (see install.sh for the JSON patch)

MCP Tools

Tool

Description

Remember

Store a fact, episode, or lesson

Recall

Semantic search across all memory

Learn

Store a high-priority correction/rule

Forget

Remove a memory by key or ID

MemoryStats

Show counts, age, and decay health per memory tier

PruneMemory

Hard-delete soft-deleted and fully decayed episodic rows

Memory tiers

Tier

Priority

Decay

Use case

Lessons

Highest

None

"Always use wikilinks", "Never assume region"

Semantic

High

None (updated in place)

Structured facts about user/projects

Episodic

Medium

exp(-0.03 × days)

Conversation fragments, decisions

Key format

  • pref.* — User preferences (pref.theme, pref.voice, pref.editor)

  • project.* — Active projects (project.active, project.stack)

  • user.* — User facts (user.role, user.company, user.tools)

Obsidian sync

Run manually or via cron:

~/.kiro/recall/.venv/bin/python ~/.kiro/recall/obsidian_sync.py

Outputs:

  • Memory/Semantic.md — all facts grouped by prefix

  • Memory/Lessons.md — corrections grouped by category

  • Sessions/YYYY-MM-DD.md — today's episodic memories

Configuration

Set the Obsidian vault path via environment variable (prompted during install, saved to ~/.kiro/recall/.env):

export KIRO_MEMORY_VAULT="$HOME/Documents/Obsidian/My Vault"

The default is ~/Documents/Obsidian/Kiro Knowledge Base.

Enable automatic Obsidian sync after every Remember or Learn call:

export KIRO_MEMORY_AUTOSYNC=1

When disabled (default), sync runs manually or via cron. Auto-sync adds a small write overhead per call but keeps the vault always current.

The Ollama endpoint is set in embed.py:

OLLAMA_URL = "http://localhost:11434/api/embed"
MODEL = "qwen3-embedding:0.6b"

License

MIT

Available Tools

6 tools
ForgetA

Remove a memory.

Args: memory_type: One of 'semantic', 'episodic', or 'lesson'. identifier: The key (for semantic) or ID number (for episodic/lesson).

Inputs: identifier (required), memory_type (required). Returns: result

LearnA

Store a correction or rule that should always be followed.

These have the highest priority and override other memories.

Args: rule: The rule or correction. e.g. "Always use wikilinks when writing to Obsidian" category: One of 'preference', 'tool', 'knowledge'. Default 'preference'.

Inputs: rule (required), category. Returns: result

MemoryStatsA

Show memory statistics — counts, age, and decay health per memory tier.

Inputs: no named parameters. Returns: result

PruneMemoryA

Hard-delete decayed and soft-deleted episodic memories.

Removes soft-deleted rows and any active episodic rows whose maximum possible decay score has fallen below score_floor (~115 days at default).

Args: score_floor: Rows with max possible decay score below this are removed. Default 0.05. Set lower (e.g. 0.01) to be more conservative.

Inputs: score_floor. Returns: result

RecallA

Search memory by semantic similarity.

Args: query: What to search for. Can be a question, topic, or keyword. memory_type: One of 'all', 'semantic', 'episodic', or 'lessons'. limit: Max results to return. Default 10. score_threshold: Minimum similarity score (0.0–1.0) to include a result. Applied to semantic cosine scores and episodic decay scores. Default 0.35. Set to 0.0 to disable filtering. category: Filter lessons by category (e.g. 'preference', 'tool', 'knowledge'). Only applied when memory_type includes lessons. Empty string returns all.

Inputs: query (required), limit, category, memory_type, +1 more. Returns: result

RememberA

Store something in memory.

Args: text: The content to remember. memory_type: One of 'episodic' (conversation fragment), 'semantic' (structured fact), or 'lesson' (correction/rule). key: Required for semantic type. Format: 'pref.theme', 'project.name', 'user.role', etc. importance: 0.0-1.0, how important this memory is. Higher = slower decay. Default 0.5. tags: Comma-separated tags for episodic memories.

Inputs: text (required), key, tags, importance, +1 more. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 6 tools

    Disambiguation3/5

    Remember and Learn overlap because Remember accepts memory_type='lesson', which is essentially Learn's entire purpose. The other tools are clearly distinct, and the detailed descriptions help clarify priority and scope, but the lesson overlap creates real ambiguity.

    Naming Consistency4/5

    Most tools use simple single-word verbs like Remember, Recall, Learn, and Forget, which is internally consistent. MemoryStats and PruneMemory break the pattern by using compound names, but the overall naming is still predictable and readable.

    Tool Count5/5

    Six tools is well-scoped for a memory system. Each tool handles a distinct part of the lifecycle: storing, learning, recalling, forgetting, pruning, and inspecting statistics, with no unnecessary redundancy.

    Completeness4/5

    The core memory lifecycle is well covered: create, recall, delete, prune, and stats. The main gap is the lack of an update/edit operation for existing memories and no exact-key lookup, though agents can work around it by forgetting and re-remembering.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      A local, fully-offline MCP memory server that enables persistent storage and retrieval of information using SQLite with both keyword and semantic vector search capabilities.
      10
      13 npm
      13
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      A local-first MCP memory server providing persistent, searchable memory for AI agents, powered by SQLite.
      1 npm
      1
      Apache 2.0
    • A
      license
      Not graded
      quality
      D
      maintenance
      A fully local, self-hosted memory server for MCP clients (Claude Code, Cursor, etc.) that provides persistent memory storage with semantic search, using local embeddings and a local Qdrant vector store.
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server that provides semantic memory with search, related-content traversal, and write-back capabilities, all powered by local embeddings of your notes, documents, and chat histories.
      3
      MIT