Create app.py

app.py

@@ -0,0 +1,344 @@
+import os, json, logging, tempfile
+import gradio as gr
+import pandas as pd
+import numpy as np
+
+# quiet logs
+logging.getLogger("cmdstanpy").setLevel(logging.WARNING)
+logging.getLogger("prophet").setLevel(logging.WARNING)
+
+# -----------------------------
+# Auth: set OPENAI_API_KEY in HF/Colab secrets
+# -----------------------------
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
+if not OPENAI_API_KEY:
+    print("⚠️  OPENAI_API_KEY not set. Set a Space secret or env var. Tools will still run locally; the agent needs it.")
+
+# -----------------------------
+# Tools (your requested @tool style)
+# -----------------------------
+from smolagents import tool, CodeAgent, OpenAIServerModel
+
+@tool
+def forecast_tool(
+    horizon_months: int = 1,
+    use_demo: bool = True,
+    history_csv_path: str = ""
+) -> str:
+    """
+    Forecast monthly demand for finished goods using Prophet (demo-friendly).
+
+    Args:
+        horizon_months (int): Number of future months to forecast. Defaults to 1.
+        use_demo (bool): If True, generate synthetic history for two SKUs (FG100/FG200). Defaults to True.
+        history_csv_path (str): Optional path to CSV with columns [product_id,date,qty] to override demo.
+
+    Returns:
+        str: JSON string list of objects:
+             {"product_id": str, "period_start": "YYYY-MM-01", "forecast_qty": float}
+    """
+    from prophet import Prophet
+
+    # 1) Build history
+    if use_demo or not history_csv_path:
+        rng = pd.date_range("2023-01-01", periods=24, freq="MS")
+        rows = []
+        np.random.seed(0)
+        for pid, base in [("FG100", 1800), ("FG200", 900)]:
+            season = 1 + 0.15 * np.sin(2 * np.pi * (np.arange(len(rng)) / 12.0))
+            qty = (base * season).astype(float)
+            for d, q in zip(rng, qty):
+                rows.append({"product_id": pid, "date": d, "qty": float(q)})
+        df = pd.DataFrame(rows)
+    else:
+        df = pd.read_csv(history_csv_path)
+        assert {"product_id", "date", "qty"} <= set(df.columns), "Missing required columns: product_id,date,qty"
+        df["date"] = pd.to_datetime(df["date"], errors="coerce")
+        df = df.dropna(subset=["date"])
+        df["qty"] = pd.to_numeric(df["qty"], errors="coerce").fillna(0.0)
+
+    # 2) Forecast per product with Prophet
+    out = []
+    horizon_months = max(1, int(horizon_months))
+    for pid, g in df.groupby("product_id"):
+        s = (
+            g.set_index("date")["qty"]
+             .resample("MS").sum()
+             .asfreq("MS").fillna(0.0)
+        )
+        m = Prophet(yearly_seasonality=True, weekly_seasonality=False, daily_seasonality=False, n_changepoints=10)
+        m.fit(pd.DataFrame({"ds": s.index, "y": s.values}))
+        future = m.make_future_dataframe(periods=horizon_months, freq="MS", include_history=False)
+        pred = m.predict(future)[["ds", "yhat"]]
+        for _, r in pred.iterrows():
+            out.append({
+                "product_id": str(pid),
+                "period_start": r["ds"].strftime("%Y-%m-%d"),
+                "forecast_qty": float(r["yhat"])
+            })
+    return json.dumps(out)
+
+
+@tool
+def optimize_supply_tool(
+    forecast_json: str
+) -> str:
+    """
+    Optimize a single-month supply plan (demo LP) using forecasted demand.
+
+    Args:
+        forecast_json (str): JSON string returned by forecast_tool.
+
+    Returns:
+        str: JSON string with plan summary:
+             {
+               "status": "OPTIMAL",
+               "profit": float,
+               "products": [{"product_id": ..., "produce_qty": ..., "sell_qty": ...}],
+               "raw_materials": [{"rm_id": ..., "purchase_qty": ..., "consumption_qty": ...}],
+               "resources": [{"resource_id": "R1"/"R2", "used_hours": ..., "available_hours": ...}]
+             }
+    """
+    # Demo master data (same as earlier examples)
+    demand_rows = json.loads(forecast_json)
+    # Use first month per product
+    demand = {}
+    for row in demand_rows:
+        p = row["product_id"]
+        demand.setdefault(p, row)  # first occurrence only
+
+    P = sorted(demand.keys()) or ["FG100", "FG200"]  # default if empty
+    # Prices / conversion costs / resource usage
+    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}
+    # RM data + BOM eff usage
+    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.2 * 1.02},  # scrap on B
+        "FG200": {"RM_A": 1.0, "RM_B": 0.1},
+    }
+    r1_cap, r2_cap = 320.0, 480.0
+    start_inv = {p: 0.0 for p in P}      # keep the LP minimal
+    safety    = {p: 0.0 for p in P}
+
+    # Build LP: variables = produce[p], sell[p], purchase[r], end_inv_rm[r], end_inv[p]
+    from scipy.optimize import linprog
+    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
+
+    # objective: minimize (costs - revenue)
+    for p in P:
+        c[i_prod(p)] += conv[p]
+        c[i_sell(p)] -= price[p]
+        c[i_einv(p)] += 0.0
+        bounds[i_prod(p)] = (0, None)
+        bounds[i_sell(p)] = (0, float(demand[p]["forecast_qty"]))
+        bounds[i_einv(p)] = (safety[p], None)
+    for r in RMs:
+        c[i_pur(r)]  += rm_cost[r]
+        c[i_einr(r)] += 0.0
+        bounds[i_pur(r)]  = (0, rm_cap[r])
+        bounds[i_einr(r)] = (0, None)
+
+    # equalities
+    Aeq, beq = [], []
+    # FG balance: start + produce - sell - end_inv = 0
+    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(-start_inv[p])
+    # RM balance: start + purchase - sum(use*produce) - end_inv_rm = 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.get(p, {}).get(r, 0.0)
+        Aeq.append(row); beq.append(-rm_start[r])
+
+    Aeq, beq = np.array(Aeq), np.array(beq)
+
+    # inequalities (resources)
+    Aub, bub = [], []
+    row = np.zeros(n_vars)
+    for p in P: row[i_prod(p)] = r1[p]
+    Aub.append(row); bub.append(r1_cap)
+    row = np.zeros(n_vars)
+    for p in P: row[i_prod(p)] = r2[p]
+    Aub.append(row); bub.append(r2_cap)
+    Aub, bub = np.array(Aub), np.array(bub)
+
+    res = linprog(c, A_ub=Aub, b_ub=bub, A_eq=Aeq, b_eq=beq, bounds=bounds, method="highs")
+    if not res.success:
+        return json.dumps({"status": "FAILED", "message": res.message})
+
+    x = res.x
+    def v(idx): return float(x[idx])
+
+    # Build outputs
+    prod_rows = []
+    for p in P:
+        prod_rows.append({
+            "product_id": p,
+            "produce_qty": v(i_prod(p)),
+            "sell_qty": v(i_sell(p))
+        })
+    # resource usage
+    r1_used = float(sum(r1[p]*v(i_prod(p)) for p in P))
+    r2_used = float(sum(r2[p]*v(i_prod(p)) for p in P))
+    resources = [
+        {"resource_id": "R1", "used_hours": r1_used, "available_hours": r1_cap, "slack_hours": r1_cap - r1_used},
+        {"resource_id": "R2", "used_hours": r2_used, "available_hours": r2_cap, "slack_hours": r2_cap - r2_used},
+    ]
+    # raw material flows
+    raw_rows = []
+    rm_purch_cost = 0.0
+    for r in RMs:
+        purchase = v(i_pur(r))
+        cons = float(sum(bom.get(p, {}).get(r, 0.0)*v(i_prod(p)) for p in P))
+        rm_purch_cost += purchase*rm_cost[r]
+        raw_rows.append({
+            "rm_id": r, "purchase_qty": purchase, "consumption_qty": cons
+        })
+    revenue = float(sum(price[p]*v(i_sell(p)) for p in P))
+    conv_cost = float(sum(conv[p]*v(i_prod(p)) for p in P))
+    profit = revenue - conv_cost - rm_purch_cost
+
+    out = {
+        "status": "OPTIMAL",
+        "profit": profit,
+        "revenue": revenue,
+        "conversion_cost": conv_cost,
+        "rm_purchase_cost": rm_purch_cost,
+        "products": prod_rows,
+        "raw_materials": raw_rows,
+        "resources": resources
+    }
+    return json.dumps(out)
+
+
+@tool
+def update_sap_md61_tool(
+    forecast_json: str,
+    plant: str = "PLANT01",
+    uom: str = "EA",
+    mrp_area: str = ""
+) -> str:
+    """
+    Prepare an MD61-style demand upload (SIMULATION ONLY).
+
+    Args:
+        forecast_json (str): JSON string returned by forecast_tool.
+        plant (str): SAP plant (WERKS). Defaults to 'PLANT01'.
+        uom (str): Unit of measure to write. Defaults to 'EA'.
+        mrp_area (str): Optional MRP area.
+
+    Returns:
+        str: JSON string with {"status":"SIMULATED","csv_path": "...", "preview":[...5 rows...]}
+    """
+    rows = json.loads(forecast_json)
+    md61 = []
+    for r in rows:
+        md61.append({
+            "Material": r["product_id"],
+            "Plant": plant,
+            "MRP_Area": mrp_area,
+            "Req_Date": r["period_start"],  # month start; in practice, align to bucket conventions
+            "Req_Qty": float(r["forecast_qty"]),
+            "UoM": uom,
+            "Version": "00"  # demo default
+        })
+    df = pd.DataFrame(md61)
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".csv")
+    df.to_csv(tmp.name, index=False)
+    return json.dumps({
+        "status": "SIMULATED",
+        "csv_path": tmp.name,
+        "preview": df.head(5).to_dict(orient="records")
+    })
+
+# -----------------------------
+# Agent: runs forecast -> optimize -> MD61
+# -----------------------------
+def make_agent():
+    model = OpenAIServerModel(
+        model_id="gpt-4o-mini",
+        api_key=OPENAI_API_KEY,
+        temperature=0
+    )
+    tools = [forecast_tool, optimize_supply_tool, update_sap_md61_tool]
+    return CodeAgent(tools=tools, model=model, add_base_tools=False, stream_outputs=False)
+
+SYSTEM_PLAN = (
+    "Run the following pipeline strictly and return one final JSON object:\n"
+    "1) Call forecast_tool with the given arguments.\n"
+    "2) Call optimize_supply_tool using the JSON returned by forecast_tool.\n"
+    "3) Call update_sap_md61_tool using the JSON returned by forecast_tool (demand), "
+    "   not the optimization plan.\n"
+    "Return final_answer as JSON with keys: 'forecast', 'plan', and 'md61'."
+)
+
+def run_workflow(horizon, use_demo, plant, file_obj):
+    agent = make_agent()
+    if file_obj is not None:
+        history_path = file_obj.name
+        user_prompt = (
+            f"{SYSTEM_PLAN}\n"
+            f"Args:\n"
+            f"- forecast_tool: horizon_months={int(horizon)}, use_demo=False, history_csv_path='{history_path}'\n"
+            f"- optimize_supply_tool: (use forecast JSON)\n"
+            f"- update_sap_md61_tool: plant='{plant}', uom='EA'\n"
+            f"Return the final JSON only."
+        )
+    else:
+        user_prompt = (
+            f"{SYSTEM_PLAN}\n"
+            f"Args:\n"
+            f"- forecast_tool: horizon_months={int(horizon)}, use_demo=True\n"
+            f"- optimize_supply_tool: (use forecast JSON)\n"
+            f"- update_sap_md61_tool: plant='{plant}', uom='EA'\n"
+            f"Return the final JSON only."
+        )
+    try:
+        out = agent.run(user_prompt)
+    except Exception as e:
+        out = f"Agent error: {e}"
+    return out
+
+# -----------------------------
+# Gradio UI (simple and clean)
+# -----------------------------
+with gr.Blocks(title="Forecast → Optimize → SAP MD61 (Demo)") as demo:
+    gr.Markdown("## Forecast → Optimize → Update SAP MD61 (Demo)\nMinimal agent workflow with Prophet, LP, and an MD61 CSV preview.")
+    with gr.Row():
+        horizon = gr.Number(label="Horizon (months)", value=1, precision=0)
+        plant = gr.Textbox(label="SAP Plant (WERKS)", value="PLANT01")
+    with gr.Row():
+        use_demo = gr.Checkbox(label="Use demo synthetic history", value=True)
+        file = gr.File(label="Or upload history CSV (product_id,date,qty)", file_types=[".csv"])
+    run_btn = gr.Button("Run end-to-end")
+    out_box = gr.Textbox(label="Agent Output (JSON)", lines=14)
+
+    def on_run(h, p, demo_flag, f):
+        # if a file is supplied, ignore demo flag
+        return run_workflow(h, (f is None) and demo_flag, p, f)
+
+    run_btn.click(on_run, inputs=[horizon, plant, use_demo, file], outputs=[out_box])
+
+if __name__ == "__main__":
+    demo.launch()