Power your agent
The publisher's own command. Not a PlugMCP endpoint.
Host a copy with our keys and logs.
docker run -i --rm docker.io/writenotenow/memory-journal-mcp:v1.1.3Claude Code has no install link for a local command. Copy the command below and run it in a terminal.
claude mcp add io.github.neverinfamous-memory-journal-mcp -- docker run -i --rm docker.io/writenotenow/memory-journal-mcp:v1.1.3Run in a terminal.
{ "mcpServers": { "io.github.neverinfamous-memory-journal-mcp": { "command": "docker", "args": [ "run", "-i", "--rm", "docker.io/writenotenow/memory-journal-mcp:v1.1.3" ] } }}claude_desktop_config.json
Remote URL or a command on your machine? How the two installs differ
Run on PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
LaunchšÆ AI Context + Project Intelligence: Bridge disconnected AI sessions with persistent project memory and automatic session handoff ā with full GitHub workflow integration.
š Quick Deploy:
npm install -g memory-journal-mcpWhen managing large projects with AI assistance, you face a critical challenge:
Memory Journal solves this by acting as your project's long-term memory, bridging the gap between fragmented AI sessions.
Experience true context-aware development:
/issue-triage workflow on the top priority ticket in the Kanban board." (GitHub operations)73 MCP Tools Ā· 19 Workflow Prompts Ā· 46 Resources Ā· 10 Tool Groups Ā· Code Mode Ā· GitHub Commander (Issue Triage, PR Review, Milestone Sprints, Security/Quality/Perf Audits) Ā· GitHub Integration (Issues, PRs, Actions, Kanban, Milestones, Insights) Ā· Team Collaboration (Shared DB, Vector Search, Cross-Project Insights, Hush Protocol Flags)
flowchart TB
subgraph Session["š¤ AI Session Start"]
Briefing["š Read Briefing<br/>(memory://briefing)"]
end
subgraph Core["š Journal Operations"]
Create["Create Entry"]
Retrieve["Retrieve & Search"]
Link["Link Entries"]
end
subgraph Search["š Hybrid Search"]
FTS["Keyword (FTS5)"]
Semantic["Semantic (Vector)"]
DateRange["Date Range"]
RRF["Reciprocal Rank Fusion"]
end
subgraph GitHub["š GitHub Integration"]
Issues["Issues & Milestones"]
PRs["Pull Requests"]
Actions["GitHub Actions"]
Kanban["Kanban Boards"]
Insights["Repository Insights"]
end
subgraph Outputs["š Outputs"]
Reports["Standups & Retrospectives"]
Graphs["Knowledge Graphs"]
Timeline["Project Timelines"]
end
Session --> Core
Core --> Search
Core <--> GitHub
Search --> Outputs
GitHub --> Outputs
Suggested Rule (Add to AGENTS.md, GEMINI.md, system prompts, etc.)
š MANDATORY SESSION START ROUTINE
Before addressing the user's first request in a session/thread, complete these steps:
Read the briefing using the read_resource tool: memory://briefing/{repo_name}.
repo_name from context of user's prompt. Use memory://briefing as fallback only if necessary.Your first response MUST begin with the entire briefing content. Use this format:
š Briefing loaded ā
{repo_name}{paste ENTIRE briefing here} (It isn't always easy for users to access in IDEs)
Then address the user's request below the briefing.
Do NOT autonomously resume work on issues mentioned in the briefing.
[!IMPORTANT] All shortcuts and tool groups include Code Mode (
mj_execute_code) by default for token-efficient operations. To exclude it, add-codemodeto your filter:--tool-filter starter,-codemode
Control which tools are exposed via MEMORY_JOURNAL_MCP_TOOL_FILTER (or CLI: --tool-filter):
Filter Syntax: shortcut or group or tool_name (whitelist mode) Ā· -group (disable group) Ā· -tool (disable tool) Ā· +tool (re-enable after group disable)
Custom Selection: List individual tool names to create your own whitelist: --tool-filter "create_entry,search_entries,semantic_search"
Groups: core, search, analytics, relationships, io, admin, github, backup, team, codemode
find-related - Discover connected entries via semantic similarityprepare-standup - Daily standup summariesprepare-retro - Sprint retrospectivesweekly-digest - Day-by-day weekly summariesanalyze-period - Deep period analysis with insightsgoal-tracker - Milestone and achievement trackingget-context-bundle - Project context with Git/GitHub/Kanbanget-recent-entries - Formatted recent entriesproject-status-summary - GitHub Project status reportspr-summary - Pull request journal activity summarycode-review-prep - Comprehensive PR review preparationpr-retrospective - Completed PR analysis with learningsactions-failure-digest - CI/CD failure analysisproject-milestone-tracker - Milestone progress trackingconfirm-briefing - Acknowledge session context to usersession-summary - Create a session summary entry with accomplishments, pending items, and next-session contextteam-session-summary - Create a retrospective team session summary entry securely isolated to the team databaseadversarial-plan-review - Multi-pass adversarial plan review with structured dimensions, scoring rubric, and prior plan contextflag-dashboard - Triage active flags with priority assessment and resolution guidance29 Static Resources (appear in resource lists):
memory://briefing - Session initialization: compact context for AI agents (~350 tokens) ā includes server version, surface area (tools/resources/prompts), test health, unreleased changes, analytics, localTime, and optional activeFlagsmemory://instructions - Behavioral guidance: complete server instructions for AI agentsmemory://recent - 10 most recent entriesmemory://significant - Significant milestones and breakthroughsmemory://graph/recent - Live Mermaid diagram of recent relationshipsmemory://health - Server health & diagnosticsmemory://graph/actions - CI/CD narrative graphmemory://actions/recent - Recent workflow runsmemory://tags - All tags with usage countsmemory://statistics - Journal statisticsmemory://rules - User rules file content for agent awarenessmemory://workflows - Available agent workflows summarymemory://skills - Agent skills index (names, paths, excerpts)memory://github/status - GitHub repository status overviewmemory://github/insights - Repository stars, forks, and 14-day traffic summarymemory://github/milestones - Open milestones with completion percentagesmemory://team/recent - Recent team entries with author attributionmemory://team/statistics - Team entry counts, types, and author breakdownmemory://help - Tool group index with descriptions and tool countsmemory://metrics/summary - Aggregate tool call metrics since server start (calls, errors, token estimates, duration) ā HIGH prioritymemory://metrics/tokens - Per-tool token usage breakdown sorted by output token cost ā MEDIUM prioritymemory://metrics/system - Process-level metrics: memory (MB), uptime (s), Node.js version, platform ā MEDIUM prioritymemory://metrics/users - Per-user call counts (populated when OAuth user identifiers are present) ā LOW prioritymemory://audit - Last 50 write/admin tool call entries from the JSONL operational telemetry log (requires AUDIT_LOG_PATH)memory://flags - Active (unresolved) team flags dashboard (requires TEAM_DB_PATH)memory://flags/vocabulary - Configured flag vocabulary termsmemory://flags/history - Recently resolved flags with resolution details and avg time-to-resolution (last 7 days)17 Template Resources (9 base templates + 8 dynamic {repo} variants):
memory://projects/{number}/timeline - Project activity timelinememory://issues/{issue_number}/entries - Entries linked to issuememory://prs/{pr_number}/entries - Entries linked to PRmemory://prs/{pr_number}/timeline - Combined PR + journal timelinememory://kanban/{project_number} - GitHub Project Kanban boardmemory://kanban/{project_number}/diagram - Kanban Mermaid visualizationmemory://milestones/{number} - Milestone detail with completion progressmemory://help/{group} - Per-group tool reference with parameters and annotationsmemory://briefing/{repo} - Context targeted to a specific repositoryNote: The memory://github/status, memory://github/insights, memory://github/milestones, and memory://milestones/{number} resources also accept an optional /{repo} path suffix for cross-repo targeting.
Code Mode (mj_execute_code) is a revolutionary approach that dramatically reduces token usage by up to 90% and is included by default in all presets. Instead of spending thousands of tokens on sequential tool calls, AI agents use a single sandboxed execution to reason faster.
Code executes in a worker_threads sandbox designed as a secure multi-tenant process isolation environment. All mj.* API calls execute against the journal within the sandbox, providing:
eval() and Function() construction from strings disabled at the V8 engine level via codeGeneration: { strings: false, wasm: false }require(), process, eval(), Reflect.*, Symbol.*, new Proxy(), and filesystem/network accessProxy: undefined in the sandbox prevents meta-object protocol abusemj.* (e.g., mj.core.createEntry(), mj.search.searchEntries(), mj.github.getGithubIssues(), mj.team.passTeamFlag())--tool-filter readonly safely halts the sandbox to prevent execution, returning a structured { success: false, error: "..." } response to the agent instead of a raw MCP protocol exception.Run with only Code Mode enabled ā a single tool that provides access to all 69 tools' worth of capability through the mj.* API:
{
"mcpServers": {
"memory-journal-mcp": {
"command": "memory-journal-mcp",
"args": ["--tool-filter", "codemode"]
}
}
}
This exposes just mj_execute_code. The agent writes JavaScript against the typed mj.* SDK ā composing operations across all 10 tool groups and returning exactly the data it needs ā in one execution. This mirrors the Code Mode pattern pioneered by Cloudflare for their entire API: fixed token cost regardless of how many capabilities exist.
If you prefer individual tool calls, exclude codemode:
{
"args": ["--tool-filter", "starter,-codemode"]
}
The Hush Protocol reimagines team collaboration for AI-augmented workflows by replacing noisy Slack/Teams messages with structured, machine-actionable flags.
When you encounter a blocker, need a review, or want to broadcast a milestone, your AI agent can raise a flag in the shared Team Database:
memory://briefing payload for all team members. When another developer's agent starts a session, it immediately sees your blockers and can help resolve them autonomously.blocker, needs_review, help_requested, fyi). You can customize your team's vocabulary via the --flag-vocabulary configuration.needs_review flags to understand how architectural blockers were conquered.prepare-standup and prepare-retro prompts, so your daily standups and sprint retrospectives always surface outstanding blockers.team_list_flags. Update metadata (escalate severity, reassign, add links) or reopen resolved flags via team_update_flag. Track resolution velocity, per-user workload, and trends with team_get_flag_analytics.Dashboard & Operations: Read memory://flags for an active dashboard, memory://flags/history for recently resolved flags, use the /flag-dashboard prompt for guided triage with severity grouping and staleness detection, and use mj.team.passTeamFlag() / mj.team.resolveTeamFlag() / mj.team.teamListFlags() / mj.team.teamUpdateFlag() / mj.team.teamGetFlagAnalytics() to manage flags programmatically in Code Mode.
npm install -g memory-journal-mcp
git clone https://github.com/neverinfamous/memory-journal-mcp.git
cd memory-journal-mcp
npm install
npm run build
Add this to your ~/.cursor/mcp.json, Claude Desktop config, or equivalent:
{
"mcpServers": {
"memory-journal-mcp": {
"command": "memory-journal-mcp",
"env": {
"GITHUB_TOKEN": "ghp_your_token_here",
"PROJECT_REGISTRY": "{\"my-repo\":{\"path\":\"/path/to/your/git/repo\",\"project_number\":1}}",
"ALLOWED_IO_ROOTS": "/path/to/your/git/repo"
}
}
}
}
Showcasing the full power of the server, including Multi-Project Routing, Team Collaboration, Copilot awareness, and Context Injections.
{
"mcpServers": {
"memory-journal-mcp": {
"command": "memory-journal-mcp",
"env": {
"DB_PATH": "/path/to/your/memory_journal.db",
"TEAM_DB_PATH": "/path/to/shared/team.db",
"GITHUB_TOKEN": "ghp_your_token_here",
"PROJECT_REGISTRY": "{\"my-repo\":{\"path\":\"/path/to/repo\",\"project_number\":1},\"other-repo\":{\"path\":\"/path/to/other\",\"project_number\":5}}",
"ALLOWED_IO_ROOTS": "/path/to/repo,/path/to/other,/path/to/your/skills",
"AUTO_REBUILD_INDEX": "true",
"MEMORY_JOURNAL_MCP_TOOL_FILTER": "codemode",
"CODEMODE_INTERNAL_FULL_ACCESS": "true",
"BRIEFING_ENTRY_COUNT": "3",
"BRIEFING_SUMMARY_COUNT": "1",
"BRIEFING_INCLUDE_TEAM": "true",
"BRIEFING_ISSUE_COUNT": "3",
"BRIEFING_PR_COUNT": "3",
"BRIEFING_PR_STATUS": "true",
"BRIEFING_WORKFLOW_COUNT": "3",
"BRIEFING_WORKFLOW_STATUS": "true",
"BRIEFING_COPILOT_REVIEWS": "true",
"RULES_FILE_PATH": "/path/to/your/RULES.md",
"SKILLS_DIR_PATH": "/path/to/your/skills",
"MEMORY_JOURNAL_WORKFLOW_SUMMARY": "/deploy: prod deployment | /audit: security scan",
"AUDIT_LOG_PATH": "/path/to/your/mcp-audit.jsonl",
"TEAM_AUTHOR": "your_username"
}
}
}
}
š” Tip: Optimize your context window! Journal entries (
BRIEFING_ENTRY_COUNT) capture frequent, granular actions (e.g. bug fixes, implementation steps). Session summaries (BRIEFING_SUMMARY_COUNT) surface high-level retrospectives meant to pass strategic context continuously across distinct AI sessions. Use both appropriately to keep the agent briefing highly focused!
The memory://briefing resource is dynamically assembled at each session start to provide rich, token-efficient ambient context. By default, it automatically surfaces:
memory://metrics/summary breadcrumbs.You control exactly what additional content your agent sees across three dimensions:
Context Injections: Set RULES_FILE_PATH and SKILLS_DIR_PATH to surface user rules and agent skills as companion resources (memory://rules, memory://skills) alongside the briefing.
Repo Targeting: In multi-repo setups, agents read memory://briefing/{repo} to get a briefing scoped to a specific repository registered in PROJECT_REGISTRY.
Minimal (fast sessions) ā Reduce briefing to bare essentials for quick interactions:
"BRIEFING_ENTRY_COUNT": "1",
"BRIEFING_SUMMARY_COUNT": "0",
"INSTRUCTION_LEVEL": "essential"
Full Context (onboarding agents) ā Maximize context for agents unfamiliar with the project:
"BRIEFING_ENTRY_COUNT": "5",
"BRIEFING_SUMMARY_COUNT": "3",
"BRIEFING_INCLUDE_TEAM": "true",
"BRIEFING_ISSUE_COUNT": "5",
"BRIEFING_PR_COUNT": "3",
"BRIEFING_PR_STATUS": "true",
"BRIEFING_COPILOT_REVIEWS": "true",
"INSTRUCTION_LEVEL": "full"
DevOps-Heavy ā Emphasize CI/CD and GitHub state for infrastructure workflows:
"BRIEFING_WORKFLOW_COUNT": "5",
"BRIEFING_WORKFLOW_STATUS": "true",
"BRIEFING_ISSUE_COUNT": "3",
"BRIEFING_PR_COUNT": "3",
"BRIEFING_PR_STATUS": "true",
"BRIEFING_COPILOT_REVIEWS": "true"
Variants (modify the config above):
Restart your MCP client and start journaling!
š Security Posture: Stdio vs HTTP
- Stdio (Default): Runs implicitly within the secure boundaries of your local IDE or command-line environment. No explicit authentication is required because the execution context is already trusted.
- HTTP/SSE: Exposes the server over a network socket. By default, HTTP binds ONLY to
localhostand blocks wildcard CORS to prevent unauthorized access and CSRF attacks. Public network binding (--server-host 0.0.0.0) requires explicit authentication (--auth-tokenor--oauth-enabled). The server will throw a fatal error if you attempt to expose it publicly without securing it.
For remote access or web-based clients, run the server in HTTP mode:
memory-journal-mcp --transport http --port 3000
To bind to all interfaces (required for containers) and enable the automated proactive analytics scheduler (e.g. daily digest), you MUST provide an authentication token:
export MCP_AUTH_TOKEN="your_secure_random_token"
memory-journal-mcp --transport http --port 3000 --server-host 0.0.0.0 --digest-interval 1440
Endpoints:
Session Management: The server uses stateful sessions by default. Include the mcp-session-id header (returned from initialization) in subsequent requests.
--oauth-enabled)Example with curl:
Initialize session (returns mcp-session-id header):
curl -X POST http://localhost:3000/mcp \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}'
List tools (with session):
curl -X POST http://localhost:3000/mcp \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-H "mcp-session-id: YOUR_SESSION_ID" \
-d '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}'
For serverless deployments (Lambda, Workers, Vercel), use stateless mode:
memory-journal-mcp --transport http --port 3000 --stateless
When running in HTTP/SSE mode, enable periodic maintenance jobs with CLI flags. These jobs run in-process on setInterval ā no external cron needed.
Note: These flags are ignored for stdio transport because stdio sessions are short-lived (tied to your IDE session). For stdio, use OS-level scheduling (Task Scheduler, cron) or run the backup/cleanup tools manually.
memory-journal-mcp --transport http --port 3000 \
--backup-interval 60 --keep-backups 10 \
--vacuum-interval 1440 \
--rebuild-index-interval 720
Each job is error-isolated ā a failure in one job won't affect the others. Scheduler status (last run, result, next run) is visible via memory://health.
The GitHub tools (get_github_issues, get_github_prs, etc.) auto-detect the repository from your git context when PROJECT_REGISTRY is configured or the MCP server is run inside a git repository.
Multi-Project Workflows: For agents to seamlessly support multiple projects, provide PROJECT_REGISTRY.
When executing GitHub tools (issues, PRs, context, etc.), the server resolves repository context in this order:
repo string that matches a key in your PROJECT_REGISTRY, the server dynamically mounts the physical directory mapped to that project. It executes git commands locally and automatically infers the owner.owner and repo explicitly, those values override auto-detection for API calls.PROJECT_REGISTRY or explicit parameters, the server blocks execution and returns {requiresUserInput: true} to prompt the agent.When opening an issue or viewing/moving a Kanban card, the server needs a GitHub Project number. It determines this via:
project_number argument passed by the agent.repo string precisely matches an entry in your PROJECT_REGISTRY, seamlessly mapping it to its pre-configured project_number.DEFAULT_PROJECT_NUMBER if set.For production deployments, enable OAuth 2.1 authentication on the HTTP transport:
Supported Scopes:
Quick Start:
memory-journal-mcp --transport http --port 3000 \
--oauth-enabled \
--oauth-issuer https://auth.example.com/realms/mcp \
--oauth-audience memory-journal-mcp \
--oauth-jwks-uri https://auth.example.com/realms/mcp/protocol/openid-connect/certs
Or via environment variables:
export OAUTH_ENABLED=true
export OAUTH_ISSUER=https://auth.example.com/realms/mcp
export OAUTH_AUDIENCE=memory-journal-mcp
export OAUTH_CLOCK_TOLERANCE=5
memory-journal-mcp --transport http --port 3000
Note: OAuth is opt-in. When not enabled, the server falls back to simple token authentication via
MCP_AUTH_TOKENenvironment variable, or runs without authentication.
memory://briefing (or memory://briefing/{repo}) and shows project context/session-summary to capture progress and next-session contextexport GITHUB_TOKEN="your_token" # For Projects/Issues/PRs
Scopes: repo, project, read:org (org-level project discovery only)
Memory Journal provides a hybrid approach to GitHub management:
MCP Server Tools (Read + Kanban + Milestones + Issue Lifecycle):
get_github_issues / get_github_issue - Query issuesget_github_prs / get_github_pr - Query pull requestsget_github_context - Full repository contextget_kanban_board / add_kanban_item / move_kanban_item / delete_kanban_item - Kanban managementget_github_milestones / get_github_milestone - Milestone tracking with completion %create_github_milestone / update_github_milestone / delete_github_milestone - Milestone CRUDget_repo_insights - Repository traffic & analytics (stars, clones, views, referrers, popular paths)create_github_issue_with_entry / close_github_issue_with_entry - Issue lifecycle with journal linkingWhy this design? The MCP server focuses on value-added features that integrate journal entries with GitHub (Kanban views, Milestones, timeline resources, context linking). Standard GitHub mutations (create/close issues, merge PRs, manage releases) are handled directly by agents via
ghCLI.
The server natively bundles the github-commander agent skill (accessible via memory://skills/github-commander). This extends your AI assistant with 9 autonomous DevOps workflows for repository stewardship: Issue Triage, Milestone Sprints, PR Reviews, Copilot Audits, Security Audits, Code Quality Audits, Performance Audits, Roadmap Kickoffs, and Dependency Updates. Configure validation layers using the PROJECT_* environment overrides to enforce CI-matching execution locally during agent tasks!
flowchart TB
AI["š¤ AI Agent<br/>(Cursor, Windsurf, Claude)"]
subgraph MCP["Memory Journal MCP Server"]
Tools["š ļø 73 Tools"]
Resources["š” 46 Resources"]
Prompts["š¬ 19 Prompts"]
end
subgraph Storage["Persistence Layer"]
SQLite[("š¾ SQLite<br/>Entries, Tags, Relationships")]
Vector[("š Vector Index<br/>Semantic Embeddings")]
Backups["š¦ Backups"]
end
subgraph External["External Integrations"]
GitHub["š GitHub API<br/>Issues, PRs, Actions"]
Kanban["š Projects v2<br/>Kanban Boards"]
end
AI <-->|"MCP Protocol"| MCP
Tools --> Storage
Tools --> External
Resources --> Storage
Resources --> External
āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā
ā MCP Server Layer (TypeScript) ā
ā āāāāāāāāāāāāāāāāāāā āāāāāāāāāāāāāāāāāāā āāāāāāāāāāāāāāā ā
ā ā Tools (73) ā ā Resources (47) ā ā Prompts (19)ā ā
ā ā with Annotationsā ā with Annotationsā ā ā ā
ā āāāāāāāāāāāāāāāāāāā āāāāāāāāāāāāāāāāāāā āāāāāāāāāāāāāāā ā
āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā¤
ā Native SQLite Engine ā
ā āāāāāāāāāāāāāāāāāāā āāāāāāāāāāāāāāāāāāā āāāāāāāāāāāāāāā ā
ā ā better-sqlite3 ā ā sqlite-vec ā ā transformersā ā
ā ā (High-Perf I/O) ā ā (Vector Index) ā ā (Embeddings)ā ā
ā āāāāāāāāāāāāāāāāāāā āāāāāāāāāāāāāāāāāāā āāāāāāāāāāāāāāā ā
āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā¤
ā SQLite Database with Hybrid Search ā
ā āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā
ā ā entries + tags + relationships + embeddings + backups āā
ā āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā
āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā
better-sqlite3 with synchronous I/OMemory Journal is designed for extremely low overhead during AI task execution. We include a vitest bench suite to maintain these baseline guarantees:
calculateImportance is ~13-14x faster than retrieving 50 recent entries.sqlite-vec with SQL-native KNN queries.getTools uses cached O(1) dispatch (~4800-7000x faster than get_recent_entries). create_entry and search_entries execute through the full MCP layer with sub-millisecond overhead.To run the benchmarking suite locally:
npm run bench
Extensively tested across two frameworks:
npm test # Unit + integration tests
npm run test:e2e # End-to-end HTTP/SSE transport tests
{success, error, code, category, suggestion, recoverable} responses with actionable context ā no raw exceptions, no silent failures, no misleading messagesreadOnlyHint, destructiveHint, etc.).db file anywhereMIT License - See LICENSE file for details.
Built by developers, for developers. PRs welcome! See CONTRIBUTING.md for guidelines.
Ā© 2026 MCP Directory.
Developer journal with knowledge graphs, relationships, Git context, and semantic search
{ "mcpServers": { "io.github.neverinfamous-memory-journal-mcp": { "command": "docker", "args": [ "run", "-i", "--rm", "docker.io/writenotenow/memory-journal-mcp:v1.1.3" ] } }}Tools
No tool list yet. Remote servers get one after the first health check.
FAQ
Copy the stdio config for Cursor, Claude Desktop, Claude Code, or VS Code on this page. It uses the publisher's install, not a PlugMCP proxy.
No required environment variable is listed on this record.
Memory Journal runs locally over stdio.
Last checked 2026-11-10. Developer journal with knowledge graphs, relationships, Git context, and semantic search