Fetches and caches Fabric patterns from the Fabric GitHub repository, providing access to expert-crafted prompts for tasks like extracting wisdom, summarizing, analyzing claims, and more.
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., "@Fabric MCP Server summarize this article using the summarize pattern"
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.
An MCP (Model Context Protocol) server that provides access to Daniel Miessler's Fabric AI patterns. Access 227+ expert-crafted prompts for tasks like extracting wisdom, summarizing content, analyzing arguments, creating visualizations, and much more - all through Claude Desktop!
No API keys needed! Fabric patterns are pure prompts - this MCP server delivers them to Claude, which processes everything natively using its own intelligence. No external AI services, no vendor lock-in, no rate limits.
🔄 Auto-Updates! The server automatically checks for new patterns daily. Always stay current with the latest Fabric patterns!
QUICKSTART.md - Get started in 5 minutes
AUTO_UPDATE.md - How automatic pattern updates work
PROMPTING_STRATEGIES.md - How to use patterns effectively
ARCHITECTURE.md - How the system works
WHY_NO_CONFIG.md - Why zero AI configuration is needed
PROJECT_SUMMARY.md - Project overview
Related MCP server: LibraLM MCP Server
Fabric is an open-source framework for augmenting humans using AI. It provides a modular system of expert-crafted prompts (called "patterns") for solving specific problems. Each pattern is a carefully designed system prompt optimized for tasks like:
extract_wisdom - Extract insights, ideas, quotes, and recommendations
summarize - Create concise summaries
analyze_claims - Evaluate arguments and claims
create_markmap - Generate mind map visualizations
explain_code - Explain code in plain language
improve_writing - Enhance written content
And 100+ more patterns!
This MCP server brings Fabric patterns to Claude Desktop:
Access 227+ Fabric Patterns - All patterns from the official Fabric repository
Pure Prompt Library - No API keys, no external services, no configuration
Apply Patterns to Text - Use any pattern with your content
Browse Patterns - List and search available patterns
Automatic Caching - Patterns are cached locally for fast access
Read Pattern Prompts - View the full prompt for any pattern
Pattern Chaining - Combine multiple patterns for complex workflows
Python 3.10 or higher
Claude Desktop
Clone or download this repository:
cd "C:\Users\jonat\OneDrive\Coding Projects\fabric-mcp"Install dependencies:
pip install -e .Add the server to your Claude Desktop configuration file:
Windows: %APPDATA%\Claude\claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json
Add this configuration:
{
"mcpServers": {
"fabric": {
"command": "python",
"args": [
"-m",
"fabric_mcp.server"
]
}
}
}Or if you want to use the full path:
{
"mcpServers": {
"fabric": {
"command": "python",
"args": [
"C:\\Users\\jonat\\OneDrive\\Coding Projects\\fabric-mcp\\fabric_mcp\\server.py"
]
}
}
}Restart Claude Desktop
Once configured, you can use Fabric patterns in Claude Desktop:
List all available Fabric patternsor filter by keyword:
Show me all Fabric patterns related to "extract"Use the extract_wisdom Fabric pattern on this article: [paste article text]Apply the summarize Fabric pattern to this content: [paste content]Show me the full prompt for the analyze_claims Fabric patternThe MCP server provides four main tools:
apply_fabric_patternApply any Fabric pattern to input text.
Parameters:
pattern - The name of the pattern to apply
input_text - The text content to process
Example:
Apply the extract_wisdom pattern to analyze this podcast transcriptlist_fabric_patternsList all available patterns, optionally filtered by keyword.
Parameters:
filter (optional) - Filter patterns by name
Example:
List all Fabric patterns containing "create"get_fabric_patternGet the full prompt/instructions for a specific pattern.
Parameters:
pattern - The name of the pattern
Example:
Show me the full prompt for the improve_writing patternupdate_fabric_patternsForce an immediate update of the pattern list from GitHub (bypasses cache).
Parameters:
None
Example:
Update my Fabric patternsReturns:
Pattern count changes
List of new patterns added
List of patterns removed
Here are some of the most useful Fabric patterns:
extract_wisdom - Extract insights, ideas, quotes, habits, facts, and recommendations
summarize - Create concise summaries
explain_code - Explain code in plain language
improve_writing - Enhance written content
create_markmap - Generate markmap visualizations
analyze_claims - Analyze and evaluate claims
extract_article_wisdom - Extract insights from articles
create_quiz - Generate quiz questions
answer_interview_question - Help with interview prep
create_visualization - Create visual representations
rate_content - Rate content quality
check_agreement - Check if parties agree
find_logical_fallacies - Identify logical fallacies
create_stride_threat_model - Security threat modeling
recommend_artists - Get artist recommendations
And many more! Use list_fabric_patterns to see all available patterns.
This is a pure prompt delivery system - no AI APIs involved!
Pattern Discovery - The server fetches the list of available patterns from the Fabric GitHub repository
Pattern Caching - Patterns are cached locally in ~/.cache/fabric-mcp/ for fast access
Pattern Application - When you use a pattern, it combines the pattern prompt with your input text
Claude Processing - Claude receives the complete prompt and processes your content natively
Architecture:
You → Claude Desktop → MCP Server → Fabric Pattern (prompt)
↓
Claude's LLM (processes everything locally)
↓
ResultNo external API calls, no vendor configuration, no rate limits!
Each Fabric pattern is also available as an MCP resource with the URI format:
fabric://pattern/{pattern_name}For example:
fabric://pattern/extract_wisdom
fabric://pattern/summarize
fabric://pattern/analyze_claims
Fabric patterns are expert-crafted prompts that encode best practices. Learn how to use them effectively:
Combine multiple patterns for complex workflows:
1. extract_wisdom → Get insights
2. summarize → Condense insights
3. create_quiz → Test knowledgeAdapt patterns on-the-fly:
Use extract_wisdom but focus only on technical insights
and extract 10 ideas instead of 25Apply different perspectives:
Analyze this article with:
- extract_wisdom (insights)
- analyze_claims (arguments)
- rate_content (quality)📚 For comprehensive prompting strategies, see PROMPTING_STRATEGIES.md
This includes:
Pattern selection guidelines
Chaining workflows
Best practices
Common patterns by use case
Advanced techniques
The server will try to load patterns from GitHub. If you're offline or experiencing issues:
Check your internet connection
The server caches patterns in ~/.cache/fabric-mcp/
Check Claude Desktop logs for errors
Verify your claude_desktop_config.json is valid JSON
Check that the Python path is correct
Restart Claude Desktop completely
Check Claude Desktop logs:
Windows: %APPDATA%\Claude\logs
macOS: ~/Library/Logs/Claude
Linux: ~/.config/Claude/logs
Fabric Framework by Daniel Miessler
All patterns are from the Fabric repository
Built with Model Context Protocol
MIT License - See LICENSE file for details
The Fabric patterns themselves are from the Fabric project and maintain their original MIT license.
Contributions welcome! This is a simple MCP wrapper around the Fabric patterns. To contribute:
Fork the repository
Create a feature branch
Make your changes
Submit a pull request
For issues with:
This MCP Server - Open an issue in this repository
Fabric Patterns - See the Fabric repository
MCP Protocol - See the MCP documentation
Enjoy using Fabric patterns with Claude Desktop! 🎨✨
Apply any Fabric AI pattern to input text. Fabric patterns are expert-crafted prompts for tasks like extracting wisdom, summarizing content, analyzing arguments, creating visualizations, and much more.
| Name | Required | Description | Default |
|---|---|---|---|
| pattern | Yes | The pattern to apply. Available patterns: agility_story, ai, analyze_answers, analyze_bill, analyze_bill_short, analyze_candidates, analyze_cfp_submission, analyze_claims, analyze_comments, analyze_debate, analyze_discord_structure, analyze_email_headers, analyze_incident, analyze_interviewer_techniques, analyze_logs, analyze_malware, analyze_military_strategy, analyze_mistakes, analyze_monetization_opportunities, analyze_paper... (and many more) | |
| input_text | Yes | The text content to process with the pattern |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations; description only says 'apply' without mentioning side effects, auth, or output behavior. Minimal transparency for a transformation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with purpose and examples. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a tool with full enum and 2 parameters, but lacks output description and error handling. Could be more complete given no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline 3. Description adds listing of pattern examples and clarifies input_text purpose, but adds marginal value beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool applies Fabric AI patterns to input text, with specific examples. It distinguishes from siblings: get, list, update.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implied usage for processing text with a pattern, but no explicit when-not-to-use or comparison with alternatives like get_fabric_pattern or list_fabric_patterns.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the full prompt/instructions for a specific Fabric pattern
| Name | Required | Description | Default |
|---|---|---|---|
| pattern | Yes | The name of the pattern to retrieve |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description should disclose behavioral traits like read-only nature or response format. It only states the function, omitting any side effects, permissions, or output details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no superfluous words. It is appropriately concise for a simple retrieval tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the low complexity (1 param, no output schema), the description is sufficient to convey the tool's purpose, though it could mention that no modifications occur.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a single 'pattern' parameter having an enum. The description adds no extra meaning beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action 'Get' and the resource 'full prompt/instructions for a specific Fabric pattern'. This distinguishes it from sibling tools like apply_fabric_pattern (apply) and list_fabric_patterns (list).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance is provided on when to use this tool versus its siblings. The sibling names hint at different purposes, but the description lacks a direct comparison or usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all available Fabric patterns with their descriptions
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Optional filter to search patterns by name (e.g., 'extract', 'analyze', 'create') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It does not mention behavioral traits such as read-only nature, pagination, or result limits. For a simple listing, this is adequate but lacks depth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that directly states the tool's purpose without any unnecessary words or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool (one optional parameter, no output schema), the description is sufficient to understand its basic function. However, it could hint at the return format or that results are a list of pattern objects with descriptions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool description does not add information about the 'filter' parameter beyond what the input schema already provides (including examples). Since schema coverage is 100%, baseline is 3; no extra meaning is added.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List all available Fabric patterns with their descriptions', specifying the verb (list) and resource (Fabric patterns). This distinguishes it from siblings like get_fabric_pattern (single pattern) and apply_fabric_pattern (action).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for browsing all patterns but does not explicitly state when to use this tool versus alternatives like get_fabric_pattern for a specific pattern, or when filtering might be beneficial. No when-not guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Force an update of the pattern list from GitHub. Use this to get the latest patterns immediately.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility for behavioral disclosure. It only says 'Force an update,' which hints at a potentially destructive or blocking operation, but lacks details on side effects, permissions, or expected behavior (e.g., network call, latency).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that immediately states the action and purpose. It is front-loaded and contains no extraneous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no parameters, no output schema, and a simple action, the description is minimally adequate. However, it lacks details on what 'force an update' entails and does not set expectations for the agent (e.g., success indication, potential delays).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters in the input schema, so the description cannot add meaning beyond the schema. With 100% schema coverage and zero parameters, a baseline score of 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('Force an update of the pattern list from GitHub') and its purpose ('get the latest patterns immediately'). It distinguishes from sibling tools which are about applying, getting, or listing patterns.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description advises using it to get the latest patterns immediately, which gives clear usage context. However, it does not mention when not to use it or alternatives, though the sibling names imply differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0apply_fabric_patternget_fabric_patternlist_fabric_patternsupdate_fabric_patternsScored across 4 tools
Each tool targets a distinct action: apply a pattern, get its details, list all patterns, and update the pattern list. No overlaps or ambiguity.
All tools follow a consistent verb_noun snake_case pattern (apply, get, list, update), making them predictable and easy to use.
With only 4 tools, the set is well-scoped for the specific domain of managing and applying Fabric patterns, neither too sparse nor too heavy.
The tool surface covers the core lifecycle of Fabric patterns: listing, retrieving details, applying, and refreshing the list. No obvious gaps for the stated purpose.
Contextual prompts and agent skills for 140+ AI platforms.
Connect your team's living knowledge base — docs, data, issues, CRM — to Claude and ChatGPT.
Curated knowledge API for AI agents - skill packs, semantic search, validated patterns.
Agent personas for Claude. 16 tools, 13 personas, 3 workflows. Zero extra API cost. Free.
