Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Memorable MCP Server recall my pinned context and find notes on database migrations"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Official TypeScript-based Model Context Protocol (MCP) server for Memorable, the local-first AI memory management studio and developer workbench.
This server enables AI assistants and autonomous agents (Antigravity, Claude Desktop, Cursor, and custom MCP clients) to seamlessly query, author, recall, and vectorize persistent context, architectural guidelines, user preferences, and memories through the Memorable REST API and pgvector semantic engine.
Full MCP Capabilities Suite:
17 Comprehensive Tools:
Vector & Semantic Search: Unified pgvector semantic search (memorable_search), nearest neighbor discovery (memorable_find_neighbors), and on-demand vectorization (memorable_generate_embedding).
Composite Context Recall: memorable_recall_context retrieves all standing pinned memories and executes semantic search in parallel, returning deduplicated, ranked context in one call.
Memory Lifecycle: Full CRUD (memorable_list_memories, memorable_get_memory, memorable_create_memory, memorable_update_memory, memorable_delete_memory).
Safe Appending: Append Markdown updates and logs without overwriting prior body (memorable_append_to_memory).
Workspace Curation: Pin toggle (memorable_toggle_pin) and pinned reordering (memorable_reorder_pinned).
Context Files: File attachments with multipart upload from disk or base64 (memorable_list_attachments, memorable_upload_attachment, memorable_delete_attachment).
Markdown & System: Redcarpet GFM rendering (memorable_render_markdown) and workbench metrics (memorable_get_stats).
5 MCP Resources: Direct URI inspection via:
memorable://stats: Workbench counts (memories, pinned memories, attachments).
memorable://memories: Index list of all active memories.
memorable://memories/pinned: Combined Markdown document of all pinned memories for instant standing instruction loading.
memorable://memories/{id}: Full memory Markdown body with YAML metadata frontmatter.
memorable://memories/{id}/neighbors: JSON nearest semantic neighbor memories with cosine similarity scores.
Context Recall & Dynamic Prompts:
memorable_recall_context: Synthesizes pinned context and semantic search matches into an executive context brief.
memorable_author_memory: Interactive engineering guide to draft structured technical memories and ADRs.
memorable_use_memory_template: Executes {{variable}} templates from memory bodies.
Dynamic Memory Prompts (memorable_<id>_<slug>): On startup, saved memories with {{variables}} are automatically discovered and exposed as typed native MCP prompts.
Stdio Transport: Low-latency JSON-RPC 2.0 communication over standard input/output.
OpenAPI 3.1 Contract: Strongly typed client generated directly against Memorable's OpenAPI 3.1.0 specification with runtime Zod validation.
Zero Friction Setup: Works out of the box with your local Memorable Rails server (http://localhost:3000).
Related MCP server: BuildAutomata Memory MCP Server
flowchart LR
Client["AI Agent / Desktop Client<br/>(Antigravity, Claude, Cursor)"]
Stdio["Stdio Transport<br/>(JSON-RPC 2.0)"]
MCPServer["Memorable MCP Server<br/>(@modelcontextprotocol/sdk)"]
APIClient["Typed MemorableClient<br/>(Node native fetch)"]
MemorableAPI["Memorable Rails 8.1 API<br/>(http://localhost:3000/api/v1)"]
PGVector[("PostgreSQL + pgvector<br/>(1024-dim HNSW + Ollama)")]
Client <-->|MCP Protocol| Stdio
Stdio <--> MCPServer
MCPServer -->|17 Tools / 5 Resources / Prompts| APIClient
APIClient <-->|REST JSON & Multipart| MemorableAPI
MemorableAPI <--> PGVectorNode.js: v18.0.0 or higher (recommended: Node 20+)
Memorable: Running locally (default: http://localhost:3000)
Ollama: Running locally with qwen3-embedding:0.6b (for vector embeddings)
# Clone repository
git clone https://github.com/leouofa/memorable-mcp.git
cd memorable-mcp
# Install dependencies
npm install
# Build the TypeScript distribution
npm run buildThe server can be configured via environment variables or command-line arguments:
Option | Environment Variable | CLI Flag | Default | Description |
API URL |
|
|
| Memorable API base URL |
API Key |
|
| (none) | Optional Bearer token for authentication |
Timeout |
|
|
| HTTP request timeout in milliseconds |
Memory Sync | — |
|
| Eagerly register saved Memorable memories as prompts at startup |
Add to your local MCP server configuration in Antigravity (~/.gemini/antigravity/mcp_config.json or project settings):
{
"mcpServers": {
"memorable": {
"command": "node",
"args": ["/Users/leonid/src/memorable-mcp/dist/index.js"],
"env": {
"MEMORABLE_API_URL": "http://localhost:3000"
}
}
}
}Add memorable to your claude_desktop_config.json (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):
{
"mcpServers": {
"memorable": {
"command": "node",
"args": ["/absolute/path/to/memorable-mcp/dist/index.js"],
"env": {
"MEMORABLE_API_URL": "http://localhost:3000"
}
}
}
}Add to your .cursor/mcp.json:
{
"mcpServers": {
"memorable": {
"command": "node",
"args": ["/absolute/path/to/memorable-mcp/dist/index.js"],
"env": {
"MEMORABLE_API_URL": "http://localhost:3000"
}
}
}
}Tool | Description | Key Parameters |
| Unified pgvector semantic & keyword search |
|
| Composite retrieval: pinned memories + semantic matches |
|
| List and filter memories across the workspace |
|
| Retrieve memory Markdown body, attachments, & embedding status |
|
| Create a memory (automatically enqueues vector embedding) |
|
| Update a memory's title, Markdown body, or pin |
|
| Safely append Markdown to an existing memory |
|
| Delete a memory and its attachments permanently |
|
| Find nearest semantic neighbors via 1024-dim cosine distance |
|
| Generate or refresh 1024-dim vector embedding via Ollama |
|
| Toggle workspace pin status for a memory |
|
| Reorder sequential pinned memories |
|
| List files attached to a memory |
|
| Attach files (paths or base64) to a memory |
|
| Purge an attachment from a memory |
|
| Render GFM into sanitized HTML via Redcarpet |
|
| Inspect platform metrics (memories, pinned, attachments) | (none) |
URI Pattern | MIME Type | Description |
|
| Workbench metrics (total memories, pinned memories, attachments) |
|
| Index list of all active memories in the workspace |
|
| Combined Markdown document of all pinned memories (standing context) |
|
| Full memory Markdown body with YAML metadata frontmatter |
|
| Nearest semantic vector neighbors and cosine similarity scores |
memorable_recall_context: Synthesizes standing pinned instructions and top semantic search matches into a structured AI context briefing for any task or topic.
memorable_author_memory: Interactive engineering guide assisting agents and users in authoring structured ADRs, architecture guidelines, user preferences, or troubleshooting knowledge.
memorable_use_memory_template: Dynamically loads any Memorable memory by ID and populates {{variable}} placeholders from a variables JSON dictionary.
Dynamic Memory Prompts (memorable_<id>_<slug>): On startup, saved Memorable memories containing {{variables}} are automatically discovered and registered as native MCP prompts.
# Regenerate TypeScript types from openapi.json
npm run typegen
# Typecheck with TypeScript
npm run typecheck
# Run unit and integration tests (Vitest)
npm test
# Build production bundle
npm run buildMIT © Leonid Medovyy
Safely append Markdown content to an existing memory without overwriting its prior body
Inputs: id (required), content (required), separator, render_markdown.
Create a new memory in Memorable (automatically enqueues vector embedding in the background)
Inputs: title (required), body, pinned, pinned_position.
Purge and delete an attachment from a memory
Inputs: memory_id (required), attachment_id (required).
Permanently delete a memory and its associated attachments from Memorable
Inputs: id (required).
Find nearest semantic neighbor memories via 1024-dimensional pgvector cosine distance
Inputs: id (required), limit.
Generate or refresh the 1024-dimensional vector embedding for a memory using Ollama (synchronous or async background job)
Inputs: id (required), async.
Retrieve a memory's full Markdown content, embedding status, attachments, and optional rendered HTML
Inputs: id (required), render_markdown.
Get system statistics from Memorable (total memories, pinned memories, and attachments count)
Inputs: no named parameters.
List file attachments and download URLs associated with a memory
Inputs: memory_id (required).
List, filter, and paginate memories in Memorable with optional query, mode, and pinned filters
Inputs: q, mode, limit, offset, +1 more.
Recalls standing pinned memories combined with relevant semantic search matches in one unified context payload
Inputs: mode, limit, query, include_pinned.
Render Markdown text to sanitized HTML using Memorable's Redcarpet GitHub-flavored markdown pipeline
Inputs: text (required).
Update the sequential order of pinned memories displayed at the top of the Memorable workspace
Inputs: memory_ids (required).
Unified vector and keyword search across Memorable memories using pgvector cosine similarity or text matching
Inputs: q (required), mode, limit.
Toggle the pinned status of a memory in the Memorable workspace
Inputs: id (required).
Update a memory's title, Markdown body, or pinned status in Memorable
Inputs: id (required), body, title, pinned, +2 more.
Upload one or more files to attach to a memory in Memorable (accepts local file paths or base64 data)
Inputs: files (required), memory_id (required).
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 17 tools
Most tools have clear, distinct purposes, and the memorable_ prefix plus descriptive names helps selection. There is some intentional overlap between search, list_memories-with-query, and recall_context, and between toggle_pin and update_memory's pinned field, but the descriptions make the boundaries reasonably clear.
All tools use the same memorable_ prefix and snake_case naming convention, typically verb_noun or verb_object. The pattern is highly predictable across memory, attachment, embedding, pin, and utility tools.
Seventeen tools is slightly above the ideal compact range but still reasonable for a memory workspace with search, embeddings, pins, attachments, rendering, and stats. Each tool has a plausible role, though a few convenience tools could be consolidated.
The surface covers the full memory lifecycle: create, read, update, append, delete, search, semantic neighbors, embeddings, pinned ordering, attachments, rendering, and stats. No obvious dead ends remain for core memory-management workflows.
Hosted persistent memory with semantic search, importance and TTL for AI agents.
Persistent memory for AI agents. Semantic search, memory graph, W3C DID identity.
Persistent memory for AI agents. EU-hosted, privacy-first, hybrid recall, contradiction detection.
Persistent memory for AI agents. Search and store durable facts, preferences and decisions.
