What is Anubis Mcp

Anubis is an intelligent workflow management tool designed to enhance AI agents’ productivity by offering structured guidance, seamless task transitions, and beautiful reporting capabilities. It helps streamline development processes, making them more efficient and reducing the time and defects typically associated with chaotic coding.

Use cases

Anubis is ideal for software development projects, particularly those requiring user authentication systems, where clear guidelines and role-based expertise are beneficial. It is also effective in scenarios needing collaborative efforts among different roles, such as researchers, architects, and developers, ensuring a well-organized workflow throughout the project lifecycle.

How to use

To get started with Anubis, initialize the intelligent guidance by calling the init_rules MCP tool for your AI agent. Begin a new workflow with Anubis guidance for your project, and at any point, you can generate an interactive workflow report to track progress and performance. Options for setup include using NPX or Docker for streamlined management.

Key features

Key features of Anubis include intelligent guidance with structured workflows, seamless transitions between roles while preserving context, and the generation of beautiful HTML reports with interactive dashboards. Additional features support role-based task management, automated context retention, and progress tracking.

Where to use

Anubis can be utilized in various environments that support AI workflows, including development teams, educational institutions, and organizations focused on software projects. It’s particularly useful for applications using the MCP framework, allowing for integration with existing development tools and environments.

𓂀𓁢𓋹𝔸ℕ𝕌𝔹𝕀𝕊𓋹𓁢𓂀 - Intelligent Guidance for AI Workflows

Transform your AI agent from chaotic coder to intelligent workflow orchestrator with three powerful capabilities:

Three Pillars of Intelligent Workflow Management

Intelligent Guidance | Seamless Transitions | Beautiful Reporting

NPM Package • Docker Hub • Website

QUICK START

Option 1: NPX (Recommended)

Add to your MCP client config

{
  "mcpServers": {
    "anubis": {
      "command": "npx",
      "args": [
        "-y",
        "@hive-academy/anubis"
      ],
      "env": {
        "PROJECT_ROOT": "C:\\path\\to\\projects"
      }
    }
  }
}

Option 2: Docker (MCP Configuration)

For Unix/Linux/macOS (mcp.json):

{
  "mcpServers": {
    "anubis": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-v",
        "${PWD}:/app/workspace",
        "-v",
        "anubis-data:/app/data",
        "hiveacademy/anubis"
      ]
    }
  }
}

For Windows (mcp.json):

{
  "mcpServers": {
    "anubis": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-v",
        "C:\\path\\to\\your\\project:/app/workspace",
        "-v",
        "C:\\path\\to\\your\\project\\data:/app/data",
        "hiveacademy/anubis"
      ]
    }
  }
}

INITIALIZE CUSTOM-MODES ( AGENT RULES)

Once you get the mcp server running you need to initialize the rules (custom-modes) for the agent you are using

Supported Agents: cursor • copilot • roocode • kilocode

Step 1: Initialize Intelligent Guidance

Please initialize Anubis workflow rules for [your-agent-name] by calling the init_rules MCP tool

Step 2: Start Your Workflow

Begin a new workflow for [your-project] with Anubis guidance

ROOCODE Setup Example

1- install the MCP server:

{
  "mcpServers": {
    "anubis": {
      "command": "npx",
      "args": ["-y", "@hive-academy/anubis"],
      "env": {
        "PROJECT_ROOT": "C:\\path\\to\\projects"
      }
    }
  }
}

2- then make sure you are on Code mode and ask it to generate the custom Anubis mode for you

Please initialize Anubis workflow rules for roocode by calling the init_rules MCP tool

3- reload the window and you should see the custom mode in the modes dropdown list. activate it and ask it to create your first task

4- also if you don’t have a memory bank files, ask it to generate them for you as the first task.

Cursor Setup Example

For Cursor users, here’s a complete setup example:

1. Install MCP Server in Cursor:
   • Open Cursor Settings (Cmd/Ctrl + ,)
   • Navigate to “Extensions” → “MCP Servers”
   • Add new server configuration:

   "anubis": {
     "command": "npx",
     "args": ["-y", "@hive-academy/anubis"],
      "env": {
        "PROJECT_ROOT": "C:\\path\\to\\projects"
      }
   }
   

2. Initialize Cursor Rules

• Make Sure the mcp server is working and active.
• ask the agent to Please initialize Anubis workflow rules for cursor by calling the init_rules MCP tool.
• you should see a file generated at .cursor/rules with the name 000-workflow-core.mdc
• Head over to cursor rules and make sure the rules file are added and active.

Now You are ready to start you first task 🚀.

Hint: an important first step task is to generate memory-bank files
Ask the agent to Please create a task to analyze codebase and generate memory-bank files (ProjectOverview.md, TechnicalArchitecture.md, and DeveloperGuide.md)

Claude Code Setup Example

• To install the mcp server use this command claude mcp add anubis npx -y @hive-academy/anubis

  make sure you are on the poject root you want to install this into.

• To make sure it’s installed correctly run claude mcp list you should see a server with name anubis.

• now you will need to do a very important step:

  • Download this rules markdown file Anubis Rules
  • Save it inside your project for example inside a folder names rules and file name anubis-rules.md.
  • Then open your CLAUDE.md file and add the following:
    Anubis Workflow @rules/anubis-rules.md

CORE VALUE #1: INTELLIGENT GUIDANCE FOR AI AGENTS

Your AI agent receives step-by-step intelligent rules for every development task:

// Before Anubis: Chaotic, directionless coding
"Create a user authentication system" →  Where do I start?

// With Anubis: Intelligent guidance at every step
"Create a user authentication system" →
   Requirements Analysis (Researcher Role)
   System Architecture (Architect Role)
   Implementation Plan (Senior Dev Role)
   Quality Validation (Code Review Role)
   Progress Report (Auto-generated)

Benefits:

• 30-50% faster development with structured workflows
• 40-60% fewer defects through quality gates
• 100% MCP-compliant guidance without execution

CORE VALUE #2: SEAMLESS TASK & ROLE TRANSITIONS

Never lose context when switching between roles or continuing tasks:

// Seamless context preservation across transitions
{
  "currentRole": "architect",
  "completedSteps": ["requirements", "design"],
  "context": {
    "decisions": ["JWT for auth", "PostgreSQL for storage"],
    "rationale": "Scalability and security requirements",
    "nextSteps": ["Implementation by Senior Dev role"]
  }
}
// → Switch roles without losing any context!

Features:

• Intelligent context preservation between role switches
• Automatic task handoffs with full history
• Role-based boundaries for focused expertise
• Pause and resume workflows anytime

CORE VALUE #3: BEAUTIFUL HTML REPORTING

Transform your workflow data into stunning, interactive reports:

What you get:

• Interactive dashboards with Chart.js visualizations
• Mobile-responsive Tailwind CSS design
• Progress tracking with visual indicators
• Performance analytics for each role
• Detailed task breakdowns with timelines
• Export-ready reports for stakeholders

INTELLIGENT ROLE SYSTEM

REAL-WORLD EXAMPLE

// 1. Agent receives intelligent guidance
const guidance = await get_step_guidance({
  executionId: 'auth-system-123',
  roleId: 'senior-developer'
});

// 2. Anubis provides structured rules
{
  "guidance": {
    "step": "Implement JWT authentication",
    "approach": [
      "1. Create User model with Prisma",
      "2. Implement password hashing with bcrypt",
      "3. Create JWT token generation service",
      "4. Add authentication middleware"
    ],
    "qualityChecklist": [
      "SOLID principles applied",
      "Unit tests coverage > 80%",
      "Security best practices",
      "Error handling implemented"
    ],
    "context": {
      "previousDecisions": ["PostgreSQL", "JWT strategy"],
      "nextRole": "code-review"
    }
  }
}

// 3. Agent executes with confidence and reports
await report_step_completion({
  result: 'success',
  metrics: {
    filesCreated: 8,
    testsWritten: 15,
    coverage: 85
  }
});

// 4. Beautiful report auto-generated! 📊

TECHNICAL EXCELLENCE

Enterprise-Grade Architecture:

• Backend: NestJS v11 + TypeScript
• Database: Prisma ORM + SQLite/PostgreSQL
• MCP: @rekog/mcp-nest v1.5.2
• Analytics: Chart.js + Tailwind CSS
• Runtime: Node.js ≥18.0.0

Production Ready:

• MCP-compliant architecture
• Zero execution violations
• 75% test coverage
• Sub-50ms cached responses

📚 DOCUMENTATION

• 📖 Technical Architecture - System design & patterns
• 🚀 Developer Guide - Setup & development workflows
• 🎯 Project Overview - Business context & strategy
• 📊 Report Examples - Sample workflow reports

🤝 CONTRIBUTING

# Development setup
npm install && npm run db:init && npm run start:dev

# Quality checks
npm run test && npm run lint

Standards: MCP compliance • SOLID principles • Domain-driven design • Evidence-based development

LICENSE

MIT License - see LICENSE file for details.

THE ANUBIS PROMISE