A persistent memory and knowledge graph service for storing learnings, entities, and decisions with search and retrieval capabilities
This MCP server exposes a remote memory/knowledge graph API through HTTP. Analysis of 12 tools reveals SIGNIFICANT GAPS in schema completeness, description quality, and adherence to tool design patterns. The server declares tool names and basic descriptions but lacks proper input schemas, parameter-level documentation, output schema specification, and error guidance. Multiple tools appear to have DUPLICATE or NEAR-DUPLICATE functionality (remember/recall vs store/search vs learn vs log_decision/decide), violating the single-responsibility principle. Descriptions are present but generic (avg ~45 chars, well below the 194-char baseline). No evidence of error handling guidance, permission gates, or schema composition patterns. Tools are called against a remote API (https://memory.studiomeyer.io) with no server-side implementation visible, this appears to be a CLIENT WRAPPER, not an MCP server implementation. Cannot verify actual tool registration, schema enforcement, or error handling at the MCP layer.
Create or update an entity in the knowledge graph
Create or update an entity in the knowledge graph
Log a decision with title, decision, and reasoning
Import and analyze ChatGPT conversation history
Store a learning in memory with category and content
Log a decision with title, decision, and reasoning
Search persistent memory for relevant information.
DUPLICATE TOOL FUNCTIONALITY: 'remember' (store learning) + 'store_learning' (store learning) + 'learn' (store learning) + 'store' (store content in memory) are functionally identical or near-identical. Similarly, 'recall' and 'search' both search memory; 'create_entity' and 'createEntity' differ only in naming convention; 'log_decision' and 'decide' are redundant. This violates the single-responsibility principle and wastes LLM reasoning cycles deciding between equivalent tools. [Source: pattern:composition]
MISSING OUTPUT SCHEMA DOCUMENTATION: Tools like 'search', 'recall', 'create_entity', 'learn', and 'import_chatgpt' have NO documented output schema. LLMs cannot infer what fields to extract from responses or what IDs/references are available for downstream calls. The examples show raw JSON responses but no formal specification of return structure. [Source: pattern:response-shaper]
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-23 | D | 54 | 2026-07-28+ | v2 |
Store a learning in persistent memory.
Search persistent memory for relevant information
Store content in persistent memory with optional category and agent ID
Store a learning with category and content
Track a person, tool, or concept in the Knowledge Graph.
GENERIC DESCRIPTIONS LACK LLM GUIDANCE: Tool descriptions are 40-60 chars (baseline 194 chars). E.g., 'search' = 50 chars, 'recall' = 60 chars, 'store' = 50 chars. No guidance on WHEN to call a tool vs alternatives, WHAT results to expect, or HOW to use the return value. LLMs cannot distinguish 'search' from 'recall' based on current descriptions. [Source: pattern:tool-description]
INCONSISTENT NAMING CONVENTIONS: Python examples use snake_case (store_learning, create_entity, log_decision) while TypeScript uses camelCase (createEntity). The MCP tool list includes BOTH (create_entity + createEntity, log_decision + decide, remember + store + learn). This forces the LLM to handle multiple aliases for the same semantic action and violates tool naming clarity. [Source: pattern:tool]
NO ERROR HANDLING GUIDANCE: No evidence of error messages that tell the LLM what to do next. The examples show raw HTTP calls with no try-catch or recovery guidance. LLMs receive raw API errors (if any) with no categorization as retryable vs fatal, no suggestions for self-correction, and no alternative action guidance. [Source: pattern:recovery-guide]
PARAMETER DESCRIPTIONS MISSING OR MINIMAL: Params like 'category' (used in 4 tools), 'entity_type', 'query', 'content', 'name' have descriptions but lack constraints, valid values, or range info. E.g., 'category' has no default behavior explained in some tools (default='insight' in others), LLMs cannot infer which. [Source: pattern:tool-description, pattern:constrained-input]
API KEY EXPOSURE RISK: Examples hardcode API_KEY in source and pass it via Bearer token in headers. While the examples show env var fallback (os.getenv), the practice of passing auth credentials through request headers is standard HTTP, but there is no evidence of server-side secret injection or vault integration at the MCP layer. If this MCP server wraps the remote API, credentials should be managed server-side, not passed through agent parameters. [Source: pattern:secret-injection]
NO PAGINATION SUPPORT DOCUMENTED: 'search' and 'recall' accept a 'limit' param in examples but no offset/page/cursor params are visible in the provided schemas. No documentation of total count, next_cursor, or pagination behavior. Large memory stores could return massive results that exhaust context windows. [Source: pattern:paginated-result]
NO SCHEMA VALIDATION VISIBLE: Input schemas are declared but no evidence of server-side validation, constraint enforcement, or validation error messages. LLMs will pass invalid categories, non-existent entity_types, or malformed queries without feedback on how to correct them. [Source: pattern:constrained-input]
MISSING TOOL ANNOTATIONS: No evidence of readOnlyHint, destructiveHint, or idempotentHint annotations in tool definitions. This prevents agents from understanding which tools are safe to retry, which modify state, and which are safe for dry-runs. E.g., 'import_chatgpt' is destructive (adds to memory) but has no annotation. [Source: pattern:tool]