
memory-fabric
Memory retrieval internals: knowledge graph orchestration with entity extraction, natural language query parsing, deduplication (85% similarity), and cross-reference boosting over unified recency, relevance, and authority ranking. Use when designing or debugging how memory search itself works. Everyday lookups belong to memory; entry storage to remember; consolidation to dream.
- Installs
- 236
- Last 24h
- —
- Trending rank
- —
- Security
- Not audited
Install
Works with every agent the skills CLI supports.
npx skills add https://github.com/yonatangross/orchestkit --skill memory-fabric- 01
Install
Run the command in your project. The CLI asks which agents to install for.
- 02
Describe the task
Ask your agent for something this skill covers. It loads memory-fabric automatically when relevant.
- 03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.
SKILL.md
The instructions your agent reads when the skill is triggered.
Memory Fabric - Graph Orchestration
Knowledge graph orchestration via mcp__memory__* for entity extraction, query parsing, deduplication, and cross-reference boosting.
Overview
- Comprehensive memory retrieval from the knowledge graph
- Cross-referencing entities within graph storage
- Ensuring no relevant memories are missed
- Building unified context from graph queries
Architecture Overview
Memory Fabric Layer
┌─────────────┐ ┌──────────────┐
│Query Parser │ │Query Executor│
└──────┬──────┘ └──────┬───────┘
└───────┬───────┘
┌──────────────┴─────────────┐
│Graph Query Dispatch │
└──────────────┬─────────────┘
┌──────────────┴─────────────┐
│mcp__memory__* │
│(Knowledge Graph) │
└──────────────┬─────────────┘
┌──────────────┴─────────────┐
│Result Normalizer │
└──────────────┬─────────────┘
┌──────────────┴─────────────┐
│Deduplication Engine │
│(>85% sim) │
└──────────────┬─────────────┘
┌──────────────┴─────────────┐
│Cross-Reference Booster │
└──────────────┬─────────────┘
┌──────────────┴─────────────┐
│Final Ranking: recency × │
│relevance × source_authority│
└────────────────────────────┘
Unified Search Workflow
Step 1: Parse Query
Extract search intent and entity hints from natural language:
Input: "What pagination approach did database-engineer recommend?"
Parsed:
- query: "pagination approach recommend"
- entity_hints: ["database-engineer", "pagination"]
- intent: "decision" or "pattern"
Step 2: Execute Graph Query
Query Graph (entity search):
mcp__memory__search_nodes({
query: "pagination database-engineer"
})
Step 3: Normalize Results
Transform results to common format:
{
"id": "graph:original_id",
"text": "content text",
"source": "graph",
"timestamp": "ISO8601",
"relevance": 0.0-1.0,
"entities": ["entity1", "entity2"],
"metadata": {}
}
Step 4: Deduplicate (>85% Similarity)
When two results have >85% text similarity:
- Keep the one with higher relevance score
- Merge metadata
- Mark as "cross-validated" for authority boost
Step 5: Cross-Reference Boost
If a result mentions an entity that exists elsewhere in the graph:
- Boost relevance score by 1.2x
- Add graph relationships to result metadata
Step 6: Final Ranking
Score = recency_factor × relevance × source_authority
| Factor | Weight | Description |
|---|---|---|
| recency | 0.3 | Newer memories rank higher |
| relevance | 0.5 | Semantic match quality |
| source_authority | 0.2 | Graph entities boost, cross-validated boost |
Result Format
{
"query": "original query",
"total_results": 4,
"sources": {
"graph": 4
},
"results": [
{
"id": "graph:cursor-pagination",
"text": "Use cursor-based pagination for scalability",
"score": 0.92,
"source": "graph",
"timestamp": "2026-01-15T10:00:00Z",
"entities": ["cursor-pagination", "database-engineer"],
"graph_relations": [
{ "from": "database-engineer", "relation": "recommends", "to": "cursor-pagination" }
]
}
]
}
Entity Extraction
Memory Fabric extracts entities from natural language for graph storage:
Input: "database-engineer uses pgvector for RAG applications"
Extracted:
- Entities:
- { name: "database-engineer", type: "agent" }
- { name: "pgvector", type: "technology" }
- { name: "RAG", type: "pattern" }
- Relations:
- { from: "database-engineer", relation: "uses", to: "pgvector" }
- { from: "pgvector", relation: "used_for", to: "RAG" }
Load Read("references/entity-extraction.md") for detailed extraction patterns.
Graph Relationship Traversal
Memory Fabric supports multi-hop graph traversal for complex relationship queries.
Example: Multi-Hop Query
Query: "What did database-engineer recommend about pagination?"
1. Search for "database-engineer pagination"
→ Find entity: "database-engineer recommends cursor-pagination"
2. Traverse related entities (depth 2)
→ Traverse: database-engineer → recommends → cursor-pagination
→ Find: "cursor-pagination uses offset-based approach"
3. Return results with relationship context
Integration with Graph Memory
Memory Fabric uses the knowledge graph for entity relationships:
- Graph search via
mcp__memory__search_nodesfinds matching entities - Graph traversal expands context via entity relationships
- Cross-reference boosts relevance when entities match
Integration Points
With memory Skill
When memory search runs, it can optionally use Memory Fabric for unified results.
With Hooks
prompt/memory-fabric-context.sh- Inject unified context at session startstop/memory-fabric-sync.sh- Sync entities to graph at session end
Configuration
# Environment variables
MEMORY_FABRIC_DEDUP_THRESHOLD=0.85 # Similarity threshold for merging
MEMORY_FABRIC_BOOST_FACTOR=1.2 # Cross-reference boost multiplier
MEMORY_FABRIC_MAX_RESULTS=20 # Max results per source
MCP Requirements
Required: Knowledge graph MCP server:
{
"mcpServers": {
"memory": {
"command": "npx",
"args": ["-y", "@anthropic/memory-mcp-server"]
}
}
}
Error Handling
| Scenario | Behavior |
|---|---|
| graph unavailable | Error - graph is required |
| Query empty | Return recent memories from graph |
Related Skills
ork:memory- User-facing memory operations (search, load, sync, viz)ork:remember- User-facing memory storagecaching- Caching layer that can use fabric
Key Decisions
| Decision | Choice | Rationale |
|---|---|---|
| Dedup threshold | 85% | Balances catching duplicates vs. preserving nuance |
| Parallel queries | Always | Reduces latency, both sources are independent |
| Cross-ref boost | 1.2x | Validated info more trustworthy but not dominant |
| Ranking weights | 0.3/0.5/0.2 | Relevance most important, recency secondary |
FAQ
What does the memory-fabric skill do?
Memory retrieval internals: knowledge graph orchestration with entity extraction, natural language query parsing, deduplication (85% similarity), and cross-reference boosting over unified recency, relevance, and authority ranking. Use when designing or debugging how memory search itself works. Everyday lookups belong to memory; entry storage to remember; consolidation to dream.
How do I install memory-fabric?
Run npx skills add https://github.com/yonatangross/orchestkit --skill memory-fabric in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/memory-fabric/ (personal) or .claude/skills/memory-fabric/ (project).
Which AI agents can use memory-fabric?
Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.
Is memory-fabric safe to install?
No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.
Who maintains memory-fabric?
It is published by yonatangross in yonatangross/orchestkit. It has 236 recorded installs.
More from yonatangross/orchestkit
devops-deployment
yonatangross/orchestkit
Use when setting up CI/CD pipelines, containerizing applications, deploying to Kubernetes, or writing infrastructure as code. DevOps & Deployment covers GitHub Actions, Docker, Helm, and Terraform patterns.
responsive-patterns
yonatangross/orchestkit
Responsive design with Container Queries, fluid typography, cqi/cqb units, subgrid, intrinsic layouts, foldable devices, and mobile-first patterns for React applications. Use when building responsive layouts or container queries.
architecture-decision-record
yonatangross/orchestkit
ADR templates in the Nygard format with context, decision, consequences, and alternatives. Use when writing ADRs, recording an architectural decision, or evaluating options.
ui-components
yonatangross/orchestkit
UI component library patterns for shadcn/ui and Radix Primitives. Use when building accessible component libraries, customizing shadcn components, using Radix unstyled primitives, or creating design system foundations.
rag-retrieval
yonatangross/orchestkit
Retrieval-Augmented Generation patterns for grounded LLM responses. Use when building RAG pipelines, embedding documents, implementing hybrid search, contextual retrieval, HyDE, agentic RAG, multimodal RAG, query decomposition, reranking, or pgvector search.
zustand-patterns
yonatangross/orchestkit
Reference for Zustand 5.x state management including slices, middleware, Immer, useShallow, persistence, selectors, and devtools integration. Documents 7 core patterns with TypeScript examples and anti-patterns. Use when building React state management with Zustand instead of Redux.
Popular code quality & workflow skills
grill-me
mattpocock/skills
A relentless interview to sharpen a plan or design.
improve-codebase-architecture
mattpocock/skills
Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.
handoff
mattpocock/skills
Compact the current conversation into a handoff document for another agent to pick up.
domain-modeling
mattpocock/skills
Build and sharpen a project's domain model. Use when discussing codebase terminology, writing or editing a GLOSSARY.md, or recording or editing an ADR.
codebase-design
mattpocock/skills
Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.
diagnosing-bugs
mattpocock/skills
Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.