By emmahyde
Teaches Claude how to use the memory-access MCP server for persistent knowledge storage, retrieval, and graph traversal. Includes PreCompact hook to preserve insights before context compaction.
Use this agent to coordinate parallel task execution across multiple subagents with contract-enforced lock management, schema-validated handoffs, and deterministic state progression. Examples: <example> Context: User wants to implement a multi-file feature with parallel work streams user: "Implement the new auth system — split the API routes, middleware, and tests across agents" assistant: "I'll use the orchestrator agent to decompose this into lock-safe parallel tasks with validated handoffs." <commentary> Multi-agent parallel work requires lock management, assignment packets, and result validation — exactly what the orchestrator enforces. </commentary> </example> <example> Context: User needs to coordinate agents that must not conflict on shared files user: "Run these three refactoring tasks in parallel but make sure agents don't step on each other" assistant: "I'll use the orchestrator agent to manage lock scopes and prevent resource conflicts." <commentary> Lock-scope enforcement and overlap detection are core orchestrator responsibilities. </commentary> </example> <example> Context: A previous multi-agent run was interrupted and needs recovery user: "The agent swarm crashed mid-run — pick up where we left off" assistant: "I'll use the orchestrator agent to reload the ledger, reconcile locks, and resume from the last valid state." <commentary> Crash recovery with ledger reload and orphan detection is a defined orchestrator protocol. </commentary> </example>
Analysis worker for tasks that examine code without modifying it. Use for code review, architecture analysis, dependency audits, security scanning, or research tasks where the output is a report, not a code change. <example> Context: Orchestrator assigns a code review task user: "Review the auth module for security vulnerabilities" assistant: "I'll use worker-readonly to analyze the code and report findings." <commentary> Code review reads files and reports findings. No file mutation needed. </commentary> </example> <example> Context: Orchestrator assigns a dependency analysis task user: "Audit which modules depend on the legacy API client" assistant: "I'll use worker-readonly to trace dependencies via Grep/Glob." <commentary> Dependency tracing is pure analysis — read and search only. </commentary> </example>
Implementation worker for tasks that create or modify files. Use when a task requires writing code, editing configurations, creating test fixtures, or any file mutation. The subagent directive is injected automatically — this agent handles execution. <example> Context: Orchestrator assigns a task to implement a new module user: "Implement the auth middleware in src/middleware/auth.py" assistant: "I'll use the worker-readwrite agent to implement this within the assigned lock scope." <commentary> File creation and editing require Write/Edit tools. worker-readwrite is the standard implementation worker. </commentary> </example> <example> Context: Orchestrator assigns a refactoring task user: "Refactor the database queries to use parameterized statements" assistant: "I'll use worker-readwrite to edit the existing query files." <commentary> Editing existing files requires Edit tool. This is a readwrite task. </commentary> </example>
Test execution worker for running test suites, validating builds, and verifying acceptance criteria through command execution. Use when the task is to run tests, check build outputs, or validate that prior changes work correctly — not to write new code. <example> Context: Orchestrator needs to validate a completed implementation task user: "Run the auth test suite and report results" assistant: "I'll use worker-test to execute the tests and report pass/fail evidence." <commentary> Test execution needs Bash for running commands and Read/Grep for examining output. No file writing. </commentary> </example> <example> Context: Orchestrator needs integration verification across modules user: "Verify the API endpoints return correct responses after the refactor" assistant: "I'll use worker-test to run integration tests and capture results." <commentary> Integration testing is command execution + result analysis. </commentary> </example>
Interactively create and ingest a knowledge base from crawled URLs, single pages, or Firecrawl JSON folders with real-time progress and detailed statistics
Operate strict orchestrator/subagent workflows with enforceable contracts, lock management, and fresh-context handoff execution. Use when planning or running agent swarms, validating assignment/result packets, preventing lock overlap, reconciling task ledgers, or recovering blocked multi-agent runs.
This skill should be used when the user asks to "store a memory", "remember this", "save this insight", "search memories", "find related insights", "what do I know about", "connect these concepts", "add a relationship", "traverse the knowledge graph", or when working with the memory-access MCP tools. Also activates when storing learnings, debugging knowledge, or building on prior insights.
Requires secrets
Needs API keys or credentials to function
Uses power tools
Uses Bash, Write, or Edit tools
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
An MCP server that gives AI agents persistent, intent-based memory. Text is decomposed into atomic insights, classified into semantic frames, embedded as vectors, and stored in a SQLite knowledge graph with subject indexing.
git clone https://github.com/emmahyde/memory-access.git
cd memory-access
uv sync --group dev
Or install from PyPI:
pip install memory-access
# or
uv add memory-access
Requires Python 3.12+.
For OpenAI + Anthropic (default):
export OPENAI_API_KEY=...
export ANTHROPIC_API_KEY=...
For AWS Bedrock:
export EMBEDDING_PROVIDER=bedrock
export LLM_PROVIDER=bedrock
export AWS_PROFILE=your-sso-profile
export AWS_REGION=us-east-1
claude plugin install memory-access@emmahyde
To ingest external documentation as knowledge bases:
export FIRECRAWL_API_KEY=... # Get from https://www.firecrawl.dev/
uv run pytest # 174 tests pass
uv run memory-access # server starts (MCP server mode)
uv run memory-access kb list # knowledge base CLI mode
| Variable | Required | Description |
|---|---|---|
OPENAI_API_KEY | Yes* | Embedding generation via OpenAI (text-embedding-3-small) |
ANTHROPIC_API_KEY | Yes* | Insight normalization via Anthropic (Claude Haiku) |
MEMORY_DB_PATH | No | Database path. Default: ~/.claude/memory-access/memory.db |
EMBEDDING_PROVIDER | No | openai (default) or bedrock |
LLM_PROVIDER | No | anthropic (default) or bedrock |
AWS_PROFILE | No | AWS SSO profile name (required for Bedrock) |
AWS_REGION | No | AWS region for Bedrock. Default: us-east-1 |
BEDROCK_EMBEDDING_MODEL | No | Bedrock model ID. Default: amazon.titan-embed-text-v2:0 |
BEDROCK_LLM_MODEL | No | Bedrock Claude model ID. Default: us.anthropic.claude-haiku-4-5-20251001-v1:0 |
FIRECRAWL_API_KEY | No | Web crawling for knowledge bases. Get from https://www.firecrawl.dev/ |
CRAWL_SERVICE | No | Crawl provider. Default: firecrawl |
MIN_CONFIDENCE_THRESHOLD | No | Minimum confidence to store ingested chunks. Default: 0.5 |
* Not required when using bedrock provider.
Add to your MCP settings (see mcp-config-example.json):
{
"mcpServers": {
"memory-access": {
"command": "python3",
"args": ["-m", "memory_access.server"],
"env": {
"MEMORY_DB_PATH": "~/.claude/memory-access/memory.db",
"OPENAI_API_KEY": "${OPENAI_API_KEY}"
},
"cwd": "/path/to/memory-access/src"
}
}
}
To use AWS Bedrock instead of OpenAI/Anthropic APIs:
{
"mcpServers": {
"memory-access": {
"command": "python3",
"args": ["-m", "memory_access.server"],
"env": {
"MEMORY_DB_PATH": "~/.claude/memory-access/memory.db",
"EMBEDDING_PROVIDER": "bedrock",
"LLM_PROVIDER": "bedrock",
"AWS_PROFILE": "your-sso-profile",
"AWS_REGION": "us-east-1"
},
"cwd": "/path/to/memory-access/src"
}
}
}
store_insight — Store text with optional domain and git context (repo, pr, author, project, task). Text is decomposed into atomic insights, classified, embedded, and indexed.update_insight — Update an insight's confidence score.forget — Delete an insight.search_insights — Semantic similarity search by query text. Returns ranked results.list_insights — List insights filtered by domain or frame.search_by_subject — Find insights by subject name and kind.related_insights — Find insights connected through shared subjects (graph traversal).add_subject_relation — Create a typed edge between two subjects (e.g., problem --solved_by--> resolution).get_subject_relations — Query outgoing relations from a subject.add_knowledge_base — Create a new knowledge base by crawling or scraping a URL. Supports both full site crawling and single-page scraping with automatic ingestion and semantic indexing.search_knowledge_base — Search external documentation by semantic similarity. Optionally filter by KB name.list_knowledge_bases — List all knowledge bases with descriptions and chunk counts.npx claudepluginhub emmahyde/memory-access --plugin memory-accessSelf-driven memory lifecycle with autonomous curation for Claude Code
Discuss implementation decisions, then execute with parallel agents in coordinated waves
Query Intent Solutions' governed knowledge brain from Claude Code — qmd://-cited answers, per-user audit, deterministic governance. Compile, then govern.
Use Memind as persistent memory for Claude Code sessions.
Persistent semantic memory for Claude Code — auto-injects relevant context at session start, captures git commits, test results, and research via hooks, and provides 30+ MCP tools for memory management.
Long-term memory for Claude Code powered by Memex. Provides persistent knowledge capture, retrieval, and memory-augmented workflows across all projects.
Persistent agent memory that survives across sessions — auto-compacting 3-tier memory with hybrid search. Your agent remembers what it learned, decided, and built.
Standalone image generation plugin using Nano Banana MCP server. Generates and edits images, icons, diagrams, patterns, and visual assets via Gemini image models. No Gemini CLI dependency required.