Archivyr

Centralized storage and management system for AI editor rulesets via the Model Context Protocol (MCP).

Archivyr solves the problem of ruleset duplication and drift across multiple projects by providing a single source of truth for AI editor guidelines, rules, and steering documents. Store your rulesets once, access them everywhere.

When working with AI editors across multiple projects, you often need to duplicate the same rulesets (coding standards, style guides, best practices) in each project. This leads to:

• Duplication of effort maintaining the same rules in multiple places
• Drift as rulesets evolve differently across projects
• Inconsistency in AI editor behavior across your projects

Archivyr provides a centralized MCP server that stores rulesets in Valkey and makes them available to any MCP-compatible AI editor. Create a ruleset once, reference it everywhere.

• Centralized Storage: Store rulesets in a Valkey-backed system
• MCP Protocol: Access rulesets via the Model Context Protocol
• CRUD Operations: Create, read, update, and delete rulesets
• Pattern Matching: Search and list rulesets using glob patterns
• Metadata Tracking: Timestamps, tags, and descriptions for each ruleset
• Docker Distribution: Self-contained image with bundled Valkey instance
• Snake Case Naming: Enforced naming convention for consistency

# Pull and run the latest image
docker run -i ghcr.io/joebrinkman/archivyr:latest

# Or build locally
docker build -f docker/Dockerfile -t archivyr:latest .
docker run -i archivyr:latest

# Install dependencies
go mod download

# Build binary
task build

# Run (requires Valkey running on localhost:6379)
./bin/archivyr

Add to your Claude Desktop configuration file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "archivyr": {
      "command": "docker",
      "args": ["run", "-i", "ghcr.io/joebrinkman/archivyr:latest"]
    }
  }
}

Add to your Cursor MCP configuration:

{
  "mcpServers": {
    "archivyr": {
      "command": "docker",
      "args": ["run", "-i", "ghcr.io/joebrinkman/archivyr:latest"]
    }
  }
}

Add to your Kiro MCP configuration file:

Workspace level: .kiro/settings/mcp.json

User level: ~/.kiro/settings/mcp.json

{
  "mcpServers": {
    "archivyr": {
      "command": "docker",
      "args": ["run", "-i", "ghcr.io/joebrinkman/archivyr:latest"],
      "disabled": false,
      "autoApprove": []
    }
  }
}

Add to your GitHub Copilot MCP configuration:

VS Code: Settings → Extensions → GitHub Copilot → MCP Servers

{
  "github.copilot.advanced": {
    "mcpServers": {
      "archivyr": {
        "command": "docker",
        "args": ["run", "-i", "ghcr.io/joebrinkman/archivyr:latest"]
      }
    }
  }
}

Add to your Windsurf MCP configuration file:

macOS: ~/Library/Application Support/Windsurf/mcp_config.json

Windows: %APPDATA%\Windsurf\mcp_config.json

Linux: ~/.config/Windsurf/mcp_config.json

{
  "mcpServers": {
    "archivyr": {
      "command": "docker",
      "args": ["run", "-i", "ghcr.io/joebrinkman/archivyr:latest"]
    }
  }
}

Archivyr uses stdio transport and works with any MCP-compatible client. See examples/mcp-config.json for more configuration examples.

Use the upsert_ruleset tool in your AI editor to create a new ruleset (all fields required):

Create a new ruleset named "python_style_guide" with:
- Description: "Python coding standards for team projects"
- Tags: ["python", "style", "pep8"]
- Content: [your markdown content]

The tool will automatically detect that this is a new ruleset and create it.

Use the upsert_ruleset tool to update an existing ruleset (only provide fields to change):

Update the ruleset "python_style_guide" with new description: "Updated Python standards"

The tool will automatically detect that the ruleset exists and update only the provided fields.

Rulesets are exposed as MCP resources. Reference them by URI:

ruleset://python_style_guide

Or use the get_ruleset tool:

Get the ruleset named "python_style_guide"

Use the search_rulesets tool without a pattern (or with pattern *):

List all available rulesets

Or explicitly:

Search for rulesets matching "*"

Use the search_rulesets tool with specific glob patterns:

Search for rulesets matching "*python*"
Search for rulesets matching "style_*"

Use the delete_ruleset tool:

Delete the ruleset named "old_ruleset"

• upsert_ruleset: Create a new ruleset or update an existing one (automatically detects which operation to perform)
• get_ruleset: Retrieve a ruleset by exact name
• delete_ruleset: Delete a ruleset by name
• search_rulesets: Search rulesets by name pattern, or list all when pattern is omitted or *

• URI scheme: ruleset://{name}
• MIME type: text/markdown
• Example: ruleset://python_style_guide

Configure via environment variables:

• VALKEY_HOST: Valkey host (default: localhost)
• VALKEY_PORT: Valkey port (default: 6379)
• LOG_LEVEL: Logging verbosity (default: info)

Archivyr is built with:

• Go 1.24+: Core implementation
• Valkey: Key-value storage backend
• valkey-glide v2: Go client for Valkey
• mcp-go: MCP protocol implementation
• Valkey Docker image: Official Valkey image as base

Rulesets are stored in Valkey as hashes with the key pattern ruleset:{name}:

Key: ruleset:python_style_guide
Fields:
  description: "Python coding standards"
  tags: ["python", "style", "pep8"]
  markdown: "# Python Style Guide\n..."
  created_at: "2025-10-28T10:30:00Z"
  last_modified: "2025-10-28T15:45:00Z"

This project uses Task for build automation. Install Task first:

# macOS
brew install go-task

# Linux
sh -c "$(curl --location https://taskfile.dev/install.sh)" -- -d -b ~/.local/bin

# Or install via Go
go install github.com/go-task/task/v3/cmd/task@latest

# Set up development environment
task dev:setup

# Run tests (same as CI)
task test

# Run linter (same as CI)
task lint

# Build binary
task build

# Run full CI pipeline locally
task ci

# See all available tasks
task

# Before committing
task verify                 # Format, lint, and test

# Run tests quickly during development
task test:quick

# Watch for changes and auto-test (requires entr)
task dev:watch

All commits must include a DCO signoff. Use git commit -s to automatically add the signoff.

BSD-3-Clause - see LICENSE for details.