From Insight to Action: Turning LLM-Built KPI Trees into Decision Engines

decision_prompt = """
You are an expert business analyst helping classify KPIs for a decision optimization system.

Context: We're building a decision engine for an e-commerce company.

KPI List:
1. On_Time_Delivery_Rate - percentage of orders delivered on promised date
2. Stockout_Rate - percentage of attempted purchases where item unavailable
3. Support_Tickets_per_Order - average number of customer service contacts
4. Order_Cycle_Time_Days - days from order placement to delivery
5. Customer_Satisfaction (CSAT) - overall satisfaction score (1-5)

For each KPI, determine:
- Variable Type: controllable, influenced, or outcome
- Controllability: direct, indirect, or none
- Business Levers: specific actions that can change this metric
- Dependencies: which other KPIs affect this one
- Time Lag: how long before changes take effect
- Cost to Improve: relative expense (low/medium/high)

Return structured JSON with detailed reasoning for each classification.
"""

from openai import OpenAI
client = OpenAI()

resp = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role":"user","content":decision_prompt}],
    response_format={"type": "json_object"}
)

import json
classification = json.loads(resp.choices[0].message.content)
print(json.dumps(classification, indent=2))

import numpy as np
import pandas as pd
from typing import Dict, Tuple

class KPISimulator:
    """
    Simulates the impact of operational changes on business KPIs
    using validated influence weights and dependency graphs.
    """
    
    def __init__(self, weights: Dict[str, float], baselines: Dict[str, float]):
        """
        Args:
            weights: Validated influence coefficients for each KPI on CSAT
            baselines: Current baseline values for each KPI
        """
        self.weights = weights
        self.baselines = baselines
        
        # Validated coefficients from Part 1's regression analysis
        self.influence = {
            "On_Time_Delivery_Rate":  0.65,   # Strong positive impact
            "Stockout_Rate":         -0.40,   # Moderate negative impact
            "Support_Tickets_per_Order": -0.55,  # Strong negative impact
            "Order_Cycle_Time_Days": -0.25    # Moderate negative impact
        }
        
        # Secondary effects: how KPIs influence each other
        self.cross_effects = {
            ("Stockout_Rate", "On_Time_Delivery_Rate"): -0.3,  # Stockouts hurt delivery
            ("On_Time_Delivery_Rate", "Support_Tickets_per_Order"): -0.2,  # Better delivery = fewer tickets
            ("Stockout_Rate", "Support_Tickets_per_Order"): 0.4   # Stockouts cause complaints
        }
    
    def simulate_csat(self, 
                     on_time_delta: float = 0, 
                     stockout_delta: float = 0,
                     tickets_delta: float = 0, 
                     cycle_delta: float = 0,
                     include_cross_effects: bool = True) -> Dict[str, float]:
        """
        Simulate CSAT change given operational improvements.
        
        Args:
            *_delta: Percentage point changes (e.g., 0.05 = +5%)
            include_cross_effects: Whether to model indirect effects
            
        Returns:
            Dict with predicted values and changes
        """
        base_csat = self.baselines.get("CSAT", 4.0)
        
        # Direct effects on CSAT
        direct_impact = (
            self.influence["On_Time_Delivery_Rate"] * on_time_delta +
            self.influence["Stockout_Rate"] * stockout_delta +
            self.influence["Support_Tickets_per_Order"] * tickets_delta +
            self.influence["Order_Cycle_Time_Days"] * cycle_delta
        )
        
        # Indirect effects (changes in one KPI affect others)
        indirect_impact = 0
        if include_cross_effects:
            # Stockouts reduce on-time delivery capability
            if stockout_delta != 0:
                induced_delivery_change = stockout_delta * self.cross_effects[("Stockout_Rate", "On_Time_Delivery_Rate")]
                indirect_impact += self.influence["On_Time_Delivery_Rate"] * induced_delivery_change
            
            # Better delivery reduces support load
            if on_time_delta != 0:
                induced_ticket_change = on_time_delta * self.cross_effects[("On_Time_Delivery_Rate", "Support_Tickets_per_Order")]
                indirect_impact += self.influence["Support_Tickets_per_Order"] * induced_ticket_change
        
        total_impact = direct_impact + indirect_impact
        predicted_csat = base_csat + total_impact
        
        # Calculate updated KPI values accounting for cross-effects
        updated_kpis = {
            "On_Time_Delivery_Rate": self.baselines["On_Time_Delivery_Rate"] + on_time_delta,
            "Stockout_Rate": self.baselines["Stockout_Rate"] + stockout_delta,
            "Support_Tickets_per_Order": self.baselines["Support_Tickets_per_Order"] + tickets_delta,
            "Order_Cycle_Time_Days": self.baselines["Order_Cycle_Time_Days"] + cycle_delta
        }
        
        if include_cross_effects:
            # Apply secondary effects
            updated_kpis["On_Time_Delivery_Rate"] += stockout_delta * self.cross_effects[("Stockout_Rate", "On_Time_Delivery_Rate")]
            updated_kpis["Support_Tickets_per_Order"] += (
                stockout_delta * self.cross_effects[("Stockout_Rate", "Support_Tickets_per_Order")] +
                on_time_delta * self.cross_effects[("On_Time_Delivery_Rate", "Support_Tickets_per_Order")]
            )
        
        return {
            "predicted_csat": round(predicted_csat, 3),
            "csat_change": round(total_impact, 3),
            "direct_impact": round(direct_impact, 3),
            "indirect_impact": round(indirect_impact, 3),
            "updated_kpis": {k: round(v, 3) for k, v in updated_kpis.items()}
        }
    
    def run_scenario_analysis(self, scenarios: Dict[str, Dict]) -> pd.DataFrame:
        """
        Run multiple scenarios and compare results.
        
        Args:
            scenarios: Dict of scenario_name -> {kpi_name: delta_value}
            
        Returns:
            DataFrame with comparative results
        """
        results = []
        
        for scenario_name, deltas in scenarios.items():
            result = self.simulate_csat(**deltas)
            results.append({
                "Scenario": scenario_name,
                "Predicted CSAT": result["predicted_csat"],
                "CSAT Change": result["csat_change"],
                "Direct Impact": result["direct_impact"],
                "Indirect Impact": result["indirect_impact"],
                **result["updated_kpis"]
            })
        
        return pd.DataFrame(results)

# Initialize simulator with current baselines
baselines = {
    "CSAT": 4.0,
    "On_Time_Delivery_Rate": 0.82,
    "Stockout_Rate": 0.12,
    "Support_Tickets_per_Order": 0.15,
    "Order_Cycle_Time_Days": 4.2
}

simulator = KPISimulator(weights={}, baselines=baselines)

# Define business scenarios to evaluate
scenarios = {
    "Status Quo": {
        "on_time_delta": 0,
        "stockout_delta": 0,
        "tickets_delta": 0,
        "cycle_delta": 0
    },
    "Logistics Focus": {
        "on_time_delta": 0.05,  # +5% on-time delivery
        "stockout_delta": -0.02,  # -2% stockouts
        "tickets_delta": 0,
        "cycle_delta": 0
    },
    "Support Automation": {
        "on_time_delta": 0.02,
        "stockout_delta": 0,
        "tickets_delta": -0.03,  # -3% tickets per order
        "cycle_delta": 0
    },
    "Balanced Approach": {
        "on_time_delta": 0.04,
        "stockout_delta": -0.02,
        "tickets_delta": -0.02,
        "cycle_delta": -0.3  # -0.3 days
    },
    "Aggressive Improvement": {
        "on_time_delta": 0.10,
        "stockout_delta": -0.05,
        "tickets_delta": -0.05,
        "cycle_delta": -0.5
    }
}

results_df = simulator.run_scenario_analysis(scenarios)
print(results_df.to_string(index=False))

# LLM generates executive summaries from simulation data
# Example prompt structure for narrative generation

prompt = """
Analyze these simulation scenarios and provide executive summary:
- Logistics Focus: CSAT +0.330 (cost: $260K)
- Support Automation: CSAT +0.007 (cost: $140K)  
- Balanced Approach: CSAT +0.401 (cost: $298K)
- Aggressive: CSAT +0.783 (cost: $580K)

Budget constraint: $300K
Recommend optimal path with timeline and resource needs.
"""

from scipy.optimize import minimize

# cost per 1% improvement for each KPI
cost = {
    "On_Time_Delivery_Rate":  80_000,
    "Stockout_Rate":          50_000,
    "Support_Tickets_per_Order": 60_000
}

budget = 300_000

def objective(x):
    on_time, stockout, tickets = x
    return -(simulate_csat(on_time, stockout, tickets) - 4.0)

def constraint(x):
    return budget - (
        abs(on_time)*cost["On_Time_Delivery_Rate"] +
        abs(stockout)*cost["Stockout_Rate"] +
        abs(tickets)*cost["Support_Tickets_per_Order"]
    )

cons = {"type":"ineq","fun":constraint}
x0 = [0,0,0]
res = minimize(objective, x0, constraints=cons)
res

opt_summary = f"""
Optimization results:
Improve On_Time_Delivery by 6%
Reduce Stockout_Rate by 3%
Reduce Support_Tickets_per_Order by 2%
Predicted CSAT +0.38
Write a 3-sentence action plan.
"""
print(client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role":"user","content":opt_summary}]
).choices[0].message.content)

from dowhy import CausalModel
model = CausalModel(
    data=df,
    treatment="on_time",
    outcome="csat",
    common_causes=["stockout_flag","support_tickets"]
)
identified_estimand = model.identify_effect()
causal_estimate = model.estimate_effect(
    identified_estimand,
    method_name="backdoor.propensity_score_matching"
)
print(causal_estimate)

cause_prompt = f"""
We found that improving On_Time_Delivery by 10% increases 
CSAT by {round(causal_estimate.value*10,2)}%.
Explain why this relationship is causal and what assumptions 
it depends on.
"""