TaskAI - Multi-Agent Task Execution System

A modern, scalable multi-agent task execution system built with Python, featuring asynchronous processing, safety management, and intelligent task orchestration.

🚀 Features

• Multi-Agent Architecture: Modular agent system with specialized capabilities
• Asynchronous Processing: High-performance async/await patterns throughout
• Safety & Security: Comprehensive safety checks and security measures
• Shared Memory: Redis-backed shared memory for inter-agent communication
• Message Bus: Asynchronous message passing between agents
• Task Orchestration: Intelligent task scheduling and dependency management
• Rich CLI: Beautiful command-line interface with Rich
• Comprehensive Logging: Structured logging with Loguru
• Configuration Management: Environment-based configuration with Pydantic
• Data Validation: Robust validation system for all inputs

📋 Requirements

• Python 3.9+
• Redis server
• LLM API keys (Groq, Google, or OpenAI)

🛠️ Installation

1. Clone the repository:

   git clone <repository-url>
   cd task-ai

2. Install dependencies:

   pip install -r requirements.txt

3. Set up environment variables:

   cp .env.example .env
   # Edit .env with your configuration

4. Start Redis:

   redis-server

🚀 Quick Start

1. Run the system:

   python main.py

2. Use the CLI:

   taskai> help
   taskai> status
   taskai> submit
   

📁 Project Structure

task-ai/
├── src/
│   ├── core/           # Core system components
│   │   ├── orchestrator.py    # Task orchestration
│   │   ├── memory.py          # Shared memory system
│   │   ├── message_bus.py     # Message passing
│   │   └── safety.py          # Safety management
│   ├── agents/         # Agent implementations
│   │   ├── base_agent.py      # Abstract base class
│   │   ├── planner.py         # Task planning agent
│   │   ├── file_handler.py    # File operations agent
│   │   ├── shell_executor.py  # Command execution agent
│   │   └── monitor.py         # System monitoring agent
│   ├── utils/          # Utility modules
│   │   ├── prompt_refiner.py  # LLM prompt optimization
│   │   └── validators.py      # Data validation
│   └── config/         # Configuration management
│       └── settings.py        # Application settings
├── main.py             # CLI entry point
├── requirements.txt    # Python dependencies
├── pyproject.toml      # Project configuration
└── README.md          # This file

🔧 Configuration

Environment Variables

Create a .env file with the following variables:

# Application
APP_NAME=TaskAI
DEBUG=false

# LLM Configuration
LLM_PROVIDER=groq
LLM_API_KEY=your_api_key_here
LLM_MODEL=llama3-8b-8192

# Redis Configuration
REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_DB=0

# Logging
LOG_LEVEL=INFO
LOG_FILE_PATH=logs/taskai.log

# Safety
SAFETY_ENABLED=true
SAFETY_MAX_FILE_SIZE=10485760

Configuration Sections

• LLM: Language model provider settings
• Redis: Shared memory backend configuration
• Logging: Logging behavior and output
• Safety: Security and safety parameters

🤖 Agents

Base Agent

Abstract base class providing common functionality:

• Lifecycle management
• Task processing
• Memory access
• Message passing
• Error handling

Specialized Agents

1. Planner Agent: Task decomposition and planning
2. File Handler Agent: File system operations
3. Shell Executor Agent: Command execution
4. Monitor Agent: System monitoring and logging

🔄 Task Execution

Task Lifecycle

1. Submission: Tasks are submitted to the orchestrator
2. Validation: Parameters and safety checks are performed
3. Scheduling: Tasks are queued based on priority and dependencies
4. Execution: Suitable agents execute the tasks
5. Completion: Results are stored and status updated

Task Types

• File Operations: Read, write, delete, list files
• Command Execution: Execute shell commands safely
• Data Analysis: Process and analyze data
• Code Generation: Generate code based on requirements

🛡️ Safety & Security

Safety Features

• File Operation Safety: Path validation and extension checking
• Command Execution Safety: Blocked commands and pattern detection
• Execution Time Limits: Prevent runaway processes
• File Size Limits: Prevent memory exhaustion
• Agent Operation Safety: Controlled agent interactions

Security Measures

• Input Validation: Comprehensive data validation
• Path Sanitization: Safe file path handling
• Command Filtering: Dangerous command detection
• Resource Limits: Memory and time constraints

📊 Monitoring & Logging

Logging

• Structured Logging: JSON-formatted logs with context
• Multiple Outputs: Console and file logging
• Log Rotation: Automatic log file management
• Log Levels: Configurable verbosity

Monitoring

• System Status: Real-time system health monitoring
• Agent Performance: Task success/failure tracking
• Resource Usage: Memory and execution time monitoring
• Safety Violations: Security incident tracking

🔌 API Integration

LLM Providers

• Groq: Fast inference with Llama models
• Google: Gemini models for complex reasoning
• OpenAI: GPT models for general tasks

External Services

• Redis: Shared memory and caching
• File System: Local and remote file operations
• Shell: Command execution and process management

🧪 Development

Setup Development Environment

# Install development dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Code formatting
black src/
isort src/

# Type checking
mypy src/

Adding New Agents

1. Inherit from BaseAgent
2. Implement required abstract methods
3. Register agent type with orchestrator
4. Add validation rules

Adding New Task Types

1. Define task parameters
2. Add validation schema
3. Implement agent logic
4. Update CLI interface

📈 Performance

Optimization Features

• Async Processing: Non-blocking I/O operations
• Connection Pooling: Efficient Redis connections
• Task Queuing: Priority-based task scheduling
• Memory Management: Automatic cleanup and expiration
• Resource Limits: Prevent resource exhaustion

Scalability

• Horizontal Scaling: Multiple agent instances
• Load Balancing: Intelligent task distribution
• Resource Isolation: Per-agent resource limits
• Fault Tolerance: Graceful error handling

🤝 Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests
5. Submit a pull request

Code Style

• Follow PEP 8
• Use type hints
• Add docstrings
• Write tests
• Use async/await patterns

📄 License

MIT License - see LICENSE file for details.

🆘 Support

• Documentation: Check the code comments and docstrings
• Issues: Report bugs and feature requests on GitHub
• Discussions: Join community discussions

🔮 Roadmap

• Web-based dashboard
• REST API
• Docker support
• Kubernetes deployment
• Plugin system
• Advanced scheduling
• Machine learning integration
• Cloud deployment guides

---

TaskAI - Empowering intelligent task execution through multi-agent collaboration.