proffesor-for-testing__agentic-qe/docs/architecture/qe-mcp-tools.md

Agentic QE MCP Tools Specification

Overview

The Agentic QE MCP (Model Context Protocol) tools provide the coordination layer for quality engineering operations. These tools handle fleet management, test orchestration, quality analysis, and intelligence gathering while the actual execution is performed by Claude Code's Task tool spawning real agents.

Core QE Fleet Management Tools

Fleet Initialization and Management

qe_fleet_init

{
  name: "qe_fleet_init",
  description: "Initialize QE agent fleet with specified topology and strategy",
  parameters: {
    topology: {
      type: "string",
      enum: ["hierarchical", "mesh", "ring", "star", "adaptive"],
      description: "Fleet coordination topology"
    },
    maxAgents: {
      type: "number",
      default: 12,
      minimum: 1,
      maximum: 100,
      description: "Maximum number of QE agents in fleet"
    },
    strategy: {
      type: "string",
      enum: ["balanced", "specialized", "adaptive", "performance-optimized"],
      default: "adaptive",
      description: "Agent distribution and coordination strategy"
    },
    qe_focus: {
      type: "string",
      enum: ["unit-testing", "integration-testing", "e2e-testing", "security-testing", "performance-testing", "full-spectrum"],
      default: "full-spectrum",
      description: "Primary quality engineering focus area"
    }
  }
}

qe_agent_spawn

{
  name: "qe_agent_spawn",
  description: "Spawn specialized QE agent with specific capabilities",
  parameters: {
    type: {
      type: "string",
      enum: [
        "unit-test-generator", "integration-test-generator", "api-test-generator",
        "ui-test-generator", "performance-test-generator", "security-test-agent",
        "code-quality-analyzer", "coverage-analyzer", "test-runner-orchestrator",
        "environment-manager", "data-manager", "result-aggregator",
        "failure-investigator", "quality-metrics-collector", "trend-analyzer",
        "risk-assessor", "quality-reporter", "ai-test-designer",
        "chaos-engineering-agent", "mutation-test-agent", "visual-test-agent"
      ],
      description: "Type of QE agent to spawn"
    },
    specialization: {
      type: "string",
      description: "Specific specialization within agent type (e.g., 'jest', 'cypress', 'k6')"
    },
    capabilities: {
      type: "array",
      items: { type: "string" },
      description: "Specific capabilities for the agent"
    },
    resources: {
      type: "object",
      properties: {
        cpu: { type: "number", description: "CPU allocation" },
        memory: { type: "number", description: "Memory allocation in MB" },
        storage: { type: "number", description: "Storage allocation in GB" }
      },
      description: "Resource allocation for the agent"
    }
  },
  required: ["type"]
}

Test Orchestration Tools

qe_test_orchestrate

{
  name: "qe_test_orchestrate",
  description: "Orchestrate comprehensive testing workflow across QE fleet",
  parameters: {
    workflow: {
      type: "string",
      enum: [
        "full-test-suite", "smoke-tests", "regression-tests",
        "security-assessment", "performance-validation", "quality-gate-check",
        "continuous-testing", "exploratory-testing", "chaos-testing"
      ],
      description: "Type of testing workflow to orchestrate"
    },
    target: {
      type: "string",
      description: "Target for testing (codebase, application, service, etc.)"
    },
    scope: {
      type: "object",
      properties: {
        components: { type: "array", items: { type: "string" } },
        test_levels: { type: "array", items: { type: "string" } },
        environments: { type: "array", items: { type: "string" } }
      },
      description: "Testing scope definition"
    },
    priority: {
      type: "string",
      enum: ["low", "medium", "high", "critical"],
      default: "medium",
      description: "Workflow execution priority"
    },
    strategy: {
      type: "string",
      enum: ["parallel", "sequential", "adaptive", "risk-based"],
      default: "adaptive",
      description: "Execution strategy"
    },
    quality_gates: {
      type: "object",
      properties: {
        coverage_threshold: { type: "number", minimum: 0, maximum: 100 },
        quality_score_threshold: { type: "number", minimum: 0, maximum: 100 },
        performance_threshold: { type: "object" },
        security_threshold: { type: "object" }
      },
      description: "Quality gate criteria"
    }
  },
  required: ["workflow", "target"]
}

Test Generation and Execution Tools

qe_test_generate

{
  name: "qe_test_generate",
  description: "Generate comprehensive test suites using AI-driven analysis",
  parameters: {
    type: {
      type: "string",
      enum: [
        "unit-tests", "integration-tests", "api-tests", "ui-tests",
        "performance-tests", "security-tests", "accessibility-tests",
        "contract-tests", "mutation-tests", "property-based-tests"
      ],
      description: "Type of tests to generate"
    },
    target: {
      type: "string",
      description: "Target code, API, or system for test generation"
    },
    framework: {
      type: "string",
      description: "Testing framework to use (jest, cypress, k6, etc.)"
    },
    coverage_requirements: {
      type: "object",
      properties: {
        line_coverage: { type: "number", minimum: 0, maximum: 100 },
        branch_coverage: { type: "number", minimum: 0, maximum: 100 },
        function_coverage: { type: "number", minimum: 0, maximum: 100 }
      },
      description: "Coverage requirements for generated tests"
    },
    generation_strategy: {
      type: "string",
      enum: ["comprehensive", "focused", "risk-based", "ai-optimized"],
      default: "ai-optimized",
      description: "Test generation strategy"
    },
    constraints: {
      type: "object",
      properties: {
        max_test_count: { type: "number" },
        execution_timeout: { type: "number" },
        resource_limits: { type: "object" }
      },
      description: "Generation constraints"
    }
  },
  required: ["type", "target"]
}

qe_test_execute

{
  name: "qe_test_execute",
  description: "Execute test suites with intelligent orchestration",
  parameters: {
    suite: {
      type: "string",
      description: "Test suite identifier or specification"
    },
    environment: {
      type: "object",
      properties: {
        name: { type: "string" },
        configuration: { type: "object" },
        resources: { type: "object" }
      },
      description: "Execution environment specification"
    },
    execution_config: {
      type: "object",
      properties: {
        parallel_execution: { type: "boolean", default: true },
        max_parallel_jobs: { type: "number", default: 4 },
        retry_failed_tests: { type: "boolean", default: true },
        timeout: { type: "number", default: 3600 }
      },
      description: "Execution configuration"
    },
    reporting: {
      type: "object",
      properties: {
        real_time_updates: { type: "boolean", default: true },
        detailed_logs: { type: "boolean", default: false },
        coverage_analysis: { type: "boolean", default: true },
        performance_metrics: { type: "boolean", default: true }
      },
      description: "Reporting configuration"
    }
  },
  required: ["suite"]
}

Quality Analysis Tools

qe_quality_analyze

{
  name: "qe_quality_analyze",
  description: "Perform comprehensive quality analysis using multiple dimensions",
  parameters: {
    scope: {
      type: "string",
      enum: ["codebase", "module", "service", "system", "deployment"],
      description: "Analysis scope"
    },
    analysis_types: {
      type: "array",
      items: {
        type: "string",
        enum: [
          "code-quality", "test-coverage", "security-vulnerability",
          "performance-analysis", "maintainability", "technical-debt",
          "reliability", "scalability", "usability"
        ]
      },
      description: "Types of quality analysis to perform"
    },
    depth: {
      type: "string",
      enum: ["surface", "standard", "deep", "comprehensive"],
      default: "standard",
      description: "Analysis depth level"
    },
    target: {
      type: "string",
      description: "Target for quality analysis"
    },
    benchmarks: {
      type: "object",
      properties: {
        industry_standards: { type: "array", items: { type: "string" } },
        internal_baselines: { type: "object" },
        competitive_analysis: { type: "boolean", default: false }
      },
      description: "Quality benchmarks and standards"
    }
  },
  required: ["scope", "target"]
}

qe_coverage_analyze

{
  name: "qe_coverage_analyze",
  description: "Perform multi-dimensional coverage analysis and optimization",
  parameters: {
    coverage_types: {
      type: "array",
      items: {
        type: "string",
        enum: [
          "line-coverage", "branch-coverage", "function-coverage",
          "statement-coverage", "condition-coverage", "path-coverage",
          "integration-coverage", "api-coverage", "ui-coverage",
          "mutation-coverage"
        ]
      },
      description: "Types of coverage to analyze"
    },
    target: {
      type: "string",
      description: "Target for coverage analysis"
    },
    optimization: {
      type: "object",
      properties: {
        identify_gaps: { type: "boolean", default: true },
        suggest_tests: { type: "boolean", default: true },
        remove_redundancy: { type: "boolean", default: true },
        prioritize_coverage: { type: "boolean", default: true }
      },
      description: "Coverage optimization options"
    },
    requirements: {
      type: "object",
      properties: {
        minimum_coverage: { type: "number", minimum: 0, maximum: 100 },
        critical_path_coverage: { type: "number", minimum: 0, maximum: 100 },
        regression_protection: { type: "boolean", default: true }
      },
      description: "Coverage requirements"
    }
  },
  required: ["target"]
}

Quality Intelligence Tools

qe_risk_assess

{
  name: "qe_risk_assess",
  description: "Perform intelligent risk assessment for quality and deployment",
  parameters: {
    scope: {
      type: "string",
      enum: ["code-changes", "deployment", "system", "integration"],
      description: "Risk assessment scope"
    },
    risk_categories: {
      type: "array",
      items: {
        type: "string",
        enum: [
          "functional", "performance", "security", "reliability",
          "maintainability", "usability", "scalability", "compliance"
        ]
      },
      description: "Categories of risk to assess"
    },
    target: {
      type: "string",
      description: "Target for risk assessment"
    },
    impact_analysis: {
      type: "object",
      properties: {
        business_impact: { type: "boolean", default: true },
        technical_impact: { type: "boolean", default: true },
        user_impact: { type: "boolean", default: true },
        operational_impact: { type: "boolean", default: true }
      },
      description: "Impact analysis configuration"
    },
    mitigation_strategy: {
      type: "object",
      properties: {
        suggest_mitigations: { type: "boolean", default: true },
        prioritize_risks: { type: "boolean", default: true },
        generate_action_plan: { type: "boolean", default: true }
      },
      description: "Risk mitigation strategy options"
    }
  },
  required: ["scope", "target"]
}

qe_pattern_learn

{
  name: "qe_pattern_learn",
  description: "Learn and adapt from quality patterns and test effectiveness",
  parameters: {
    data_sources: {
      type: "array",
      items: {
        type: "string",
        enum: [
          "test-results", "defect-reports", "code-changes",
          "performance-metrics", "user-feedback", "deployment-outcomes"
        ]
      },
      description: "Data sources for pattern learning"
    },
    pattern_types: {
      type: "array",
      items: {
        type: "string",
        enum: [
          "defect-patterns", "test-effectiveness-patterns",
          "quality-degradation-patterns", "performance-patterns",
          "failure-patterns", "success-patterns"
        ]
      },
      description: "Types of patterns to learn"
    },
    learning_scope: {
      type: "string",
      enum: ["project", "team", "organization", "cross-project"],
      default: "project",
      description: "Scope of pattern learning"
    },
    effectiveness_tracking: {
      type: "object",
      properties: {
        measure_impact: { type: "boolean", default: true },
        track_improvements: { type: "boolean", default: true },
        validate_predictions: { type: "boolean", default: true }
      },
      description: "Effectiveness tracking configuration"
    }
  },
  required: ["data_sources", "pattern_types"]
}

Advanced Testing Tools

qe_chaos_engineer

{
  name: "qe_chaos_engineer",
  description: "Perform controlled chaos engineering to test system resilience",
  parameters: {
    system_target: {
      type: "string",
      description: "Target system for chaos engineering"
    },
    chaos_types: {
      type: "array",
      items: {
        type: "string",
        enum: [
          "service-failure", "network-partition", "resource-exhaustion",
          "latency-injection", "error-injection", "dependency-failure"
        ]
      },
      description: "Types of chaos to introduce"
    },
    blast_radius: {
      type: "object",
      properties: {
        scope: { type: "string", enum: ["component", "service", "system"] },
        duration: { type: "number", description: "Duration in seconds" },
        intensity: { type: "string", enum: ["low", "medium", "high"] }
      },
      description: "Chaos blast radius configuration"
    },
    safety_measures: {
      type: "object",
      properties: {
        monitoring: { type: "boolean", default: true },
        automatic_rollback: { type: "boolean", default: true },
        circuit_breakers: { type: "boolean", default: true },
        alert_thresholds: { type: "object" }
      },
      description: "Safety measures during chaos engineering"
    },
    recovery_validation: {
      type: "object",
      properties: {
        validate_recovery: { type: "boolean", default: true },
        measure_recovery_time: { type: "boolean", default: true },
        assess_data_consistency: { type: "boolean", default: true }
      },
      description: "Recovery validation configuration"
    }
  },
  required: ["system_target", "chaos_types"]
}

qe_mutation_test

{
  name: "qe_mutation_test",
  description: "Perform mutation testing to validate test suite effectiveness",
  parameters: {
    target: {
      type: "string",
      description: "Target code for mutation testing"
    },
    mutation_strategies: {
      type: "array",
      items: {
        type: "string",
        enum: [
          "arithmetic-operator", "relational-operator", "conditional-operator",
          "logical-operator", "assignment-operator", "unary-operator",
          "statement-deletion", "constant-replacement"
        ]
      },
      description: "Mutation strategies to apply"
    },
    test_suite: {
      type: "string",
      description: "Test suite to validate against mutations"
    },
    analysis_config: {
      type: "object",
      properties: {
        mutation_score_threshold: { type: "number", minimum: 0, maximum: 100 },
        identify_weak_tests: { type: "boolean", default: true },
        suggest_improvements: { type: "boolean", default: true },
        generate_additional_tests: { type: "boolean", default: false }
      },
      description: "Mutation analysis configuration"
    }
  },
  required: ["target", "test_suite"]
}

Integration and Environment Tools

qe_environment_provision

{
  name: "qe_environment_provision",
  description: "Provision and manage testing environments",
  parameters: {
    environment_spec: {
      type: "object",
      properties: {
        name: { type: "string" },
        type: { type: "string", enum: ["development", "testing", "staging", "production-like"] },
        infrastructure: { type: "object" },
        services: { type: "array", items: { type: "object" } },
        data: { type: "object" }
      },
      description: "Environment specification"
    },
    provisioning_strategy: {
      type: "string",
      enum: ["on-demand", "persistent", "shared", "isolated"],
      default: "on-demand",
      description: "Environment provisioning strategy"
    },
    lifecycle_config: {
      type: "object",
      properties: {
        auto_start: { type: "boolean", default: true },
        auto_stop: { type: "boolean", default: true },
        cleanup_policy: { type: "string", enum: ["immediate", "scheduled", "manual"] },
        resource_limits: { type: "object" }
      },
      description: "Environment lifecycle configuration"
    }
  },
  required: ["environment_spec"]
}

qe_data_manage

{
  name: "qe_data_manage",
  description: "Manage test data lifecycle and consistency",
  parameters: {
    operation: {
      type: "string",
      enum: ["generate", "seed", "anonymize", "cleanup", "backup", "restore"],
      description: "Data management operation"
    },
    dataset_spec: {
      type: "object",
      properties: {
        type: { type: "string" },
        size: { type: "number" },
        constraints: { type: "object" },
        privacy_requirements: { type: "object" }
      },
      description: "Dataset specification"
    },
    data_sources: {
      type: "array",
      items: { type: "string" },
      description: "Source systems for test data"
    },
    privacy_compliance: {
      type: "object",
      properties: {
        anonymization: { type: "boolean", default: true },
        encryption: { type: "boolean", default: true },
        retention_policy: { type: "object" },
        audit_trail: { type: "boolean", default: true }
      },
      description: "Privacy and compliance configuration"
    }
  },
  required: ["operation"]
}

Monitoring and Reporting Tools

qe_fleet_status

{
  name: "qe_fleet_status",
  description: "Get comprehensive QE fleet status and health metrics",
  parameters: {
    detail_level: {
      type: "string",
      enum: ["summary", "detailed", "comprehensive"],
      default: "detailed",
      description: "Level of detail in status report"
    },
    include_metrics: {
      type: "object",
      properties: {
        performance: { type: "boolean", default: true },
        resource_utilization: { type: "boolean", default: true },
        quality_metrics: { type: "boolean", default: true },
        coordination_efficiency: { type: "boolean", default: true }
      },
      description: "Metrics to include in status"
    }
  }
}

qe_quality_dashboard

{
  name: "qe_quality_dashboard",
  description: "Generate comprehensive quality dashboard with real-time metrics",
  parameters: {
    dashboard_config: {
      type: "object",
      properties: {
        refresh_interval: { type: "number", default: 30 },
        metric_categories: { type: "array", items: { type: "string" } },
        visualization_types: { type: "array", items: { type: "string" } },
        alert_thresholds: { type: "object" }
      },
      description: "Dashboard configuration"
    },
    time_range: {
      type: "object",
      properties: {
        start: { type: "string", format: "date-time" },
        end: { type: "string", format: "date-time" },
        preset: { type: "string", enum: ["1h", "6h", "24h", "7d", "30d"] }
      },
      description: "Time range for dashboard data"
    }
  }
}

Tool Usage Patterns

Sequential Quality Workflow

// 1. Initialize QE fleet
qe_fleet_init({ topology: "hierarchical", qe_focus: "full-spectrum" })

// 2. Spawn specialized agents
qe_agent_spawn({ type: "unit-test-generator", specialization: "jest" })
qe_agent_spawn({ type: "security-test-agent", specialization: "owasp" })

// 3. Orchestrate comprehensive testing
qe_test_orchestrate({
  workflow: "full-test-suite",
  target: "application",
  quality_gates: { coverage_threshold: 80 }
})

// 4. Analyze results and learn patterns
qe_quality_analyze({ scope: "codebase", target: "application" })
qe_pattern_learn({ data_sources: ["test-results"], pattern_types: ["defect-patterns"] })

Continuous Testing Integration

// Real-time quality monitoring with adaptive response
qe_test_orchestrate({
  workflow: "continuous-testing",
  strategy: "adaptive",
  quality_gates: "dynamic-thresholds"
})

// Intelligent risk assessment for deployments
qe_risk_assess({
  scope: "deployment",
  risk_categories: ["functional", "performance", "security"],
  mitigation_strategy: { generate_action_plan: true }
})

This MCP tool specification provides the foundation for coordinating sophisticated quality engineering operations while maintaining clear separation between coordination (MCP tools) and execution (Claude Code Task tool).