Update app.py

app.py

@@ -1,3 +1,4 @@
+# app.py
 import os, json, tempfile, logging
 import gradio as gr
 import pandas as pd
@@ -146,6 +147,7 @@ def optimize_supply_tool(forecast_json: str) -> str:
     row = np.zeros(n_vars);  [row.__setitem__(i_prod(p), r1[p]) for p in P];  Aub.append(row); bub.append(r1_cap)
     row = np.zeros(n_vars);  [row.__setitem__(i_prod(p), r2[p]) for p in P];  Aub.append(row); bub.append(r2_cap)
 
+    from scipy.optimize import linprog
     res = linprog(c, A_ub=np.array(Aub), b_ub=np.array(bub), A_eq=np.array(Aeq), b_eq=np.array(beq),
                   bounds=bounds, method="highs")
     if not res.success:
@@ -268,7 +270,6 @@ def data_quality_guard_tool(use_demo: bool = True, history_csv_path: str = "", z
             if y == 0 and prev_nonzero and next_nonzero:
                 flag = flag or "ZERO_BETWEEN_NONZERO"
                 action = action or "impute_neighbor_avg"
-                # simple neighbor average
                 idx = s.index.get_loc(ts)
                 neighbors = []
                 if idx>0: neighbors.append(s.iloc[idx-1])
@@ -322,7 +323,6 @@ def scenario_explorer_tool(forecast_json: str) -> str:
     }
     r1_cap0, r2_cap0 = 320.0, 480.0
 
-    # Define scenarios
     scenarios = [
         {"name":"Base", "mult":1.0, "r1_cap":r1_cap0, "r2_cap":r2_cap0, "rm_cost_B_add":0.0, "conv_fg100_mult":1.0, "rmA_start_mult":1.0},
         {"name":"+10% Demand", "demand_mult":1.10, "r1_cap":r1_cap0, "r2_cap":r2_cap0, "rm_cost_B_add":0.0, "conv_fg100_mult":1.0, "rmA_start_mult":1.0},
@@ -372,6 +372,7 @@ def scenario_explorer_tool(forecast_json: str) -> str:
         row = np.zeros(n_vars); [row.__setitem__(i_prod(p), r1[p]) for p in P]; Aub.append(row); bub.append(r1_cap)
         row = np.zeros(n_vars); [row.__setitem__(i_prod(p), r2[p]) for p in P]; Aub.append(row); bub.append(r2_cap)
 
+        from scipy.optimize import linprog
         res = linprog(c, A_ub=np.array(Aub), b_ub=np.array(bub), A_eq=np.array(Aeq), b_eq=np.array(beq),
                       bounds=bounds, method="highs")
         if not res.success:
@@ -415,8 +416,7 @@ def plan_explainer_tool(plan_json: str) -> str:
     products = d.get("products", [])
     resources = d.get("resources", [])
 
-    # Simple insights
-    # 1) Top product by revenue contribution (price*Sell - conv*Produce) — using demo fields available
+    # Contribution by product
     contribs = []
     for row in products:
         rev = row["Sell"] * row["Unit Price"]
@@ -425,7 +425,7 @@ def plan_explainer_tool(plan_json: str) -> str:
     contribs.sort(key=lambda x: x[1], reverse=True)
     top_prod = contribs[0][0] if contribs else "N/A"
 
-    # 2) Binding resource (min slack)
+    # Binding resource (min slack)
     bind_res = None
     if resources:
         r_sorted = sorted(resources, key=lambda r: r.get("Slack", 0.0))
@@ -440,6 +440,158 @@ def plan_explainer_tool(plan_json: str) -> str:
 
     return json.dumps({"status":"OK","summary": summary})
 
+# ---------- NEW: Bottleneck Search (finite-difference + policy) ----------
+@tool
+def bottleneck_search_tool(forecast_json: str, policy_json: str = "") -> str:
+    """
+    Find the best practical lever to relax (within ~1 month) via small scenario probes.
+
+    Args:
+        forecast_json (str): JSON from forecast_tool (first month per SKU used).
+        policy_json (str): Optional JSON with relaxable levers and costs.
+                           Defaults include overtime and RM expedite; blocks factory expansion.
+
+    Returns:
+        str: JSON {"status":"OK","recommendations":[{lever, recommended, est_profit_lift, est_net_gain, rationale}]}
+    """
+    # --- Defaults (edit to your reality) ---
+    policy = {
+        "R1_overtime": {"type":"resource","target":"R1","step":10.0,"max_delta":80.0,"unit_cost":600.0},
+        "R2_overtime": {"type":"resource","target":"R2","step":10.0,"max_delta":40.0,"unit_cost":800.0},
+        "RM_A_expedite": {"type":"rm_expedite","target":"RM_A","step":200.0,"max_delta":1500.0,"unit_premium":8.0},
+        "RM_B_expedite": {"type":"rm_expedite","target":"RM_B","step":100.0,"max_delta":800.0,"unit_premium":12.0},
+        "Factory_expansion": {"type":"blocked","reason":"Not relaxable within 1 month"}
+    }
+    if policy_json:
+        try:
+            policy.update(json.loads(policy_json))
+        except Exception:
+            pass
+
+    # --- 1) Baseline solve ---
+    base_plan = json.loads(optimize_supply_tool(forecast_json))
+    if base_plan.get("status") != "OPTIMAL":
+        return json.dumps({"status":"FAILED","message":"Baseline plan not optimal."})
+    base_profit = float(base_plan["kpis"]["Profit"])
+
+    # --- 2) Helper to run a perturbed solve ---
+    def run_with(delta_map):
+        from scipy.optimize import linprog
+
+        rows = json.loads(forecast_json)
+        demand = {}
+        for r in rows:
+            p = r["product_id"]
+            if p not in demand:
+                demand[p] = float(r["forecast_qty"])
+        P = sorted(demand.keys()) or ["FG100","FG200"]
+        price = {"FG100":98.0,"FG200":120.0}
+        conv  = {"FG100":12.5,"FG200":15.0}
+        r1    = {"FG100":0.03,"FG200":0.05}
+        r2    = {"FG100":0.02,"FG200":0.01}
+        RMs = ["RM_A","RM_B"]
+        rm_cost = {"RM_A":20.0,"RM_B":30.0}
+        rm_start = {"RM_A":1000.0,"RM_B":100.0}
+        rm_cap   = {"RM_A":5000.0,"RM_B":5000.0}
+        bom = {"FG100":{"RM_A":0.8,"RM_B":0.204},"FG200":{"RM_A":1.0,"RM_B":0.1}}
+
+        # Apply deltas
+        r1_cap = 320.0 + delta_map.get("R1_cap",0.0)
+        r2_cap = 480.0 + delta_map.get("R2_cap",0.0)
+        rm_cap_adj = {
+            "RM_A": rm_cap["RM_A"] + delta_map.get("RM_A_cap",0.0),
+            "RM_B": rm_cap["RM_B"] + delta_map.get("RM_B_cap",0.0),
+        }
+
+        nP, nR = len(P), len(RMs)
+        pidx = {p:i for i,p in enumerate(P)}; ridx = {r:i for i,r in enumerate(RMs)}
+        def i_prod(p): return pidx[p]
+        def i_sell(p): return nP + pidx[p]
+        def i_einv(p): return 2*nP + pidx[p]
+        def i_pur(r):  return 3*nP + ridx[r]
+        def i_einr(r): return 3*nP + nR + ridx[r]
+        n_vars = 3*nP + 2*nR
+        c = np.zeros(n_vars); bounds=[None]*n_vars
+
+        for p in P:
+            c[i_prod(p)] += conv[p]
+            c[i_sell(p)] -= price[p]
+            bounds[i_prod(p)] = (0,None)
+            bounds[i_sell(p)] = (0,demand[p])
+            bounds[i_einv(p)] = (0,None)
+        for r in RMs:
+            c[i_pur(r)]  += rm_cost[r]
+            bounds[i_pur(r)]  = (0, rm_cap_adj[r])
+            bounds[i_einr(r)] = (0,None)
+
+        Aeq, beq = [], []
+        for p in P:
+            row = np.zeros(n_vars); row[i_prod(p)]=1; row[i_sell(p)]=-1; row[i_einv(p)]=-1
+            Aeq.append(row); beq.append(0.0)
+        for r in RMs:
+            row = np.zeros(n_vars); row[i_pur(r)]=1; row[i_einr(r)]=-1
+            for p in P: row[i_prod(p)] -= bom[p].get(r,0.0)
+            Aeq.append(row); beq.append(-rm_start[r])
+
+        Aub, bub = [], []
+        row = np.zeros(n_vars); [row.__setitem__(i_prod(p), r1[p]) for p in P]; Aub.append(row); bub.append(r1_cap)
+        row = np.zeros(n_vars); [row.__setitem__(i_prod(p), r2[p]) for p in P]; Aub.append(row); bub.append(r2_cap)
+
+        res = linprog(c, A_ub=np.array(Aub), b_ub=np.array(bub), A_eq=np.array(Aeq), b_eq=np.array(beq),
+                      bounds=bounds, method="highs")
+        if not res.success:
+            return None
+        x = res.x
+        def v(idx): return float(x[idx])
+        revenue = sum(price[p]*v(i_sell(p)) for p in P)
+        conv_cost = sum(conv[p]*v(i_prod(p)) for p in P)
+        rm_purch_cost = sum(v(i_pur(r))*rm_cost[r] for r in RMs)
+        profit = revenue - conv_cost - rm_purch_cost
+        return profit
+
+    # --- 3) Probe levers; compute net gain ---
+    recs = []
+    for name, cfg in policy.items():
+        if cfg.get("type") == "blocked":
+            recs.append({"lever":name,"recommended":0,"est_profit_lift":0,"est_net_gain":0,
+                         "rationale":cfg.get("reason","Not feasible in horizon")})
+            continue
+        step = float(cfg["step"]); maxd = float(cfg["max_delta"])
+        best_gain = 0.0; best_delta = 0.0; best_profit_lift = 0.0
+        d = 0.0
+        while d <= maxd + 1e-6:
+            delta_map = {}
+            relax_cost = 0.0
+            if cfg["type"] == "resource" and cfg["target"]=="R1":
+                delta_map["R1_cap"] = d; relax_cost = d * float(cfg["unit_cost"])
+            elif cfg["type"] == "resource" and cfg["target"]=="R2":
+                delta_map["R2_cap"] = d; relax_cost = d * float(cfg["unit_cost"])
+            elif cfg["type"] == "rm_expedite":
+                key = "RM_A_cap" if cfg["target"]=="RM_A" else "RM_B_cap"
+                delta_map[key] = d; relax_cost = d * float(cfg["unit_premium"])
+            else:
+                d += step; continue
+
+            prof = run_with(delta_map)
+            if prof is None:
+                d += step; continue
+            lift = prof - base_profit
+            net = lift - relax_cost
+            if net > best_gain:
+                best_gain, best_delta, best_profit_lift = net, d, lift
+            d += step
+
+        rationale = ("Beneficial at small Δ" if best_gain>0 else "No positive net gain within feasible range")
+        recs.append({"lever":name,"recommended":best_delta,"est_profit_lift":best_profit_lift,
+                     "est_net_gain":best_gain,"rationale":rationale})
+
+    recs.sort(key=lambda r: r["est_net_gain"], reverse=True)
+    for r in recs:
+        for k in ["recommended","est_profit_lift","est_net_gain"]:
+            if r[k] is not None:
+                r[k] = round(float(r[k]), 2)
+    return json.dumps({"status":"OK","recommendations":recs})
+
 # ==== Agent (end-to-end) ======================================================
 def make_agent():
     api_key = os.environ.get("OPENAI_API_KEY", "")
@@ -448,7 +600,7 @@ def make_agent():
     model = OpenAIServerModel(model_id="gpt-4o-mini", api_key=api_key, temperature=0)
     return CodeAgent(tools=[
         forecast_tool, optimize_supply_tool, update_sap_md61_tool,
-        data_quality_guard_tool, scenario_explorer_tool, plan_explainer_tool
+        data_quality_guard_tool, scenario_explorer_tool, plan_explainer_tool, bottleneck_search_tool
     ], model=model, add_base_tools=False, stream_outputs=False)
 
 SYSTEM_PLAN = (
@@ -511,6 +663,16 @@ def parse_scenarios(json_str):
                                 "r1_used":"R1 Used","r1_slack":"R1 Slack","r2_used":"R2 Used","r2_slack":"R2 Slack"})
     return df
 
+def parse_recs(json_str):
+    d = json.loads(json_str)
+    df = _round_df(pd.DataFrame(d.get("recommendations", [])))
+    if not df.empty:
+        df = df.rename(columns={
+            "lever":"Lever","recommended":"Recommended Δ","est_profit_lift":"Est. Profit Lift",
+            "est_net_gain":"Est. Net Gain","rationale":"Rationale"
+        })
+    return df
+
 # ==== Gradio UI ==============================================================
 with gr.Blocks(title="Forecast → Optimize → SAP MD61") as demo:
     gr.Markdown("## 🧭 Workflow\n"
@@ -628,7 +790,7 @@ with gr.Blocks(title="Forecast → Optimize → SAP MD61") as demo:
         run_all.click(do_agent, inputs=[a_horizon, a_plant, a_demo, a_file],
                       outputs=[out_json, a_forecast_tbl, a_plan_kpis, a_plan_prod, a_plan_raw, a_plan_res, a_md61_prev, a_md61_file])
 
-    # --------- New Tab: Upgrades ---------
+    # --------- Upgrades ---------
     with gr.Tab("Upgrades"):
         gr.Markdown("### 🧹 Data Quality Guard")
         with gr.Row():
@@ -670,6 +832,22 @@ with gr.Blocks(title="Forecast → Optimize → SAP MD61") as demo:
 
         run_ex.click(do_explain, inputs=[plan_state], outputs=[expl_md])
 
+        gr.Markdown("### 🎯 Bottleneck Finder (Practical Levers)")
+        policy_box = gr.Textbox(
+            label="Optional policy JSON (overtime/expedite limits & costs). Leave blank for sensible defaults.",
+            lines=4, value=""
+        )
+        run_bn = gr.Button("Find Best Bottleneck (uses current Forecast)")
+        bn_tbl = gr.Dataframe(label="Ranked Recommendations", interactive=False)
+
+        def do_bn(fj, policy):
+            if not fj:
+                return pd.DataFrame()
+            out = bottleneck_search_tool(fj, policy_json=policy or "")
+            return parse_recs(out)
+
+        run_bn.click(do_bn, inputs=[forecast_state, policy_box], outputs=[bn_tbl])
+
 if __name__ == "__main__":
     # Needs OPENAI_API_KEY in env for agent tab; manual tabs work without it.
     if not os.environ.get("OPENAI_API_KEY"):