Remind MCPサーバー
コミット 2026年10月23日AIエージェントに、エピソードの記録、概念の整理、そして時間的事実やセマンティック検索を用いたコンテキストの呼び出しを可能にする、永続的なメモリレイヤーを提供します。
別名 sandst1/remind
- スター
- 84
- ツール
- —
- ダウンロード数(30日間)
- —
- 最新バージョン
- —
- 最終コミット
- 2026年10月23日
- ライセンス
- Apache-2.0
Remind MCPとは
AIエージェントに、エピソードの記録、概念の整理、そして時間的事実やセマンティック検索を用いたコンテキストの呼び出しを可能にする、永続的なメモリレイヤーを提供します。
プロジェクトのREADMEから生成された概要
Remind MCP server について
Remindは、Claude DesktopやCursorなどのツールを使用する開発者に向けて、AIエージェントに永続的なメモリレイヤーを提供します。これは決定論的な基盤として機能し、エージェントが生の体験をエピソードとして記録し、それらを一般化された概念へと整理することを可能にします。fastembedによるローカル埋め込みを使用するため、基本的なセットアップにはAPIキーは不要ですが、クラウドベースの埋め込みが必要な場合はOpenAIもサポートしています。
ユーザーは、コマンドラインインターフェース、REST API、またはMCP server接続を通じてメモリを操作できます。システムは時間的な事実を管理し、衝突検知を通じて矛盾を検出するとともに、知識の構造化されたキュレーションを可能にします。ストレージバックエンドには、ローカルのJSONファイル、sqlite-vecを使用したSQLite、pgvectorを使用したPostgreSQL、およびMySQLなど、さまざまなオプションをサポートしています。これにより、メモリをGitリポジトリ内のコードと共にバージョン管理でき、ブランチのチェックアウトやマージに合わせてコンテキストを維持することができます。
できること
- 1技術的な意思決定の記録エージェントが特定のアーキテクチャ上の選択を事実として記録することで、将来的な矛盾を防ぎます。
- 2知識の概念化による整理開発者は、複数の生の情報を、タイトルと要約を持つ単一の構造化された概念へと変換できます。
- 3セマンティックなコンテキストの取得AIクライアントがセマンティック検索を実行し、保存されたメモリに基づいて質問に回答します。
- 4メモリの衝突管理新しい情報が既存の事実と衝突した際にシステムがそれを特定し、手動での整理を可能にします。
プロジェクトの README から作成されています。すべてのユースケースは、その引用と照らし合わせて確認されています。
設定
REMIND_DB_URL
| 名前 | 説明 | 種類 |
|---|---|---|
| REMIND_DB_URL | — |
自動チェック
実行日 2026年11月13日完全なレポート →まだ検証されていません。サーバーには80点のスコア、重大な問題がないこと、および検証に必要な十分なデータが必要です。 チェックの仕組み · 点数を上げるための改善点
- ソースリポジトリがリンクされており、アクセス可能合格
- オープンソースライセンス (OSI)合格
- 過去1年以内にコミットまたはリリースあり合格
- パッケージ名が有名なパッケージに酷似していない未チェック
- リモートエンドポイントがHTTPSを使用未チェック
- 破壊的なツールがラベル付けされている未チェック
- モデルへの隠れた指示がない合格
- パッケージおよびその依存関係に重大な勧告なし未チェック
README
GitHubで見るRemind
Agent-driven memory layer for LLMs. Remind is a deterministic memory substrate with temporal facts, semantic retrieval, and structured curation — the calling agent is the only intelligence.
Documentation · Examples · Changelog

Quick start
pip install remind-mcp
No configuration required — Remind uses local embeddings by default (fastembed, no API key).
remind remember "This project uses React with TypeScript"
remind remember "Chose PostgreSQL for the database" -t decision
remind remember "Cache TTL is 600 seconds" -t fact -e concept:caching
remind recall "What tech stack are we using?"
Durable local memory
Local memory is stored as deterministic JSON records in .remind/memory/. Commit those files with the code; memories follow branch checkout and merge normally. .remind/cache/ and .remind/runtime/ hold ignored indexes, embeddings, logs, and recovery data. Existing local databases migrate automatically with a retained backup. Explicit sqlite://, PostgreSQL, and MySQL URLs continue selecting SQL directly.
remind --store ./my-memory remember "User prefers concise answers"
remind remember "Cache TTL is 600 seconds" -t fact --json --idempotency-key ttl-change
remind recall "cache configuration" --json --explain
remind doctor
remind export memory.json # complete portable knowledge
remind export backup.json --mode backup # also include embeddings and usage
Edits now require revisions from snapshot; CLI apply accepts --revisions '{"<id>":"<revision>"}', MCP/Python apply accepts expected_revisions. Read-only recall returns a structured RecallResult in Python; use .text for prompt context. Storage and migration describes the breaking changes.
Local evaluations cover capture → curation → restart → recall through Python, CLI, MCP, and REST. Run remind-eval --suite operational, remind-eval --suite retrieval (real local embeddings), or remind-eval --suite agent --agent-command '<runner command>'. See evals/README.md for datasets, gates, and the external runner contract. No internal LLM calls or CI are introduced.
How it works
Remind stores episodes (raw experiences) and concepts (generalized knowledge). You capture and curate memories explicitly using CLI commands or MCP tools.
For facts (-t fact), Remind automatically:
- Creates a
Factrow with validity tracking - Assigns it to a cluster based on entity overlap (Jaccard similarity)
- Detects potential collisions with existing facts — same-cluster collisions and cross-cluster related facts are returned with ready-to-paste
applycommands
For any remember call, the output also surfaces the top-5 nearest episodes and concepts semantically, so you can catch contradictions before they go unnoticed.
For patterns and concepts, you use remind apply to create them from episodes:
remind apply --revisions '<ID-to-revision JSON from snapshot>' << 'EOF'
concept from=ep:11,ep:12 title="Retry-with-backoff for resilience" "Exponential backoff resolves flaky deploys and API timeouts."
processed ids=ep:11,ep:12
EOF
Two batch tools
remind snapshot — Read state
remind snapshot stats pending conflicts health # Full overview
remind snapshot entity:concept:caching # Everything about an entity
remind snapshot concept:abc123 # Concept detail with history
# Browse scopes (for exploring memory)
remind snapshot concepts # All concepts
remind snapshot episodes:20 # Recent 20 episodes
remind snapshot entities:person # Entities filtered by type
remind snapshot labels # All labels with counts
remind snapshot decisions questions # Episodes by type
remind snapshot bootstrap # Query-free stable context
Returns JSON. Combinable scopes:
| Scope | Description |
|---|---|
pending |
Unprocessed episodes with their entities |
conflicts[:<status>] |
Open conflicts (or resolved/dismissed/all) |
health |
Actionable issues: pending episodes, open conflicts, orphan concepts |
stats |
Memory statistics |
concepts[:<n>] |
All concepts (default 50) |
episodes[:<n>] |
Recent episodes (default 20) |
entities[:<type>] |
All entities with mention counts, filterable by type |
labels |
All distinct key/value labels in use, with counts |
decisions[:<n>] |
Recent decision episodes |
questions[:<n>] |
Recent question episodes |
entity:<id> |
Episodes and concepts for a specific entity |
label:<key>=<value> |
All episodes and concepts carrying a label |
concept:<id> |
Concept detail with facts and supersession history |
recent:<n> |
N most recent episodes |
query:<text> |
Semantic search results |
events[:<since_seq>] |
Change-feed events with seq > since_seq (default 0). Prefer remind events. |
bootstrap[:<n>] |
Query-free stable context: top-n actionable concepts by confidence + open conflicts + stats (default 10) |
remind events — Poll the change feed
remind events # All events from the start
remind events --since 42 # Only events after seq 42
remind events --kind conflict_opened --since 42
Every write (remember, supersede, conflict, resolve, dismiss, concept, update, label, unlabel, delete, restore, processed) appends an append-only row atomically with the write it describes. Returns {since_seq, count, events, next_since_seq} — pass next_since_seq back in as --since on the next poll instead of re-scanning snapshot pending.
remind apply — Write changes
remind apply << 'EOF'
remember as=f1 t=fact e=concept:cache "Cache TTL is 600 seconds"
supersede old=fact:old123 new=$f1
concept as=c1 from=ep:1,ep:2 title="Pattern name" "Summary"
evidence concept=$c1 episode=ep:3 type=supports strength=0.8 "confirms pattern"
resolve id=conflict:7 winner=fact:abc "confirmed by alice"
processed ids=ep:1,ep:2
EOF
All operations run in a single transaction. --dry-run validates without executing.
Operations:
| Op | Description |
|---|---|
remember |
Store episode (same params as CLI remember) |
supersede old=<fact> new=<fact> |
Replace old fact — auto-records resolved conflict |
conflict fact_a=<id> fact_b=<id> |
Flag contradiction for triage |
resolve id=<conflict> winner=<fact> |
Resolve conflict; losing fact is superseded |
dismiss id=<conflict> |
Dismiss conflict (both facts stay active) |
concept from=<eps> title="..." "summary" |
Create concept from episodes |
link from=<concept> to=<concept> type=<relation> |
Add concept relation |
evidence concept=<id> episode=<id> type=<supports|contradicts|qualifies> |
Link episode evidence to concept |
unlink concept=<id> episode=<id> |
Remove evidence link |
entity_relation source=<id> target=<id> relation=<type> |
Create entity graph edge |
reshape id=<concept> type=<new_type> |
Change concept type |
merge from=<id1>,<id2> into=<new_id> |
Combine overlapping concepts |
split id=<concept> into=<id1>,<id2> |
Separate distinct concerns |
update id=<id> [field=value...] |
Update episode or concept fields |
label id=<id> key=<key> value=<value> |
Add a key=value label to episode/concept |
unlabel id=<id> key=<key> value=<value> |
Remove a key=value label from episode/concept |
delete id=<id> / restore id=<id> |
Soft delete / restore |
processed ids=<ep1>,<ep2> |
Mark episodes as reviewed |
Agent skills
Install skills to teach AI agents how to use Remind:
remind skill-install
remind skill-install --agent claude # Use .claude/skills instead
remind skill-install --dir ~ # Install into ~/.agents/skills
remind skill-install --agent cursor --dir /path/to/project
By default, skills go into .agents/skills under the current working directory.
Use --agent agents|claude|cursor|codex|opencode to select a layout and --dir
to choose any base folder. Codex uses .agents/skills; OpenCode uses
.opencode/skills in projects and .config/opencode/skills when targeting home.
Re-running the command overwrites installed skill files with the bundled versions.
Three skills:
- remind-capture — When and how to write memories (includes decision tree and entity type guide)
- remind-context — When and how to recall before acting (includes output interpretation guide)
- remind-curate — How to process pending episodes into concepts, resolve conflicts, maintain quality
MCP Server
For IDE agents (Cursor, Claude Desktop, etc.):
remind-mcp --port 8765
{
"mcpServers": {
"remind": {
"url": "http://127.0.0.1:8765/sse?db=my-project"
}
}
}
Tools: remember, recall, snapshot, apply, plus conflict/entity management.
Web UI at http://127.0.0.1:8765/ui/, REST API at /api/v1/.
Key features
- Zero-config embeddings — Local fastembed by default (no API key required)
- Labels as a substrate primitive — Freeform
key=valuetags on episodes/concepts, pushed down as a pre-filter into vector search (recall -l key=value), not just a post-filter - Change feed — Append-only
eventstable written atomically with every write; poll withremind events --since <seq>instead of re-scanning pending state - Query-free bootstrap read —
snapshot bootstrapreturns deterministic, stable context (top concepts + conflicts + stats) with no embedding call, cheap enough to inject every turn - Temporal facts — Validity windows, structural supersession, time-travel queries (
--as-of) - Collision detection — Same-cluster and cross-cluster collisions reported on write with ready-to-paste
applycommands - Nearby surfacing — Every
remembercall returns the top-k semantically nearest episodes and concepts for immediate conflict triage - Evidence-weighted retrieval — Episodes link to concepts with typed relationships (
supports,contradicts,qualifies); more evidence = higher recall rank - Freeform concept types — Concepts can have any type string:
pattern,rule,procedure,hypothesis, or any domain-specific label - Concept evolution —
reshape(change type),merge(combine overlapping),split(separate concerns), all with lineage tracking - Transactional writes —
applyruns all operations atomically - Spreading activation retrieval — Queries activate related concepts through the knowledge graph
- Native vector indexes — sqlite-vec (SQLite), pgvector (PostgreSQL)
- Entity graph — Files, functions, people, tools linked to episodes and concepts via
entity_relation - Memory decay — Rarely-recalled concepts fade
- Soft delete / restore — With permanent purge as a separate step
- Web UI — Dashboard, concept graph, entity explorer
Embedding providers
Local embedding is the default (384-dim all-MiniLM-L6-v2). For cloud embeddings:
pip install "remind-mcp[openai]" # OpenAI embeddings
pip install "remind-mcp[rerank]" # Cross-encoder reranking
{
"embedding_provider": "openai",
"openai": { "api_key": "sk-..." }
}
Database backends
Local JSON records are the default; SQLite is used for disposable indexes. Explicit SQL URLs select a database backend. For PostgreSQL or MySQL:
pip install "remind-mcp[postgres]" # PostgreSQL (psycopg v3 + pgvector)
pip install "remind-mcp[mysql]" # MySQL (PyMySQL)
export REMIND_DB_URL="postgresql+psycopg://user:pass@localhost:5432/mydb"
CLI reference
Core
remember Add an episode (-t type, -e entity, -l key=value label, --asserted-by, --source-ref)
recall Semantic or entity-based retrieval (-k, --episode-k, -l label filter, --as-of)
snapshot Read memory state as JSON (combinable scopes)
apply Apply a batch changeset transactionally
Inspection
inspect List or detail concepts; use --episodes for episodes
stats Memory statistics
entities List entities or show details
Episode types
decisions Show decision episodes
questions Show open question episodes
Conflicts
conflicts list/resolve/dismiss
Editing
update-episode/update-concept
delete-episode/restore-episode/purge-episode
delete-concept/restore-concept/purge-concept
Embeddings
embed-episodes Backfill embeddings
re-embed Recompute embeddings (--episodes/--concepts/--entities/--all)
Import / Export
export/import
Skills
skill-install Install Remind skills
UI
ui Launch the web UI
Entity types: file, function, class, module, subject, person, project, tool — format is type:name (e.g., file:src/auth.ts, person:alice, tool:redis, concept:caching)
Documentation
Full documentation at sandst1.github.io/remind:
- What is Remind? — How it works
- Skills + CLI — Agent integration
- Configuration — Providers, config
- CLI Reference — All commands
- MCP Tools — MCP reference
License
Apache 2.0 (LICENSE)
Remind MCPのよくある質問
Remindを使用する際、APIキーや設定は必要ですか?
いいえ。Remindはデフォルトでfastembedを使用したローカル埋め込みを使用するため、設定やAPIキーなしですぐに動作します。
Remindが公開するMCP toolsにはどのようなものがありますか?
このMCP serverは、remember、recall、snapshot、applyの各toolに加え、衝突(conflict)およびエンティティ管理のtoolを提供します。
Remindのメモリはデフォルトでどこに保存されますか?
ローカルメモリは、.remind/memory/ 内に決定論的なJSONレコードとして保存され、コードと共にコミットすることが可能です。また、SQLite、PostgreSQL、MySQLのURLもサポートしています。
ローカル埋め込みの代わりにOpenAIの埋め込みを使用できますか?
はい。openai extraをインストールし、embedding_providerをopenaiに設定してAPIキーを入力することで利用可能です。
エージェントはどのようにしてRemindの使い方を学習しますか?
remind skill-installを実行して、同梱されているAgent Skills(capture、context、curate)をインストールすることで、Claude、Cursor、Codex、OpenCodeなどのエージェントで利用できるようになります。