ROI Measurement & Value Attribution

# Define ROICalculator; implement __init__, total_cost, total_value
# Key operations: results display, monitoring and metrics, deployment configuration
class ROICalculator:
 """Calculate ROI metrics for LLM deployment scenarios."""

 def __init__(self, model: LLMCostModel, months: int = 12):
 self.model = model
 self.months = months

 def total_cost(self) -> float:
 """Total cost over the time horizon."""
 return self.model.total_one_time_cost + (self.model.total_monthly_cost * self.months)

 def total_value(self) -> float:
 """Total value generated over the time horizon."""
 return self.model.total_monthly_value * self.months

 def net_benefit(self) -> float:
 """Net benefit = total value minus total cost."""
 return self.total_value() - self.total_cost()

 def roi_percentage(self) -> float:
 """ROI = (net benefit / total cost) * 100."""
 cost = self.total_cost()
 if cost == 0:
 return 0.0
 return (self.net_benefit() / cost) * 100

 def payback_months(self) -> Optional[float]:
 """Months until cumulative value exceeds cumulative cost."""
 # TODO: Calculate month-by-month cumulative costs and value.
 # The payback month is when cumulative value first exceeds cumulative cost.
 # Return None if payback never happens within 36 months.
 pass

 def npv(self, annual_discount_rate: float = 0.10) -> float:
 """Net Present Value with monthly discounting."""
 monthly_rate = annual_discount_rate / 12
 npv = -self.model.total_one_time_cost
 # TODO: For each month, compute the net cash flow
 # (monthly_value minus monthly_cost) and discount it.
 # NPV += net_cash_flow / (1 + monthly_rate) ** month
 pass

# Test with each scenario
for scenario in scenarios:
 calc = ROICalculator(scenario, months=12)
 print(f"\n{scenario.name} (12 months):")
 print(f" Total Cost: ${calc.total_{cost}():>12,.0f}")
 print(f" Total Value: ${calc.total_value():>12,.0f}")
 print(f" Net Benefit: ${calc.net_{benefit}():>12,.0f}")
 print(f" ROI: {calc.roi_{percentage}():>11.1f}%")
 print(f" Payback: {calc.payback_{months}()} months")
 print(f" NPV (10%): ${calc.npv():>12,.0f}")

# implement sensitivity_analysis
# Key operations: results display, cost tracking
def sensitivity_analysis(base_model: LLMCostModel, months: int = 12) -> dict:
 """Run sensitivity analysis on key variables."""
 variations = [0.5, 0.75, 1.0, 1.25, 1.5] # 50% to 150% of base value
 results = {}

 # Variables to test
 variables = {
 "api_cost_per_month": base_model.api_cost_per_month,
 "labor_savings_per_month": base_model.labor_savings_per_month,
 "development_cost": base_model.development_cost,
 }

 for var_name, base_value in variables.items():
 var_results = []
 for mult in variations:
 # TODO: Create a copy of the model with this variable modified
 # Calculate ROI at this variation
 # Store the multiplier and resulting ROI
 pass
 results[var_name] = var_results

 return results

# Run sensitivity for support AI (the most expensive scenario)
print(f"\n=== Sensitivity Analysis: {support_ai.name} ===\n")
sensitivity = sensitivity_analysis(support_ai)
for var_name, var_results in sensitivity.items():
 print(f" {var_name}:")
 for entry in var_results:
 bar = "#" * max(0, int(entry["roi"] / 10))
 print(f" {entry['multiplier']:.0%} of base -> ROI: {entry['roi']:>7.1f}% {bar}")
 print()

# implement multi_year_projection
# Key operations: results display, cost tracking
def multi_year_projection(model: LLMCostModel, years: int = 3,
 annual_usage_growth: float = 0.20,
 annual_cost_reduction: float = 0.15) -> dict:
 """Project costs and value over multiple years with growth assumptions."""
 projection = {"years": [], "cumulative_cost": [], "cumulative_value": [],
 "annual_roi": [], "cumulative_roi": []}

 cum_cost = model.total_one_time_cost
 cum_value = 0.0

 for year in range(1, years + 1):
 # TODO: Calculate annual costs and value for this year.
 # Apply usage_growth to value (compound annually).
 # Apply cost_reduction to API costs (providers get cheaper each year).
 # Track cumulative totals and per-year ROI.
 growth_mult = (1 + annual_usage_growth) ** (year - 1)
 cost_mult = (1 - annual_cost_reduction) ** (year - 1)

 annual_api = model.api_cost_per_month * 12 * cost_mult
 annual_other = (model.infrastructure_per_month + model.maintenance_per_month) * 12
 annual_cost = annual_api + annual_other
 annual_value = model.total_monthly_value * 12 * growth_mult

 cum_cost += annual_cost
 cum_value += annual_value

 projection["years"].append(year)
 projection["cumulative_cost"].append(cum_cost)
 projection["cumulative_value"].append(cum_value)
 year_roi = ((annual_value - annual_cost) / annual_cost * 100) if annual_cost > 0 else 0
 cum_roi = ((cum_value - cum_cost) / cum_cost * 100) if cum_cost > 0 else 0
 projection["annual_roi"].append(year_roi)
 projection["cumulative_roi"].append(cum_roi)

 return projection

# Run projections for all scenarios
print("=== 3-YEAR PROJECTIONS ===\n")
for scenario in scenarios:
 proj = multi_year_projection(scenario, years=3)
 print(f"{scenario.name}:")
 for i, year in enumerate(proj["years"]):
 print(f" Year {year}: Cost=${proj['cumulative_{cost}'][i]:>10,.0f} "
 f"Value=${proj['cumulative_value'][i]:>10,.0f} "
 f"Cum.ROI={proj['cumulative_roi'][i]:>6.1f}%")
 print()

# implement executive_report
# Key operations: cost tracking
def executive_report(scenarios: list, months: int = 12) -> str:
 """Generate an executive summary comparing all scenarios."""
 lines = ["=" * 70, "LLM INVESTMENT ROI COMPARISON REPORT", "=" * 70, ""]

 # Summary table
 lines.append(f"{'Scenario':<25} {'1yr Cost':>10} {'1yr Value':>10} {'ROI':>8} {'Payback':>10}")
 lines.append("-" * 70)

 best_roi = None
 fastest_payback = None

 for s in scenarios:
 calc = ROICalculator(s, months)
 roi = calc.roi_percentage()
 payback = calc.payback_months()
 payback_str = f"{payback:.1f} mo" if payback else "N/A"

 lines.append(f"{s.name:<25} ${calc.total_{cost}():>9,.0f} ${calc.total_value():>9,.0f} "
 f"{roi:>7.1f}% {payback_str:>10}")

 if best_roi is None or roi > best_roi[1]:
 best_roi = (s.name, roi)
 if payback and (fastest_payback is None or payback < fastest_payback[1]):
 fastest_payback = (s.name, payback)

 lines.append("")
 lines.append("KEY FINDINGS:")
 if best_roi:
 lines.append(f" Highest ROI: {best_roi[0]} at {best_roi[1]:.1f}%")
 if fastest_payback:
 lines.append(f" Fastest Payback: {fastest_payback[0]} at {fastest_payback[1]:.1f} months")

 # TODO: Add per-scenario sensitivity highlights
 # Identify the most impactful variable for each scenario

 lines.append("")
 lines.append("RECOMMENDATION:")
 lines.append(" Start with the fastest-payback scenario to demonstrate value,")
 lines.append(" then invest in higher-ROI scenarios using proven results.")
 lines.append("=" * 70)
 return "\n".join(lines)

print(executive_report(scenarios))