home-lab/research/taskmaster-ai.md

Task Master + Ollama Research & Integration Plan

Project Overview

Task Master (https://www.task-master.dev/) is an AI-powered task management system that can be enhanced with local AI capabilities through Ollama integration for intelligent task breakdown, prioritization, and execution tracking while maintaining complete data privacy.

Key Features Analysis

Core Capabilities

• Intelligent Task Breakdown: Automatically decomposes complex projects into manageable subtasks
• Context-Aware Planning: Uses AI to understand project requirements and dependencies
• Progress Tracking: Monitors task completion and adjusts plans dynamically
• Natural Language Interface: Allows task management through conversational commands
• Integration Ready: Designed to work with existing development workflows

Technical Architecture

• Backend: Node.js/Python-based task orchestration
• AI Integration: Ollama API for local task analysis and planning
• Storage: JSON/Database for task persistence
• API: RESTful endpoints for external integrations

Workflow Compatibility Assessment

Current Home-lab Methodology Alignment

✅ Strong Fits

1. Infrastructure-as-Code Philosophy

   • Task Master's structured approach aligns with your NixOS configuration management
   • Can track infrastructure changes as tasks with dependencies

2. Service-Oriented Architecture

   • Fits well with your microservices approach (Transmission, monitoring, etc.)
   • Can manage service deployment and configuration tasks

3. Documentation-Driven Development

   • Integrates with your markdown-based documentation workflow
   • Can auto-generate task documentation and progress reports

⚠️ Considerations

1. Resource Overhead

   • Additional service to manage in your infrastructure
   • Local AI processing requirements on grey-area

2. Hardware Requirements

   • Need sufficient RAM/CPU for Ollama models
   • Storage requirements for model files

Integration Strategy

Phase 1: Core Installation & Setup

Prerequisites

# Dependencies for Home-lab integration
- Node.js runtime environment
- Ollama service on grey-area
- Docker/Podman for containerization
- NixOS service configuration

Installation Plan

1. Clone and Setup

   cd /home/geir/Home-lab/services
   git clone https://github.com/task-master-dev/task-master.git taskmaster
   cd taskmaster
   

2. NixOS Service Configuration

   • Create taskmaster.nix service definition
   • Configure Ollama endpoint and environment variables
   • Set up reverse proxy through existing nginx setup

3. Environment Configuration

   OLLAMA_API_URL=http://grey-area:11434/api
   OLLAMA_MODEL=llama3.2:8b
   TASKMASTER_PORT=3001
   DATABASE_URL=sqlite:///mnt/storage/taskmaster.db
   

Phase 2: GitHub Copilot Integration

Integration Points

1. Code Task Generation

   • Use Copilot to generate coding tasks from repository analysis
   • Automatic task creation from GitHub issues and PRs

2. Development Workflow Enhancement

   // Example integration hook
   interface CopilotTaskBridge {
     generateTasksFromCode(filePath: string): Task[];
     updateTaskProgress(taskId: string, codeChanges: CodeDiff[]): void;
     suggestNextSteps(currentTask: Task): Suggestion[];
   }
   

3. VS Code Extension Development

   • Custom extension to bridge Copilot suggestions with Task Master
   • Real-time task updates based on code changes

Phase 3: Context7 MCP Integration

Model Context Protocol Benefits

1. Unified Context Management

   • Task Master tasks as context for Ollama conversations
   • Project state awareness across all AI interactions

2. Cross-Service Communication

   {
     "mcp_config": {
       "services": {
         "taskmaster": {
           "endpoint": "http://sleeper-service:3001/api",
           "capabilities": ["task_management", "progress_tracking"]
         },
         "github_copilot": {
           "integration": "vscode_extension",
           "context_sharing": true
         }
       }
     }
   }
   

3. Context Flow Architecture

   GitHub Copilot → Context7 MCP → Task Master → Ollama API
        ↑                                           ↓
   VS Code Editor ←─────── Task Updates ←─────── AI Insights
   

Implementation Roadmap

Week 1: Foundation

• Set up Task Master on sleeper-service
• Configure basic NixOS service
• Set up Ollama on grey-area
• Create initial task templates for Home-lab projects

Week 2: GitHub Integration

• Develop Copilot bridge extension
• Set up GitHub webhook integration
• Create automated task generation from repository events
• Test code-to-task mapping

Week 3: MCP Integration

• Implement Context7 MCP protocol support
• Create unified context sharing system
• Develop cross-service communication layer
• Test end-to-end workflow

Week 4: Optimization & Documentation

• Performance tuning and monitoring
• Complete integration documentation
• Create user workflow guides
• Set up backup and recovery procedures

NixOS Service Configuration Preview

# /home/geir/Home-lab/machines/sleeper-service/services/taskmaster.nix
{ config, pkgs, ... }:

{
  services.taskmaster = {
    enable = true;
    port = 3001;
    user = "sma";
    group = "users";
    environmentFile = "/etc/taskmaster/env";
    dataDir = "/mnt/storage/taskmaster";
  };

  # Nginx reverse proxy configuration
  services.nginx.virtualHosts."taskmaster.home-lab" = {
    locations."/" = {
      proxyPass = "http://localhost:3001";
      proxyWebsockets = true;
    };
  };

  # Firewall configuration
  networking.firewall.allowedTCPPorts = [ 3001 ];
}

Benefits for Home-lab Workflow

Immediate Improvements

1. Project Visibility: Clear overview of all infrastructure tasks and their status
2. Dependency Management: Automatic tracking of service dependencies and update sequences
3. Documentation Automation: AI-generated task documentation and progress reports
4. Workflow Optimization: Intelligent task prioritization based on system state

Long-term Value

1. Knowledge Retention: Comprehensive history of infrastructure decisions and changes
2. Onboarding: New team members can quickly understand project structure through task history
3. Compliance: Automated tracking for security updates and maintenance tasks
4. Scalability: Framework for managing larger infrastructure deployments

Risk Assessment & Mitigation

Technical Risks

• Hardware Limitations: Grey-area may not have sufficient resources for larger models
• Data Loss: Regular backups to /mnt/storage/backups
• Performance Impact: Resource monitoring and limits

Security Considerations

• Network Isolation: Local Ollama API access only from sleeper-service
• Firewall Rules: Restrict Ollama API access to authorized services
• Data Encryption: Encrypt sensitive task data at rest

Ollama Self-Hosted AI Integration

Ollama on Grey-Area Research

Ollama provides a lightweight, self-hosted alternative to external AI APIs that can run on your grey-area server, offering complete data privacy and control while eliminating external API dependencies.

Grey-Area Hardware Assessment

Current Specifications

• CPU: Check grey-area specs for AI workload capability
• RAM: Minimum 8GB for smaller models, 16GB+ recommended for larger models
• Storage: SSD recommended for model storage and fast inference
• GPU: NVIDIA GPU would significantly improve performance (if available)

Model Size Considerations

# Recommended models for task management:
# Lightweight options (4-8GB RAM):
- llama3.2:3b (2GB model size)
- gemma2:2b (1.5GB model size)
- phi3:3.8b (2.3GB model size)

# Medium performance (8-16GB RAM):
- llama3.2:8b (4.7GB model size)
- gemma2:9b (5.4GB model size)
- mistral:7b (4.1GB model size)

# High performance (16GB+ RAM):
- llama3.1:70b (40GB model size) - if grey-area has sufficient resources

Context7 MCP + Ollama Architecture

Integration Benefits

1. Complete Data Privacy: All AI processing stays within your infrastructure
2. No API Rate Limits: Unlimited local inference capacity
3. Cost Efficiency: No per-token costs after initial setup
4. Low Latency: Local processing eliminates network round-trips
5. Customization: Fine-tune models for specific task management patterns

Technical Stack

VS Code + GitHub Copilot
         ↓
Context7 MCP Server (sleeper-service)
         ↓
Task Master (sleeper-service) ←→ Ollama API (grey-area:11434)
         ↓
Local Model Inference (grey-area)

NixOS Ollama Configuration for Grey-Area

Service Definition

# /home/geir/Home-lab/machines/grey-area/services/ollama.nix
{ config, pkgs, ... }:

{
  services.ollama = {
    enable = true;
    acceleration = "cuda"; # or "rocm" if AMD GPU, omit if CPU-only
    environmentVariables = {
      OLLAMA_HOST = "0.0.0.0:11434";
      OLLAMA_MODELS = "/mnt/storage/ollama/models";
    };
    openFirewall = true;
  };

  # Ensure sufficient resources
  systemd.services.ollama = {
    serviceConfig = {
      MemoryMax = "16G"; # Adjust based on available RAM
      CPUQuota = "400%"; # Use 4 CPU cores max
    };
  };

  # Storage configuration
  fileSystems."/mnt/storage/ollama" = {
    device = "/dev/disk/by-label/storage";
    fsType = "ext4";
    options = [ "defaults" "noatime" ];
  };
}

Model Management Script

#!/usr/bin/env bash
# /home/geir/Home-lab/scripts/ollama-setup.sh

# Pull recommended models for task management
ollama pull llama3.2:8b
ollama pull gemma2:9b
ollama pull mistral:7b

# Create custom modelfile for task management optimization
cat > /tmp/taskmaster-model << EOF
FROM llama3.2:8b
PARAMETER temperature 0.7
PARAMETER top_p 0.9
SYSTEM """You are an AI assistant specialized in project task management and software development workflows. You excel at breaking down complex projects into manageable tasks, understanding dependencies, and providing clear, actionable guidance. Always respond with structured, practical information."""
EOF

ollama create taskmaster-optimized -f /tmp/taskmaster-model

Modified Task Master Integration

Environment Configuration for Ollama

# Replace Claude API with Ollama endpoint
AI_PROVIDER=ollama
OLLAMA_API_URL=http://grey-area:11434/api
OLLAMA_MODEL=taskmaster-optimized
# Fallback models
OLLAMA_FALLBACK_MODELS=llama3.2:8b,gemma2:9b,mistral:7b

API Adapter Layer

// services/ai-provider.ts
interface AIProvider {
  generateResponse(prompt: string, context?: any): Promise<string>;
  analyzeTask(taskDescription: string): Promise<TaskAnalysis>;
  suggestSubtasks(project: Project): Promise<Subtask[]>;
}

class OllamaProvider implements AIProvider {
  private baseUrl = process.env.OLLAMA_API_URL;
  private model = process.env.OLLAMA_MODEL || 'llama3.2:8b';

  async generateResponse(prompt: string, context?: any): Promise<string> {
    const response = await fetch(`${this.baseUrl}/generate`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        model: this.model,
        prompt,
        context,
        stream: false
      })
    });
    return response.json().then(data => data.response);
  }

  // ...existing code...
}

Context7 MCP Integration for Ollama

MCP Server Configuration

{
  "mcp_config": {
    "version": "1.0",
    "servers": {
      "taskmaster": {
        "endpoint": "http://sleeper-service:3001/mcp",
        "capabilities": ["task_management", "project_context"]
      },
      "ollama": {
        "endpoint": "http://grey-area:11434/v1",
        "type": "openai_compatible",
        "model": "taskmaster-optimized",
        "capabilities": ["text_generation", "task_analysis"]
      }
    },
    "context_routing": {
      "task_operations": "taskmaster",
      "ai_inference": "ollama",
      "code_analysis": "github_copilot"
    }
  }
}

Context Flow with Ollama

GitHub Copilot (VS Code)
         ↓
Context7 MCP Server (sleeper-service)
         ↓ (project context + task history)
Task Master API (sleeper-service)
         ↓ (AI inference requests)
Ollama API (grey-area:11434)
         ↓
Local Model Processing (grey-area)

Performance Optimization Strategies

Model Selection Matrix

Use Case	Model	RAM Req	Response Time	Quality
Quick tasks	phi3:3.8b	4GB	<2s	Good
Standard workflow	llama3.2:8b	8GB	<5s	Excellent
Complex analysis	gemma2:9b	12GB	<10s	Excellent
Heavy workloads	mistral:7b	8GB	<7s	Very Good

Caching Strategy

// Implement response caching for common queries
class OllamaCache {
  private cache = new Map<string, CachedResponse>();
  
  async getCachedResponse(prompt: string): Promise<string | null> {
    const hash = this.hashPrompt(prompt);
    const cached = this.cache.get(hash);
    
    if (cached && !this.isExpired(cached)) {
      return cached.response;
    }
    return null;
  }
  
  setCachedResponse(prompt: string, response: string): void {
    const hash = this.hashPrompt(prompt);
    this.cache.set(hash, {
      response,
      timestamp: Date.now(),
      ttl: 300000 // 5 minutes
    });
  }
}

Deployment Strategy Comparison

Ollama vs External APIs Comparison

Aspect	Ollama (Grey-Area)	External APIs (Claude/OpenAI)
Privacy	✅ Complete local control	❌ External processing
Cost	✅ One-time setup cost	❌ Per-token pricing
Performance	⚠️ Hardware dependent	✅ Consistent cloud performance
Availability	⚠️ Depends on grey-area uptime	✅ High availability SLA
Model Updates	⚠️ Manual model management	✅ Automatic improvements
Setup Complexity	❌ Requires local infrastructure	✅ API key only

Implementation Phases for Ollama Integration

Phase 1: Ollama Infrastructure (Week 1-2)

• Install Ollama on grey-area via NixOS
• Benchmark grey-area hardware with different models
• Set up model management and automatic updates
• Configure networking and firewall rules
• Test basic inference performance

Phase 2: Task Master Adaptation (Week 2-3)

• Modify Task Master to support Ollama API
• Implement AI provider abstraction layer
• Add response caching and optimization
• Create model selection logic based on task complexity
• Test task breakdown and analysis quality

Phase 3: Context7 Integration (Week 3-4)

• Configure MCP server for Ollama endpoint
• Implement context sharing between services
• Set up GitHub Copilot → Context7 → Ollama flow
• Test end-to-end workflow with local inference
• Performance tuning and monitoring

Phase 4: Hybrid Deployment (Week 4-5)

• Implement fallback to external APIs for complex queries
• Create intelligent routing based on task complexity
• Set up monitoring and alerting for Ollama service
• Document operational procedures
• Create backup and disaster recovery plans

Hardware Recommendations for Grey-Area

Minimum Requirements

• RAM: 16GB (8GB for OS + 8GB for model)
• CPU: 4+ cores with good single-thread performance
• Storage: 100GB SSD for models and cache
• Network: Gigabit connection to sleeper-service

Optimal Configuration

• RAM: 32GB (enables larger models and concurrent requests)
• CPU: 8+ cores or GPU acceleration
• Storage: NVMe SSD for maximum I/O performance
• Monitoring: Resource usage tracking for optimization

Risk Assessment for Ollama Deployment

Technical Risks

• Hardware Limitations: Grey-area may not have sufficient resources for larger models
• Single Point of Failure: Ollama downtime affects entire AI workflow
• Model Quality: Local models may not match external APIs' performance for complex tasks

Mitigation Strategies

• Hybrid Approach: Use Ollama for standard tasks, external APIs for complex analysis
• High Availability: Set up Ollama clustering if multiple servers available
• Progressive Deployment: Start with smaller models and scale up based on performance

Success Metrics

Performance Benchmarks

• Response Time: <10 seconds for standard task analysis
• Accuracy: Task breakdown quality comparable to external APIs
• Availability: >99% uptime for Ollama service
• Resource Usage: <80% RAM utilization during peak usage

Cost Analysis

# Estimated savings over 1 year
External APIs (estimated): $500-1000/year
Ollama Infrastructure: $0 (using existing hardware)
Power Consumption: ~$50/year additional
Net Savings: $450-950/year

Recommendation: Proceed with Ollama integration as primary research track, with external APIs as fallback option. This approach provides maximum privacy, cost efficiency, and aligns with your self-hosted infrastructure philosophy.