Fabric Atelier

🚀 Fabric Atelier 🎨

A high-performance atelier for Fabric patterns - MCP server built with Rust + Apache Arrow

This project is a high - performance MCP server. It exposes over 200 AI patterns from Fabric as discoverable and executable tools for various AI assistants, leveraging the power of Rust and Apache Arrow.

🚀 Quick Start

Option 1: Docker (Recommended) 🐳

Pull from Docker Hub:

docker pull copyleftdev/fabric-atelier:latest

Configure Claude Desktop:

{
  "mcpServers": {
    "fabric-atelier": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "copyleftdev/fabric-atelier:latest"]
    }
  }
}

Test it:

echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | \
  docker run -i --rm copyleftdev/fabric-atelier:latest

Option 2: Build from Source

Prerequisites:

• Rust 1.90+ (curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh)
• Local LLM (Ollama) or API keys (OpenAI/Anthropic)

Installation:

# Clone with submodules
git clone --recursive https://github.com/copyleftdev/fabric-atelier.git
cd fabric-atelier

# Build release binary
cargo build --release

# Binary location: target/release/fabric-atelier

Configure MCP Client

Claude Desktop (macOS):

code ~/Library/Application\ Support/Claude/claude_desktop_config.json

Claude Desktop (Linux):

code ~/.config/Claude/claude_desktop_config.json

Windsurf IDE: See WINDSURF_SETUP.md for detailed Windsurf configuration.

Add this configuration:

{
  "mcpServers": {
    "fabric-atelier": {
      "command": "/absolute/path/to/fabric-atelier/target/release/fabric-atelier"
    }
  }
}

Restart Claude Desktop and look for the 🔌 icon to verify connection.

✨ Features

• 🚀 Blazingly Fast - Built with Rust for maximum performance
• 🎯 226 Patterns - All Fabric patterns accessible via MCP
• 🐳 Docker Ready - Pull and run in seconds
• 🤖 LLM Powered - Ollama, OpenAI, or Anthropic support
• 🦀 Rust Performance - 281MB Docker image, <50ms startup
• 🔗 Auto - Sync - Git submodule keeps patterns up - to - date with Fabric
• 🔒 Secure - Non - root Docker user, minimal dependencies
• 📊 Benchmarked - 5,000+ req/s, comprehensive performance testing

💻 Usage Examples

In Claude Desktop

User: "Find me a Fabric pattern for analyzing security papers"
Claude: [Uses fabric_find_pattern tool]
        → Suggests: analyze_threat_report, analyze_paper, extract_wisdom

User: "Use fabric_extract_wisdom to analyze this article: [content]"
Claude: [Executes pattern and returns insights]

Available MCP Tools

• fabric_find_pattern - Semantic search for patterns
• fabric_<pattern_name> - Execute any Fabric pattern (200+ tools)
  • fabric_summarize - Summarize content
  • fabric_extract_wisdom - Extract insights from articles/videos
  • fabric_analyze_claims - Fact - check and analyze claims
  • fabric_improve_writing - Enhance writing quality
  • fabric_explain_code - Explain code snippets
  • ... and 195+ more!

📚 Documentation

For detailed technical documentation, see the docs/ directory:

• ARCHITECTURE.md - System architecture and design
• BUILD_SYSTEM.md - Build configuration and optimization
• MCP_SCHEMA_DOCUMENTATION.md - MCP protocol implementation
• WINDSURF_SETUP.md - Windsurf IDE integration guide

🔧 Technical Details

Architecture

fabric-atelier/
├── src/                      # Rust source code
│   ├── mcp/                  # MCP protocol implementation
│   ├── fabric/               # Pattern loader & executor
│   ├── vector/               # Arrow-based semantic search
│   └── main.rs
├── data/
│   ├── fabric/              # Git submodule → danielmiessler/fabric
│   │   └── data/patterns/   # 200+ Fabric patterns (auto-synced)
│   └── embeddings.parquet   # Cached pattern embeddings
└── docs/
    └── media/               # Project assets

How It Works

1. Pattern Discovery

Fabric Atelier loads all patterns from the data/fabric/data/patterns/ directory (synced via git submodule).

2. Semantic Indexing

Pattern descriptions are embedded using OpenAI/Anthropic APIs and cached in Parquet format using Apache Arrow for instant access.

3. MCP Protocol

The server implements the Model Context Protocol, exposing patterns as tools that AI assistants can discover and execute.

4. Pattern Execution

When a tool is called, Atelier executes the corresponding Fabric pattern via CLI and returns the result.

Data Strategy

Fabric Atelier uses a git submodule to reference Daniel Miessler's Fabric repository:

# Update to latest Fabric patterns
git submodule update --remote data/fabric

# Rebuild embeddings after update
cargo run --bin generate-embeddings

This approach:

• ✅ Keeps patterns in sync with upstream Fabric
• ✅ Respects Fabric's MIT license
• ✅ No data duplication
• ✅ Single source of truth

Performance

Benchmarked with comprehensive performance testing.

Development

Project Structure

The project follows a modular Rust architecture with MCP protocol implementation, pattern loading, and semantic search capabilities.

Building

# Development build
cargo build

# Release build (optimized)
cargo build --release

# Run tests
cargo test

# Run benchmarks
cargo bench

Generating Embeddings

# Set API key
export OPENAI_API_KEY=your_key_here

# Generate embeddings for all patterns
cargo run --bin generate-embeddings

# Output: data/embeddings.parquet

📄 License

MIT License - see LICENSE for details.

Fabric patterns are licensed under MIT by danielmiessler/fabric.

Roadmap

• [x] Basic MCP server implementation
• [x] Pattern loading from Fabric submodule
• [x] Git submodule integration
• [ ] Apache Arrow vector search
• [ ] Parquet embedding cache
• [ ] SIMD - accelerated similarity search
• [ ] Pattern chaining support
• [ ] YouTube transcript integration
• [ ] Custom pattern support
• [ ] Performance benchmarks

Contributing

Contributions welcome! Please open an issue or pull request on GitHub.

Philosophy

Fabric Atelier aligns with Fabric's core philosophy:

"AI isn't a thing; it's a magnifier of a thing. And that thing is human creativity."

By making Fabric's patterns accessible through MCP, we extend this vision of human augmentation to every AI assistant that supports the protocol.

Credits

• Daniel Miessler - Creator of Fabric
• Model Context Protocol - Anthropic's open protocol for AI tool integration
• Apache Arrow - High - performance columnar data format

Built with 🦀 Rust and ❤️ for the Fabric community