Skip to main content
Glama

AI Memory MCP Server

Agent-agnostic persistent memory as an MCP Server — local-first: memories travel with your project in .aamm/, shared across Claude Code / Qoder / Cursor.

License: MIT Python 3.11+ MCP PyPI

中文 | 日本語

An agent-agnostic persistent memory layer exposed as an MCP Server. Any MCP client — Claude Code, Qoder, Cursor — can reuse it. Memories live in each project's .aamm/ directory and travel with the project; different agents working the same project share one memory store, with a source_agent stamp distinguishing writers.

Architecture

  • SQLite — structured source of truth (CRUD + FTS5 keyword search)

  • Chroma (embedded) — vector retrieval, persisted to .aamm/chroma/

  • Embedding — any OpenAI-compatible service (Volcengine / SiliconFlow / OpenAI / others); defaults to Volcengine doubao-embedding-vision

  • Markdown mirror — each memory is also written to .aamm/memories/<category>/<id>.md, human-readable and editable

The three layers are joined by id.

Related MCP server: blueocean-vector

Memory categories

category

use

user

user preferences (tech background / dev habits / answer style)

project

project knowledge (architecture / stack / layout / design decisions)

process

work process (solved issues / bugs / debugging / lessons)

agent

agent collaboration (what was done / handoff notes)

Install

From PyPI:

pip install ai-agent-memory-mcp

From source:

cd ai_agent_memory_mcp
pip install .          # or: pip install -e .   (editable, for development)

Requires Python 3.11+.

Configure embedding (any OpenAI-compatible service)

The embedding layer is a generic OpenAI-compatible client — Volcengine / SiliconFlow / OpenAI / any compatible service works. On first run a default config is generated at .aamm/config.yml; edit as needed.

Fields (embedding section of .aamm/config.yml)

field

meaning

provider

label (informational only)

model

embedding model name

base_url

OpenAI-compatible endpoint

api_key_env

which env var holds the key

dim

vector dim (must match the model)

Put the key in the project root .env, then edit the embedding section of config.yml.

Examples

Volcengine doubao-embedding-vision (default; Agent/Coding Plan keys must use the Plan endpoint /api/plan/v3 — standard /api/v3 returns 401)

embedding:
  provider: volcengine
  model: doubao-embedding-vision
  base_url: https://ark.cn-beijing.volces.com/api/plan/v3
  api_key_env: VOLCENGINE_API_KEY
  dim: 2048

.env: VOLCENGINE_API_KEY=...

SiliconFlow bge-large-zh (Chinese-text optimized)

embedding:
  provider: siliconflow
  model: BAAI/bge-large-zh-v1.5
  base_url: https://api.siliconflow.cn/v1
  api_key_env: SILICONFLOW_API_KEY
  dim: 1024

.env: SILICONFLOW_API_KEY=...

OpenAI

embedding:
  provider: openai
  model: text-embedding-3-small
  base_url: https://api.openai.com/v1
  api_key_env: OPENAI_API_KEY
  dim: 1536

.env: OPENAI_API_KEY=...

Any other OpenAI-compatible service: just fill in base_url / model / api_key_env / dim.

After switching embedding model, old vectors may mismatch in dimension; clear .aamm/chroma/ and re-remember, or run python tests/rebuild_vectors.py.

Retrieval

recall uses three-way fused retrieval to maximize hit rate:

  • Vector (weight 0.6): Chroma cosine; embeddings are computed from title + tags + content, so title/tag signal enters the vector

  • Keyword (weight 0.25): SQLite FTS5 trigram

  • Title/tag match (weight 0.15): +0.15 if the query appears in the title, +0.075 if in a tag

Candidates are expanded to top_k*3, then fused down to top_k. If the query contains FTS5 special characters (., *, ", -, ...), the keyword branch falls back to LIKE substring matching instead of erroring.

Work journal

Besides searchable memories, aamm keeps a human-readable work journal. After completing a user request, the agent calls journal_entry() to log what was asked / what it did / any open question. Journals are for people reading a timeline; recall does not search them. Use search_journal() only as a fallback to recover "what happened in a past interaction".

Journals are written to .aamm/logs/:

  • journal.db — single SQLite store (the search source, spans all dates)

  • YYYY-MM-DD.md — one Markdown file per day, append-only timeline

.aamm/logs/
├── journal.db        # search source (all dates)
├── 2026-07-14.md     # per-day timeline
└── 2026-07-15.md

MCP tools

Memory (8):

  • remember(title, content, category, tags?, scope?) — store (three-way sync, auto-embed)

  • recall(query, category?, top_k=5) — fused retrieval (vector + keyword + title match)

  • get_memory(id) — get one

  • search_memories(category?, tag?, agent?) — structured filter

  • update_memory(id, ...) — update (re-embed + refresh md)

  • forget(id) — delete (three-way sync)

  • list_memories(category?) — list

  • who_am_i() — current agent + project context

Journal (3):

  • journal_entry(question, answer_summary, key_points?, open_question?, session_id?) — log a timeline entry

  • search_journal(query, date_from?, date_to?, agent?, limit=10) — fallback search over journals

  • setup_profile(user_name) — set the user name (shown in journals)

Management CLI

python -m ai_agent_memory_mcp.cli init                  # initialize .aamm in the current project
python -m ai_agent_memory_mcp.cli status                # store overview (categories / vectors / md / journal)
python -m ai_agent_memory_mcp.cli export [--dir DIR]    # export all memories to Markdown
python -m ai_agent_memory_mcp.cli sync                  # rebuild SQLite + Chroma from Markdown
python -m ai_agent_memory_mcp.cli check                 # consistency check (db / md / chroma)
python -m ai_agent_memory_mcp.cli journal [--limit N]   # show recent journal entries

Wire into Claude Code (user scope; shared code, per-project data)

From PyPI (no PYTHONPATH needed):

claude mcp add aamm -s user -- python -m ai_agent_memory_mcp --agent claude-code --project-from-cwd

From a source clone, add -e PYTHONPATH=<clone dir>\ai_agent_memory_mcp:

claude mcp add aamm -s user -e PYTHONPATH=<clone dir>\ai_agent_memory_mcp -- python -m ai_agent_memory_mcp --agent claude-code --project-from-cwd

Qoder / Cursor are the same — just change --agent.

Data layout

.aamm/
├── memory.db                    # SQLite: structured memories + FTS5
├── chroma/                      # Chroma vector store
├── memories/<category>/<id>.md  # Markdown mirror (editable)
├── logs/
│   ├── journal.db               # work journal (search source)
│   └── YYYY-MM-DD.md            # per-day journal timeline
├── config.yml                   # embedding config
└── profile.json                 # user name

License

MIT

Available Tools

8 tools
forgetA

删除一条记忆(SQLite+Chroma+Markdown 三处同步)。用户要求"删掉 / 忘掉"某条记忆时调用。

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes

TDQS

A3.7/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description bears full burden. It reveals the three synced stores (SQLite, Chroma, Markdown), indicating persistence. However, it does not mention irreversibility, confirmation requirements, or error states.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with a parenthetical detail, front-loaded with the purpose. Slightly concise but clear.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given one parameter and no output schema, the description provides basic purpose and sync info but lacks return format, error behavior, and parameter details.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%. The description adds no meaning beyond the schema: it does not explain what the 'id' parameter refers to or its format.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb (删除, delete) and resource (记忆, memory) and specifies three synced stores. It distinguishes itself from siblings like remember and update_memory.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says to call when the user wants to delete/forget a memory. It lacks explicit when-not-to-use or alternatives, but the context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_memoryA

按 id 取单条记忆的完整内容(含 [[link]] 关联)。已知具体 id 时调用。

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes

TDQS

A4.6/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Describes return content (complete with links). No annotations provided, but readability is high; could explicitly state read-only nature.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences, front-loaded with action, no unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Fully describes a simple retrieval tool. Covers purpose, usage, and output (content with links).

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Only parameter 'id' is explained in description as a required memory identifier. Compensates for 0% schema description coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states tool retrieves a single memory by ID, including associated links. Distinguishes from siblings like search_memories and list_memories.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says to call when a specific ID is known, indicating usage context. Could benefit from mentioning when not to use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_memoriesA

列出记忆(可按分类过滤),按更新时间倒序(不含正文)。浏览 / 概览已有记忆时调用。

ParametersJSON Schema
NameRequiredDescriptionDefault
categoryNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.9/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It discloses sorting order and exclusion of content, but lacks details on pagination, limits, or authentication needs.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences, front-loaded with purpose. Every word earns its place, no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple list tool with one optional parameter and an output schema, the description is nearly complete. Could mention pagination, but output schema may cover return structure.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%. Description mentions category filter, but adds no value beyond the parameter name 'category'. Does not explain valid values or format.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states it lists memories with optional category filtering, sorted by update time descending, and excludes content. It distinguishes from siblings by explicitly noting the sorting and filtering behavior.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states 'call when browsing/overviewing existing memories', providing clear context. Does not mention when not to use or alternatives, but siblings imply search_memories for searching.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

recallB

语义 + 关键词 + 标题三路融合检索,返回最相关记忆(含正文 + [[link]] 关联)。

当用户问"之前 / 上次 / 有没有记录 / 回忆 / 召回 / 历史决策 / 踩过的坑"时调用。 每条记忆若 content 含 [[其他记忆标题]],返回时附 links 字段(关联记忆 id/title/category)。

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYes
top_kNo
categoryNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

B3.4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It discloses that it returns memories with links if content contains [[link]] syntax, but does not detail fusion algorithm, auth requirements, or rate limits. Adequate but not comprehensive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences plus a third about links; no wasted words. Could be improved by structuring as bullet points for scanning, but overall efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given that output schema exists (covering return values) and there are no annotations, the description covers purpose, usage, and link behavior. However, it omits details about the fusion method and does not explain all parameters, leaving moderate gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, and the description does not explain individual parameters (query, top_k, category) beyond implying query as the user's question. top_k and category are left to the schema defaults. Insufficient compensation for the lack of schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it is a retrieval tool using semantic+keyword+title fusion, returning memories with links. The verb '检索' (retrieve) and resource '记忆' (memories) are specific, but it does not explicitly distinguish from sibling 'search_memories'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly tells when to call (user asking about past records, historical decisions, pitfalls) via example phrases. Lacks when-not-to-use or alternative tool references, but the context is clearly conveyed.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

rememberA

存储一条持久化记忆(SQLite+Chroma+Markdown 三处同步,自动 embed)。

当用户说"记住 / 记下 / 沉淀 / 保存"某条信息时调用。content 中可用 [[其他记忆标题]] 引用已有记忆,recall 时会解析为关联记忆。 category:user(用户偏好)/ project(项目知识)/ process(工作过程)/ agent(Agent 协作)。 scope:user / project / session。

ParametersJSON Schema
NameRequiredDescriptionDefault
tagsNo
scopeNoproject
titleYes
contentYes
categoryYes

TDQS

A4.4/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It discloses multi-sync storage, auto-embedding, and the ability to reference other memories. It does not mention return values or error handling, but for a create operation, the disclosed behavior is adequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise at three sentences, each sentence adds value: first sentence states core function, second gives usage trigger, third explains advanced features (references, category, scope). No redundant words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 5 parameters, no output schema, and no annotations, the description covers purpose, usage, and parameter semantics adequately. It does not describe return values or success/failure, but for a simple storage tool, the information provided is sufficient for an AI agent to use it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 0% description coverage, so the description must compensate. It explains the category values (user/project/process/agent) and scope values (user/project/session), and notes that content can reference other memories. It does not detail title or tags beyond their names, but adds significant value overall.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states the tool stores a persistent memory (verb+resource) with specific storage backends and auto-embedding. It distinguishes from siblings like recall and forget by providing usage triggers (when user says 'remember/note/save'). The purpose is specific and clear.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states when to call the tool (when user says certain phrases). It implies context for use but does not explicitly exclude scenarios or mention alternatives like update_memory. However, the sibling list provides differentiation, and the trigger phrases are helpful guidelines.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_memoriesA

按分类 / 标签 / 来源 Agent 结构化过滤(不含正文)。需精确筛选时调用。

ParametersJSON Schema
NameRequiredDescriptionDefault
tagNo
agentNo
limitNo
categoryNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the tool filters only metadata ('不含正文'), which is a critical behavioral trait. However, it does not mention read-only nature, pagination, sorting, or required permissions, leaving gaps in transparency for a safe invocation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise: two short sentences with no redundancy. It front-loads the key filtering dimensions and the exclusion of body content, then provides a usage directive. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of an output schema (which likely documents return values), the description adequately covers the filtering scope and behavioral note (no body). It lacks details on combining filters, pagination, or default limit behavior, but the schema and output schema partially fill these gaps. Overall, sufficient for a focused filter tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description references three of four parameters (category, tag, agent) by their filtering roles, adding meaning beyond the bare property names in the schema. However, the 'limit' parameter is not mentioned, and with 0% schema description coverage, the description does not fully compensate by explaining parameter types, constraints, or how to combine filters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool filters memories by category, tag, and source agent, and explicitly notes it excludes body content. The phrase '需精确筛选时调用' (call when precise filtering is needed) differentiates it from semantic or list operations, making the purpose very specific and distinguishable from siblings like 'recall' or 'list_memories'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says '需精确筛选时调用', guiding the agent to use this tool when precise structural filtering is required. It implies not for fuzzy or semantic search, though it does not explicitly name alternatives or state when not to use it. The context is clear enough for an agent to choose appropriately among siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

update_memoryA

更新已有记忆;改 content 会重算向量并刷新 Markdown。修改 / 补充已有记忆时调用。

ParametersJSON Schema
NameRequiredDescriptionDefault
idYes
tagsNo
scopeNo
titleNo
contentNo
categoryNo

TDQS

A4.2/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Given no annotations, the description carries full burden. It discloses that changing content triggers vector recalculation and Markdown refresh, which is a key behavioral trait beyond a simple update. It could mention other aspects like idempotency or auth needs, but the disclosed behavior adds value.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences, front-loaded with the action and key behavior, followed by usage guidance. No wasted words; every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is adequate for a simple update tool. It covers purpose, usage, and a key behavioral effect. However, it does not mention return values (no output schema) and omits that 'id' is required, but these gaps are minor given the tool's simplicity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It adds meaning to the 'content' parameter by noting it triggers recalculation, but does not explain other parameters (id, tags, scope, title, category). This is partial compensation, leading to a score of 3 (baseline 4 with no param info is not fully met).

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Update existing memory' and specifies that changing content recalculates vectors and refreshes Markdown. It distinguishes from siblings like 'remember' (create) and 'get_memory' (read) by stating 'call when modifying/supplementing existing memory'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says 'call when modifying/supplementing existing memory', which provides clear context for when to use this tool. It does not explicitly mention when not to use it, but the sibling context implies differentiation from creation or retrieval tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

who_am_iA

返回当前 Agent 标识、项目根、数据目录与各分类记忆数量。会话开始时先调用,了解当前 agent 与记忆库概况。

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A4.6/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It clearly indicates a read-only information retrieval, but could explicitly state it does not modify state. Given the obvious safe nature, score is high.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences: first defines output, second gives usage instruction. No wasted words, front-loaded with purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Lists returned items satisfactorily for a simple info tool. No output schema, but description covers key contents. Could add more on output format but acceptable.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters, baseline score of 4. Description correctly implies no input needed, and schema coverage is 100%.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool returns specific information: Agent identity, project root, data directory, and memory counts by category. It uses a specific verb '返回' (returns) and resource, distinguishing it from sibling tools like 'get_memory' or 'remember'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit guidance provided: '会话开始时先调用' (call at the start of a session). This tells the agent precisely when to use this tool, though it does not mention alternatives—but the sibling tools are different in purpose.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

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

  1. 8 tool updatesv0.1.1
    • First observedforget
    • First observedget_memory
    • First observedlist_memories
    • First observedrecall
    • First observedremember
    • First observedsearch_memories
    • First observedupdate_memory
    • First observedwho_am_i

TDQS

A4/5.0

Scored across 8 tools

Disambiguation5/5

Each tool has a clearly distinct purpose: forget (delete), get_memory (by id), list_memories (filtered browsing), recall (semantic search), remember (create), search_memories (structured filter), update_memory (modify), who_am_i (identity). Despite some overlap between list and search, descriptions differentiate them well.

Naming Consistency3/5

Naming conventions are mixed: three tools are single verbs (forget, recall, remember), four are verb_noun (get_memory, list_memories, search_memories, update_memory), and one is a phrase (who_am_i). This inconsistency, while readable, lacks a uniform pattern.

Tool Count5/5

With 8 tools, the set is well-scoped for a memory server. Each tool serves a distinct CRUD or auxiliary role, covering creation, retrieval (multiple methods), update, deletion, and system info. No tool seems superfluous or missing.

Completeness5/5

The tool surface provides full lifecycle coverage: remember (create), get_memory/list/recall/search/who_am_i (read), update_memory (update), forget (delete). It also supports linking via recall. No obvious gaps for the intended personal memory domain.

Maintenance

ActivityStale
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    D
    maintenance
    Enables AI coding agents to retrieve and manage code context with hybrid search, project memory, and observability via MCP tools.
    29
    MIT
  • A
    license
    B
    quality
    B
    maintenance
    A shared, persistent MCP memory server for coding agents that enables storing and retrieving project decisions and context across different tools like Claude Code, Codex, and Cursor using semantic vector search.
    8
    MIT
  • A
    license
    Not graded
    quality
    B
    maintenance
    Enables AI coding agents to maintain a private, local-first persistent memory by automatically saving, searching, and retrieving structured project memories through MCP, with hybrid keyword and embedding search, feedback-driven ranking, and no cloud dependency.
    1
    MIT