Skip to main content
Glama
π“‚€π“’π“‹Ήπ”Έβ„•π•Œπ”Ήπ•€π•Šπ“‹Ήπ“’π“‚€ - Intelligent Guidance for

π“‚€π“’π“‹Ήπ”Έβ„•π•Œπ”Ήπ•€π•Šπ“‹Ήπ“’π“‚€ - Intelligent Guidance for

by Hive-Academy

π“‚€π“’π“‹Ήπ”Έβ„•π•Œπ”Ήπ•€π•Šπ“‹Ήπ“’π“‚€ - 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 | Repository Pattern Architecture

Repository Pattern Type Safety Clean Architecture

Docker Pulls Docker Image Size Docker Image Version MCP Server

NPM Package β€’ Docker Hub β€’ Website


Related MCP server: session-coord-mcp

QUICK START

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:/app/.anubis",
        "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\\.anubis:/app/.anubis",
        "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

Anubis MCP server Demo

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


πŸ† RECENT ACHIEVEMENTS (v1.2.11)

Repository Pattern Implementation Success 🎯

225% Completion Rate - Exceeded target goals by migrating 9 services (target: 4 services)

Successfully Migrated Services:

  • βœ… workflow-guidance.service.ts - Enhanced testability and maintainability

  • βœ… step-progress-tracker.service.ts - Clean state management

  • βœ… workflow-bootstrap.service.ts - Simplified bootstrap process

  • βœ… progress-calculator.service.ts - Pure business logic functions

  • βœ… step-query.service.ts - Flexible data access strategies

  • βœ… step-execution.service.ts - Reliable execution tracking

  • βœ… role-transition.service.ts - Consistent role management

  • βœ… execution-data-enricher.service.ts - Efficient data aggregation

  • βœ… workflow-guidance-mcp.service.ts - Standardized MCP operations

Technical Excellence Achievements πŸš€

95% Type Safety - Enhanced TypeScript compliance across the entire codebase
Zero Compilation Errors - Complete elimination of TypeScript build issues
75% Maintainability Improvement - Cleaner separation of concerns through repository pattern

MCP Protocol Compliance πŸ€–

Multi-Agent Support - Comprehensive template system for:

  • βœ… Cursor IDE - Intelligent workflow guidance integration

  • βœ… GitHub Copilot - Enhanced AI assistant capabilities

  • βœ… RooCode - Streamlined development workflows

  • βœ… KiloCode - Advanced automation support

Performance Optimizations ⚑

Database Optimization - 434,176 β†’ 421,888 bytes (optimized storage)
Enhanced Query Performance - Repository pattern enables efficient data access
Improved State Management - ExecutionId-based workflow tracking


πŸ—οΈ ARCHITECTURE EXCELLENCE

πŸ† Recent Achievements (v1.2.11)

Repository Pattern Implementation Success

  • 225% Completion Rate: Exceeded target by migrating 9 services (target: 4)

  • 95% Type Safety: Enhanced TypeScript compliance across the codebase

  • Zero Compilation Errors: Complete elimination of TypeScript build issues

  • 75% Maintainability Improvement: Cleaner separation of concerns

Services Successfully Migrated

  • workflow-guidance.service.ts

  • step-progress-tracker.service.ts

  • workflow-bootstrap.service.ts

  • progress-calculator.service.ts

  • step-query.service.ts

  • step-execution.service.ts

  • role-transition.service.ts

  • execution-data-enricher.service.ts

  • workflow-guidance-mcp.service.ts

Technical Highlights

  • βœ… Zero TypeScript Compilation Errors - 95% type safety achieved

  • βœ… 9 Services Migrated - Exceeded 4 service target by 225%

  • βœ… 6 Repository Implementations - Complete data access abstraction layer

  • βœ… 100+ Repository Methods - Comprehensive database operations

  • βœ… SOLID Principles - Clean architecture with dependency injection

  • βœ… Transaction Support - Data integrity across complex operations

Services Utilizing Repository Pattern

// Example: Service with Repository Pattern
@Injectable()
export class WorkflowGuidanceService {
  constructor(
    @Inject('IProjectContextRepository')
    private readonly projectContextRepository: IProjectContextRepository,
    @Inject('IWorkflowRoleRepository')
    private readonly workflowRoleRepository: IWorkflowRoleRepository,
  ) {}

  // 75% maintenance reduction through abstraction layer
}

Repositories: WorkflowExecution β€’ StepProgress β€’ ProjectContext β€’ WorkflowBootstrap β€’ ProgressCalculation β€’ WorkflowRole


πŸš€ Key Features

Repository Pattern Architecture

  • Clean Data Access Layer: Separated business logic from data persistence

  • Enhanced Testability: Mock-friendly repository interfaces

  • SOLID Principles Compliance: Dependency inversion and single responsibility

  • Type-Safe Operations: Comprehensive TypeScript coverage

MCP Protocol Compliance

  • Multi-Agent Support: Cursor, Copilot, RooCode, KiloCode templates

  • Standardized Interactions: Official Model Context Protocol implementation

  • Enhanced AI Integration: Optimized for LLM workflow automation

Performance Optimizations

  • Database Size Reduction: 434176 β†’ 421888 bytes optimized storage

  • Enhanced Query Performance: Repository pattern enables efficient data access

  • Improved State Management: ExecutionId-based workflow tracking


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)
   Enhanced Implementation with Subtasks (Senior Dev Role)
   Quality Validation (Code Review Role)
   Delivery Preparation (Integration Engineer Role)

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": ["Enhanced Implementation with Subtasks 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


INTELLIGENT ROLE SYSTEM

Role

Intelligent Purpose

Key Powers

Product Manager

Strategic Orchestration

Project setup, task creation, workflow management

Architect

System Design

Technical architecture, implementation planning

Senior Developer

Code Manifestation

High-quality implementation, testing

Code Review

Quality Guardian

Security validation, performance review, approval


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. Quality delivery complete! βœ…

TECHNICAL EXCELLENCE

Enterprise-Grade Architecture:

  • Backend: NestJS v11 + TypeScript

  • Database: Prisma ORM + SQLite/PostgreSQL

  • MCP: @rekog/mcp-nest v1.5.2

  • Workflow Engine: Repository Pattern + DDD Architecture

  • Runtime: Node.js β‰₯18.0.0

Production Ready:

  • MCP-compliant architecture

  • Zero execution violations

  • 75% test coverage

  • Sub-50ms cached responses


πŸ“š DOCUMENTATION


🀝 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

Intelligent Guidance ✨ Seamless Transitions ✨ Quality Delivery

Transform your AI workflows from chaotic to intelligent. Give your agents the rules of the ancients with modern MCP-compliant architecture.

Ready to ascend? Add Anubis to your MCP config now!

Available Tools

16 tools
bootstrap_workflowC

Initializes a new workflow execution with boomerang role, starting from git setup through task creation and delegation.

Inputs: executionMode, initialRole, projectPath.

execute_mcp_operationC

Core workflow operations service for executing database and business logic operations through MCP services like TaskOperations, PlanningOperations, WorkflowOperations, etc. Uses consistent parameters and follows strict naming conventions.

Inputs: operation (required), serviceName (required), parameters.

execute_transitionC

Executes role transition and returns execution status with essential details for next steps.

Inputs: roleId (required), taskId (required), transitionId (required), handoffMessage.

generate_workflow_reportB

Generates interactive workflow reports and analytics dashboards with rich visualizations and real-time data tracking.

Inputs: reportType (required), basePath, endDate, mode, +5 more.

get_next_available_stepC

Get focused next step information for role progression.

Inputs: id (required), roleId (required).

get_operation_schemaA

Get the parameter schema definition for a specific MCP service and operation. Returns the exact structure needed for parameters when calling execute_mcp_operation. Useful for understanding what parameters are required and optional for any service operation.

Inputs: serviceName (required), operation.

get_report_statusC

Retrieves current status and results of a report generation request.

Inputs: reportId (required).

get_role_transitionsC

Gets available role transitions with recommendations, scores, and basic requirements for workflow progression.

Inputs: fromRoleName (required), roleId (required), taskId (required).

get_step_guidanceC

Provides focused guidance for executing the current workflow step, including commands and validation checklist.

Inputs: roleId (required), executionId, stepId, taskId.

get_step_progressC

Get focused step progress summary for a task.

Inputs: id (required), roleId.

get_transition_historyB

Retrieves transition history with timeline overview and basic statistics for task context.

Inputs: taskId (required).

get_workflow_guidanceC

Provides minimal role identity and basic capabilities for workflow execution.

Inputs: roleName (required), taskId (required), projectPath.

init_rulesC

Initialize Anubis workflow rules to specified AI agent (cursor or copilot)

Inputs: agentName (required), projectRoot.

report_step_completionC

Report step completion results and get next step guidance.

Inputs: result (required), stepId (required), executionData, executionId, +2 more.

validate_transitionC

Validates role transition requirements and provides pass/fail status with actionable feedback.

Inputs: roleId (required), taskId (required), transitionId (required).

workflow_execution_operationsC

Manages workflow execution state through strongly-typed operations for creating, querying, updating, and completing workflow executions. Handles execution context and progress tracking with validated parameters.

Inputs: operation (required), autoCreatedTask, contextUpdates, dataKey, +8 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    C2.9/5.0

    Scored across 16 tools

    Disambiguation3/5

    The tool set has clear thematic grouping around workflow execution, transitions, and guidance, but there is significant overlap in purpose. For example, get_step_guidance, get_workflow_guidance, and get_next_available_step all provide guidance-related information, which could confuse an agent about which to use. Similarly, execute_mcp_operation and workflow_execution_operations both handle workflow operations, though their descriptions hint at different scopes.

    Naming Consistency4/5

    Most tools follow a consistent verb_noun pattern (e.g., execute_mcp_operation, generate_workflow_report, get_role_transitions), which aids readability. However, there are minor deviations such as init_rules (verb_noun but abbreviated) and workflow_execution_operations (noun-heavy, less action-oriented), slightly disrupting the pattern.

    Tool Count3/5

    With 16 tools, the count is borderline for a workflow guidance server. It feels heavy due to overlapping tools, but it might be justified if each serves a distinct niche in a complex domain. The scope appears broad, covering initialization, execution, transitions, reporting, and guidance, which could warrant this number, but it risks being overwhelming.

    Completeness4/5

    The tool surface covers key aspects of workflow management: initialization (bootstrap_workflow, init_rules), execution (execute_mcp_operation, workflow_execution_operations), transitions (execute_transition, validate_transition), guidance (get_step_guidance, get_workflow_guidance), and reporting (generate_workflow_report, get_report_status). Minor gaps might exist, such as tools for deleting or archiving workflows, but core workflows are well-supported.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers