Optimizar precios

Instructions

Implementation Reference

• server.js:262-302 (registration)

  MCP tool registration for 'optimize_pricing', including schema, title, description, and thin handler that validates input and delegates to businessCalculator.optimizePricing

  server.registerTool(
    'optimize_pricing',
    {
      title: 'Optimizar precios',
      description: 'Sugiere optimizaciones de precios basado en competencia y ocupación usando datos reales',
      inputSchema: z.object({
        strategy: z.string().default('maximize_revenue'),
      }),
    },
    async ({ strategy = 'maximize_revenue' }) => {
      validator.log('info', `Iniciando optimización de precios con estrategia: ${strategy}`);
      
      try {
        // Validar parámetros de entrada
        const inputValidation = validator.validateUserInput({
          strategy
        }, {
          strategy: { required: true, type: 'string', enum: ['maximize_revenue', 'maximize_occupancy', 'balanced', 'competitive'] }
        });
  
        if (!inputValidation.valid) {
          return validator.generateInsufficientDataResponse(
            'estrategia de optimización',
            `Errores: ${inputValidation.errors.join(', ')}`
          );
        }
        
        const result = await businessCalculator.optimizePricing(strategy);
        
        validator.log('info', 'Optimización de precios completada exitosamente');
        return result;
        
      } catch (error) {
        validator.log('error', `Error crítico en optimización de precios: ${error.message}`);
        return validator.generateInsufficientDataResponse(
          'optimización de precios',
          'Error interno del sistema. Contacta al administrador.'
        );
      }
    }
  );

• server.js:267-270 (schema)

  Input schema using Zod: strategy string defaulting to 'maximize_revenue'

    inputSchema: z.object({
      strategy: z.string().default('maximize_revenue'),
    }),
  },

• src/business/calculator.js:1111-1149 (handler)

  Core handler logic in BusinessCalculator.optimizePricing: loads real data sources, computes pricing optimization based on strategy, formats response

  async optimizePricing(strategy) {
    validator.log('info', `Iniciando optimización de precios con estrategia: ${strategy}`);
    
    try {
      // Cargar datos reales necesarios
      const financialData = await dataLoader.loadFinancialData();
      const businessData = await dataLoader.loadBusinessStatus();
      const competitionData = await dataLoader.loadCompetitionData();
      
      // Validar que tenemos datos suficientes
      if (!financialData && !businessData) {
        return validator.generateInsufficientDataResponse(
          'datos para optimización de precios',
          'No se pudo acceder a los datos financieros ni de estado del negocio'
        );
      }
      
      const optimization = this.calculatePricingOptimization(
        strategy, 
        financialData, 
        businessData, 
        competitionData
      );
      
      return {
        content: [{
          type: 'text',
          text: this.formatPricingOptimization(optimization, strategy)
        }]
      };
      
    } catch (error) {
      validator.log('error', `Error en optimización de precios: ${error.message}`);
      return validator.generateInsufficientDataResponse(
        'optimización de precios',
        'Error interno en el análisis. Contacta al administrador.'
      );
    }
  }

• src/business/calculator.js:1151-1195 (helper)

  Helper that performs the pricing optimization calculation based on strategy and loaded data, populates recommendation structure

  calculatePricingOptimization(strategy, financialData, businessData, competitionData) {
    const currentOccupancy = financialData?.ocupacion_promedio || businessData?.occupancy || 0;
    const currentRevenue = financialData?.ingresos_total || 0;
    const averageRate = currentRevenue > 0 && financialData?.reservas_totales > 0 
      ? Math.round(currentRevenue / financialData.reservas_totales) 
      : 0;
    
    const optimization = {
      strategy,
      current_metrics: {
        occupancy: currentOccupancy,
        revenue: currentRevenue,
        average_rate: averageRate
      },
      recommendations: [],
      price_adjustments: [],
      expected_impact: {},
      implementation_steps: [],
      monitoring_kpis: []
    };
    
    // Análisis por estrategia
    switch (strategy) {
      case 'maximize_revenue':
        this.addRevenueMaximizationStrategy(optimization, currentOccupancy);
        break;
      case 'maximize_occupancy':
        this.addOccupancyMaximizationStrategy(optimization, currentOccupancy);
        break;
      case 'balanced':
        this.addBalancedStrategy(optimization, currentOccupancy);
        break;
      case 'competitive':
        this.addCompetitiveStrategy(optimization, competitionData);
        break;
      default:
        optimization.recommendations.push('Estrategia no reconocida, aplicando estrategia balanceada');
        this.addBalancedStrategy(optimization, currentOccupancy);
    }
    
    // Agregar consideraciones generales
    this.addGeneralPricingConsiderations(optimization);
    
    return optimization;
  }

• src/business/calculator.js:1275-1343 (helper)

  Helper to format the pricing optimization results into a structured text report for MCP response

  formatPricingOptimization(optimization, strategy) {
    const strategyNames = {
      maximize_revenue: 'Maximizar Ingresos',
      maximize_occupancy: 'Maximizar Ocupación', 
      balanced: 'Estrategia Balanceada',
      competitive: 'Estrategia Competitiva'
    };
    
    let report = `💰 **OPTIMIZACIÓN DE PRECIOS TREEPOD**\n\n`;
    report += `🎯 **Estrategia:** ${strategyNames[strategy] || strategy}\n\n`;
    
    // Métricas actuales
    report += `📊 **MÉTRICAS ACTUALES:**\n`;
    report += `• Ocupación: ${optimization.current_metrics.occupancy}%\n`;
    if (optimization.current_metrics.revenue > 0) {
      report += `• Ingresos: ${this.formatCurrency(optimization.current_metrics.revenue)}\n`;
    }
    if (optimization.current_metrics.average_rate > 0) {
      report += `• Tarifa promedio: ${this.formatCurrency(optimization.current_metrics.average_rate)}\n`;
    }
    report += `\n`;
    
    // Recomendaciones
    report += `🎯 **RECOMENDACIONES:**\n`;
    optimization.recommendations.forEach(rec => {
      report += `• ${rec}\n`;
    });
    report += `\n`;
    
    // Ajustes de precios
    if (optimization.price_adjustments.length > 0) {
      report += `💲 **AJUSTES SUGERIDOS:**\n`;
      optimization.price_adjustments.forEach(adj => {
        report += `• ${adj}\n`;
      });
      report += `\n`;
    }
    
    // Impacto esperado
    if (Object.keys(optimization.expected_impact).length > 0) {
      report += `📈 **IMPACTO ESPERADO:**\n`;
      if (optimization.expected_impact.revenue) {
        report += `• Ingresos: ${optimization.expected_impact.revenue}\n`;
      }
      if (optimization.expected_impact.occupancy) {
        report += `• Ocupación: ${optimization.expected_impact.occupancy}\n`;
      }
      report += `\n`;
    }
    
    // Pasos de implementación
    if (optimization.implementation_steps.length > 0) {
      report += `🔧 **IMPLEMENTACIÓN:**\n`;
      optimization.implementation_steps.forEach((step, index) => {
        report += `${index + 1}. ${step}\n`;
      });
      report += `\n`;
    }
    
    // KPIs de monitoreo
    if (optimization.monitoring_kpis.length > 0) {
      report += `📊 **KPIS A MONITOREAR:**\n`;
      optimization.monitoring_kpis.forEach(kpi => {
        report += `• ${kpi}\n`;
      });
    }
    
    return report;
  }