ππ’πΉπΈβππΉπππΉπ’π - Intelligent Guidance for
The Anubis server orchestrates AI agent-driven development workflows through three core capabilities:
Intelligent Guidance: Provides step-by-step rules for AI agents (like cursor, copilot, roocode) across specialized roles (Researcher, Architect, Senior Developer, Code Reviewer), including quality checklists and structured approaches for efficient task execution.
Seamless Role Transitions: Preserves context when switching between roles, facilitates automatic task handoffs, validates transitions based on workflow progress, and maintains historical records of all role changes.
Comprehensive Reporting: Generates interactive HTML reports with analytics dashboards (using Chart.js and Tailwind CSS), tracks workflow progress, provides performance insights, and offers both visual and JSON output formats.
Additionally, it manages complete workflow lifecycles through creation, updates, validation, and task tracking, while supporting execution of underlying MCP service operations.
Enables generation of interactive dashboards and visualizations in the workflow reports using Chart.js
Provides containerized deployment options for running the Anubis MCP server with isolated storage using Docker volumes
Built on NestJS for the backend architecture, providing enterprise-grade MCP-compliant server capabilities
Runs on Node.js runtime environment (v18.0.0 or higher) for server execution
Offers package distribution through NPM for easy installation and dependency management
Supports PostgreSQL database integration for persistent storage of workflow data
Uses Prisma ORM for database operations and model management across SQLite/PostgreSQL
Supports SQLite database integration for lightweight storage options
Leverages Tailwind CSS for mobile-responsive design in generated HTML reports
Built with TypeScript for type-safe development and integration
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., "@ππ’πΉπΈβππΉπππΉπ’π - Intelligent Guidance for initialize Anubis workflow rules for cursor"
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.
ππ’πΉπΈβππΉπππΉπ’π - 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
NPM Package β’ Docker Hub β’ Website
Related MCP server: session-coord-mcp
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:/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 toolStep 2: Start Your Workflow
Begin a new workflow for [your-project] with Anubis guidanceROOCODE 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:
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" } }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.mdcHead 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/anubismake sure you are on the poject root you want to install this into.
To make sure it's installed correctly run
claude mcp listyou should see a server with nameanubis.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
rulesand file nameanubis-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
π Technical Architecture - System design & patterns
π Developer Guide - Setup & development workflows
π― Project Overview - Business context & strategy
ποΈ Technical Architecture - System design & patterns
π€ CONTRIBUTING
# Development setup
npm install && npm run db:init && npm run start:dev
# Quality checks
npm run test && npm run lintStandards: 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 toolsbootstrap_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
Scored across 16 tools
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.
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.
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.
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
Related MCP Connectors
Orbit is an MCP server that gives your AI agents a 4000+ tools, a shared memory brain and a live dashboard OS. Every agent reads active decisions, logs outputs to a searchable vault, and reports status in real time. 2-minute setup via MCP; works across Claude, ChatGPT, Codex, Cursor, Gemini, and Manus. Finally Agents work, agents that grow your business and bring you customers. https://orbitagents.xyz
MCP hosting for AI agents: Claude or Codex writes the code, runs it and sends a live link.
HiveCapital MCP Server β autonomous investment layer for AI agents
Shared memory and mail for your AI agents. Verified with Claude Code; other MCP clients in testing.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceA lightweight MCP server that enhances AI agents with tools for codebase analysis, task delegation to sub-agents, multi-agent coordination through chatrooms, and project todo management.-
- AlicenseNot gradedqualityDmaintenanceA local-first MCP server for coordinating parallel AI coding sessions with tools like Claude Code and Codex in a single repository.2MIT
- AlicenseNot gradedqualityDmaintenanceA Model Context Protocol (MCP) server that turns multiple AI coding agents into a coordinated team that chats, debates, remembers, audits security, and works in parallel on the same project.MIT
- AlicenseNot gradedqualityDmaintenanceFull autonomous project management MCP server enabling AI assistants to manage projects, sprints, tasks, bugs, proposals, and team collaboration via natural language.10 npmMIT