Gemini MCP

Instructions

Implementation Reference

• src/tools/business-tools.js:146-245 (handler)

  The primary handler function implementing the tool's logic. It takes system details and scenarios, crafts detailed AI prompts for performance prediction and optimization recommendations, calls the AI client twice, and formats a comprehensive response.

      handler: async (args) => {
        const { system, load_scenarios = ['current', '2x', '10x'], metrics = ['response_time', 'throughput', 'resource_usage'], prediction_horizon = '12 months' } = args;
        validateString(system, 'system');
        
        const timer = performanceMonitor.startTimer('performance_predictor');
        
        const predictionPrompt = `Create AI-powered performance prediction model:
  
  **System**: ${system}
  **Load Scenarios**: ${load_scenarios.join(', ')}
  **Metrics**: ${metrics.join(', ')}
  **Prediction Horizon**: ${prediction_horizon}
  
  Analyze and predict:
  
  1. **Current Performance Baseline**
     - Current performance characteristics
     - Resource utilization patterns
     - Bottleneck identification
     - Scalability limits
  
  2. **Performance Predictions by Load**
     ${load_scenarios.map(scenario => `- **${scenario} Load**: Predicted performance metrics and breaking points`).join('\n   ')}
  
  3. **Capacity Planning**
     - Resource requirements for each scenario
     - Infrastructure scaling recommendations
     - Cost implications of scaling
     - Optimal scaling thresholds
  
  4. **Performance Optimization Roadmap**
     - Priority optimization opportunities
     - Expected performance gains
     - Implementation effort vs impact
     - Monitoring and alerting strategy
  
  5. **Predictive Modeling**
     - Performance degradation patterns
     - Early warning indicators
     - Automated scaling triggers
     - Capacity forecasting
  
  Provide specific numbers, thresholds, and actionable recommendations.`;
  
        const performancePrediction = await aiClient.call(predictionPrompt, 'analysis', { 
          complexity: 'complex',
          maxTokens: 4000 
        });
        
        // Generate optimization recommendations
        const optimizationPrompt = `Based on performance predictions, create optimization strategy:
  
  ${performancePrediction}
  
  Provide:
  1. **Immediate Optimizations** (0-3 months)
     - Quick wins with high impact
     - Low-effort improvements
     - Performance monitoring setup
  
  2. **Medium-term Improvements** (3-12 months)
     - Architectural optimizations
     - Technology upgrades
     - Process improvements
  
  3. **Long-term Strategic Changes** (12+ months)
     - Platform modernization
     - Scalability architecture
     - Future-proofing initiatives
  
  4. **Implementation Roadmap**
     - Prioritized action plan
     - Resource requirements
     - Success metrics
     - Risk mitigation
  
  Include cost-benefit analysis for each optimization.`;
  
        const optimizationStrategy = await aiClient.call(optimizationPrompt, 'analysis');
        
        timer.end();
        
        return `🚀 **Performance Prediction Model** (${prediction_horizon})
  
  **System**: ${system}
  **Load Scenarios**: ${load_scenarios.join(', ')}
  **Metrics**: ${metrics.join(', ')}
  
  ---
  
  📊 **Performance Predictions**
  
  ${performancePrediction}
  
  ---
  
  ⚡ **Optimization Strategy**
  
  ${optimizationStrategy}`;
      }

• src/tools/business-tools.js:140-144 (schema)

  Input schema defining the parameters for the performance predictor tool, including required system description and optional load scenarios, metrics, and prediction horizon.

  parameters: {
    system: { type: 'string', description: 'System or code to analyze', required: true },
    load_scenarios: { type: 'array', description: 'Load scenarios to predict', default: ['current', '2x', '10x'] },
    metrics: { type: 'array', description: 'Performance metrics to predict', default: ['response_time', 'throughput', 'resource_usage'] },
    prediction_horizon: { type: 'string', description: 'Prediction timeframe', default: '12 months' }

• src/tools/registry.js:244-248 (registration)

  Generic registration function used to register all tools from the businessTools module, including 'mcp__gemini__performance_predictor', by calling registerTool for each entry.

  registerToolsFromModule(toolsModule) {
    Object.entries(toolsModule).forEach(([name, tool]) => {
      this.registerTool(name, tool.description, tool.parameters, tool.handler);
    });
  }

• src/tools/registry.js:238-238 (registration)

  Specific call to register the businessTools module containing the 'mcp__gemini__performance_predictor' tool.

  this.registerToolsFromModule(businessTools);