atlas-mcp-server
- Developer Tools
- OS Automation
ATLAS (Adaptive Task & Logic Automation System) is a Model Context Protocol server that provides hierarchical task management capabilities to Large Language Models. This tool provides LLMs with the structure and context needed to manage complex tasks and dependencies.
Prompts
Interactive templates invoked by user choice
Name | Description |
---|---|
No prompts |
Resources
Contextual data attached and managed by the client
Name | Description |
---|---|
No resources |
Tools
Functions exposed to the LLM to take actions
Name | Description |
---|---|
create_task | Creates a new task with rich content support and automatic status tracking. Supports nested subtask creation. Best Practices: 1. Dependencies must use actual task IDs, not arbitrary strings 2. Create dependent tasks in order, using the returned task IDs 3. Notes support markdown, code, and JSON formats 4. Use metadata.context to provide clear task context 5. Use metadata.tags for categorization 6. Consider task hierarchy - group related tasks under a parent 7. Use reasoning fields to document decision-making process - be clear and concise; 1-2 sentences max. Focus on actionable insights. Example: 1. Create parent task first 2. Note its ID from the response 3. Create child tasks using parentId 4. Use previous task IDs for dependencies Common Mistakes: - Using string identifiers instead of task IDs for dependencies - Creating tasks with dependencies before their dependent tasks exist - Not maintaining proper task hierarchy - Missing context in metadata - Not documenting task reasoning and assumptions |
bulk_create_tasks | Creates multiple tasks at once under the same parent. Best Practices: 1. Use for creating related tasks that share the same parent 2. Consider task order and dependencies 3. Create dependent tasks in separate calls if they need IDs from previous tasks 4. Provide clear context and metadata for each task 5. Document reasoning for task organization Common Mistakes: - Trying to create dependent tasks before their dependencies exist - Missing task context and metadata - Not considering task hierarchy - Missing reasoning documentation |
get_task | Retrieves a task by ID with all its content and metadata. Best Practices: 1. Use to verify task creation and updates 2. Check task status and dependencies 3. Review subtask hierarchy |
update_task | Updates an existing task with automatic parent status updates and dependency validation. Best Practices: 1. Verify task exists before updating 2. Consider impact on dependent tasks 3. Update status appropriately 4. Maintain task context in metadata 5. Document reasoning changes Status Flow: - pending → in_progress → completed - pending → blocked (if dependencies not met) - in_progress → failed (if issues occur) |
bulk_update_tasks | Updates multiple tasks at once with automatic parent status updates and dependency validation. Best Practices: 1. Use for batch status updates or metadata changes 2. Consider impact on task hierarchy 3. Maintain data consistency 4. Document changes in reasoning Common Mistakes: - Not using valid task IDs - Creating circular dependencies - Inconsistent status updates - Missing context in updates |
delete_task | Safely deletes a task and its subtasks with dependency checking. Best Practices: 1. Check for dependent tasks first 2. Consider impact on parent task 3. Verify task completion status Common Mistakes: - Deleting tasks that others depend on - Not considering impact on project structure |
get_subtasks | Retrieves all subtasks of a task for hierarchy navigation. Best Practices: 1. Use for understanding task breakdown 2. Check subtask status and progress 3. Verify task relationships |
get_task_tree | Retrieves the entire task hierarchy starting from root tasks. Best Practices: 1. Use for understanding overall project structure 2. Check task relationships and dependencies 3. Monitor project progress 4. Verify task organization |
get_tasks_by_status | Retrieves all tasks with a specific status for progress tracking. Best Practices: 1. Monitor task progress 2. Identify blocked or failed tasks 3. Track completion status 4. Find tasks needing attention |
Server Configuration
Describes the environment variables required to run the server.
Name | Required | Description | Default |
---|---|---|---|
TASK_STORAGE_DIR | Yes | Directory for task data storage |
ATLAS MCP Server
ATLAS (Adaptive Task & Logic Automation System) is a Model Context Protocol server that provides hierarchical task management capabilities to Large Language Models. This tool provides LLMs with the structure and context needed to manage complex tasks and dependencies.
Table of Contents
- Overview
- Features
- Installation
- Configuration
- Task Structure
- Tools
- Best Practices
- Development
- Up Next
- Contributing
- License
Overview
Model Context Protocol Server
ATLAS implements the Model Context Protocol (MCP), created by Anthropic, which is a standardized communication protocol between LLMs and external systems. The architecture consists of:
- Clients (Claude Desktop, IDEs) that maintain server connections
- Servers that provide tools and resources to clients
- LLMs that interact with servers through client applications
This architecture creates a secure boundary between LLMs and external systems while enabling controlled access to functionality.
Core Components
ATLAS is built on several robust core components:
- TaskManager: Central coordinator for all task operations
- TaskStore: Handles persistent storage and retrieval of tasks
- DependencyValidator: Ensures valid task relationships and dependencies
- StatusManager: Manages task state transitions and propagation
- StorageManager: Provides durable data persistence
- RateLimiter: Controls request rates (600 req/min)
- HealthMonitor: Tracks system health
- MetricsCollector: Gathers performance metrics
- RequestTracer: Traces request flow
Through the MCP protocol, ATLAS empowers LLMs to break down complex projects into manageable tasks, track their progress, and maintain dependencies — all within an organized hierarchical structure.
Features
Task Organization
- Hierarchical task structures with parent-child relationships
- Dependency management and validation
- Status tracking and automatic propagation
- Bulk operations for efficient task management
- Session-based task isolation
Content Support
- Markdown documentation
- Code snippets with syntax highlighting
- JSON data structures
- Rich metadata and tagging
- Task reasoning documentation
- Decision-making history
System Features
- Rate limiting (600 requests/minute)
- Health monitoring and metrics
- Request tracing
- Error handling with detailed context
- Graceful shutdown handling
- Session management
- Audit logging
Performance
- Efficient task storage and retrieval
- Bulk operation support
- Request timeout handling
- Concurrent request management
- Resource cleanup
Installation
Setup Steps
- Clone the repository:
- Navigate to the project directory:
- Install dependencies:
- Build the project:
- Create a storage directory for tasks:
The server is now ready to be configured and used with your MCP client.
Configuration
ATLAS requires configuration in your MCP client settings:
Environment Variables
Variable | Description | Required |
---|---|---|
TASK_STORAGE_DIR | Directory for task data storage | Yes |
Task Structure
Tasks support rich content, metadata, and reasoning documentation:
The reasoning field provides structured documentation of decision-making:
- approach: High-level implementation strategy
- assumptions: Key assumptions made during planning
- alternatives: Other approaches that were considered
- risks: Potential issues and challenges
- tradeoffs: Key decisions and their implications
- constraints: Technical or business limitations
- dependencies_rationale: Reasoning for task dependencies
- impact_analysis: Analysis of changes on the system
Example Task List (Without reasoning)
The following example demonstrates a task breakdown for a personal portfolio website project. The task list was generated from the following prompt:
<details> <summary><b>Portfolio Website Development Task List</b></summary>You are a web developer for modern apps. Architect, design, and plan the required tasks for a personal portfolio website for a web dev that has a modern UI/UX.
Tools
Task Management
create_task
Creates a new task with optional subtasks.
bulk_create_tasks
Creates multiple tasks efficiently in a single operation. Supports:
- Batch creation under a common parent
- Automatic dependency validation
- Status propagation
- Transaction handling for consistency
update_task
Updates an existing task with automatic status propagation and validation:
- Validates status transitions
- Updates dependent tasks
- Maintains task hierarchy
- Preserves task history
delete_task
Safely removes a task and its subtasks:
- Recursive deletion of subtasks
- Dependency cleanup
- Status propagation
- Reference removal
- Transaction handling
Task Retrieval
get_task
Retrieves a task by ID with full context:
- Complete task details
- Status information
- Dependency data
- Metadata and history
- Error context if applicable
get_subtasks
Lists all subtasks of a specified task:
- Direct child tasks
- Status information
- Dependency relationships
- Metadata and context
- Hierarchical structure
get_task_tree
Retrieves the complete task hierarchy:
- Full task tree structure
- Status aggregation
- Dependency mapping
- Metadata inheritance
- Performance optimized
get_tasks_by_status
Filters tasks by their current status:
- Status-based filtering
- Optional parent filtering
- Dependency context
- Metadata inclusion
- Performance optimized
System Features
Rate Limiting
- 600 requests per minute limit
- Automatic request throttling
- Queue management
- Error handling
- Client feedback
Health Monitoring
- System health checks
- Resource monitoring
- Error tracking
- Performance metrics
- Status reporting
Request Tracing
- Request lifecycle tracking
- Performance monitoring
- Error context capture
- Debug information
- Audit logging
Error Handling
ATLAS provides comprehensive error handling:
- Validation errors with context
- Dependency conflict detection
- Task state inconsistencies
- System resource issues
- Transaction failures
- Rate limit violations
- Request timeout handling
Best Practices
Task Management
- Create parent tasks before subtasks
- Use task IDs for dependencies
- Provide clear context in metadata
- Use appropriate task types
- Document reasoning and assumptions
- Handle status transitions carefully
- Monitor dependency relationships
- Maintain task hierarchy
Content Organization
- Use appropriate note types
- Include relevant code samples
- Maintain clear documentation
- Document decision-making process
- Keep metadata current
- Tag tasks appropriately
- Structure hierarchies logically
Performance Optimization
- Use bulk operations for multiple tasks
- Monitor rate limits
- Handle long-running operations
- Implement proper error handling
- Optimize task retrieval
- Cache frequently accessed data
- Clean up completed tasks
Error Recovery
- Handle validation errors gracefully
- Resolve dependency conflicts
- Manage status inconsistencies
- Recover from system issues
- Maintain data integrity
- Document error contexts
- Implement retry strategies
Development
Up Next
Enhanced Task Management
- Task scheduling with time-based triggers
- Recurring task support
- Task templates and presets
- Advanced filtering and search
- Custom task types
- Task archiving
System Improvements
- Enhanced performance monitoring
- Advanced caching strategies
- Improved error recovery
- Better dependency management
- Transaction optimizations
- Resource usage tracking
Integration Features
- Webhook support
- External system integration
- Event streaming
- Custom tool support
- Plugin architecture
- API versioning
Contributing
Contributions are welcome! Please follow these steps:
- Fork the repository
- Create a feature branch
- Commit your changes
- Push to the branch
- Create a Pull Request
For bugs and feature requests, please create an issue.
License
Apache License 2.0
<div align="center"> Built with the Model Context Protocol </div>
GitHub Badge
Glama performs regular codebase and documentation scans to:
- Confirm that the MCP server is working as expected.
- Confirm that there are no obvious security issues with dependencies of the server.
- Extract server characteristics such as tools, resources, prompts, and required parameters.
Our directory badge helps users to quickly asses that the MCP server is safe, server capabilities, and instructions for installing the server.
Copy the following code to your README.md file: