Create app.py

app.py

@@ -0,0 +1,297 @@
+# agentops_space.py
+import os
+import threading
+import tempfile
+import json
+import datetime
+from pathlib import Path
+import requests
+
+# Gradio 6
+import gradio as gr
+
+# FastAPI + Uvicorn for internal MCP servers
+from fastapi import FastAPI, UploadFile, File
+from fastapi.responses import PlainTextResponse
+import uvicorn
+
+# PDF report
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+
+# -----------------------
+# ENV VARS / CONFIG
+# -----------------------
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "")
+REPORT_DIR = Path("./reports")
+REPORT_DIR.mkdir(exist_ok=True)
+
+# MCP ports (internal)
+FILE_SERVER_PORT = 8001
+EXECUTOR_PORT = 8002
+MEMORY_PORT = 8003
+RAG_PORT = 8004  # optional
+
+# -----------------------
+# MCP SERVERS
+# -----------------------
+
+# --- File Server ---
+file_app = FastAPI()
+FILE_STORAGE = Path("file_storage")
+FILE_STORAGE.mkdir(exist_ok=True)
+
+@file_app.post("/upload")
+async def upload_file(file: UploadFile = File(...)):
+    dest = FILE_STORAGE / file.filename
+    content = await file.read()
+    with open(dest, "wb") as f:
+        f.write(content)
+    return {"status":"ok","filename":file.filename,"path":str(dest)}
+
+@file_app.get("/list")
+def list_files():
+    return {"files": [p.name for p in FILE_STORAGE.iterdir() if p.is_file()]}
+
+@file_app.get("/read/{name}")
+def read_file(name: str):
+    fpath = FILE_STORAGE / name
+    if not fpath.exists():
+        return {"error":"not found"}
+    return {"filename": name, "content": fpath.read_text(encoding="utf-8")}
+
+# --- Executor Server ---
+executor_app = FastAPI()
+EXECUTOR_DB = Path("executor_db")
+EXECUTOR_DB.mkdir(exist_ok=True)
+
+@executor_app.post("/apply")
+def apply_patch(req: dict):
+    rec = {
+        "filename": req.get("filename"),
+        "action": req.get("action"),
+        "params": req.get("params", {}),
+        "timestamp": datetime.datetime.utcnow().isoformat()
+    }
+    fname = EXECUTOR_DB / f"{rec['filename']}.patchlog.json"
+    existing = []
+    if fname.exists():
+        existing = json.loads(fname.read_text())
+    existing.append(rec)
+    fname.write_text(json.dumps(existing, indent=2))
+    return {"status":"applied","record": rec}
+
+# --- Memory Server ---
+memory_app = FastAPI()
+MEMORY_DB = Path("memory_db")
+MEMORY_DB.mkdir(exist_ok=True)
+MEMORY_FILE = MEMORY_DB / "memory.json"
+if not MEMORY_FILE.exists():
+    MEMORY_FILE.write_text(json.dumps({}))
+
+@memory_app.post("/set")
+def set_memory(item: dict):
+    key = item.get("key")
+    value = item.get("value")
+    m = json.loads(MEMORY_FILE.read_text())
+    m[key] = value
+    MEMORY_FILE.write_text(json.dumps(m, indent=2))
+    return {"status":"ok","key":key}
+
+@memory_app.get("/get/{key}")
+def get_memory(key: str):
+    m = json.loads(MEMORY_FILE.read_text())
+    return {"value": m.get(key)}
+
+# -----------------------
+# HELPER FUNCTIONS
+# -----------------------
+
+# MCP calls
+def upload_file_to_mcp(filepath, filename):
+    url = f"http://localhost:{FILE_SERVER_PORT}/upload"
+    with open(filepath, "rb") as f:
+        files = {"file": (filename, f)}
+        r = requests.post(url, files=files, timeout=30)
+        r.raise_for_status()
+        return r.json()
+
+def list_mcp_files():
+    return requests.get(f"http://localhost:{FILE_SERVER_PORT}/list").json()
+
+def read_mcp_file(name):
+    return requests.get(f"http://localhost:{FILE_SERVER_PORT}/read/{name}").json()
+
+def apply_patch_mcp(filename, action, params=None):
+    payload = {"filename": filename, "action": action, "params": params or {}}
+    return requests.post(f"http://localhost:{EXECUTOR_PORT}/apply", json=payload).json()
+
+def memory_set(key, value):
+    return requests.post(f"http://localhost:{MEMORY_PORT}/set", json={"key":key,"value":value}).json()
+
+def memory_get(key):
+    return requests.get(f"http://localhost:{MEMORY_PORT}/get/{key}").json()
+
+# Gemini planner
+def call_gemini(prompt: str):
+    if GEMINI_API_KEY:
+        headers = {"Authorization": f"Bearer {GEMINI_API_KEY}", "Content-Type": "application/json"}
+        data = {"prompt": prompt, "max_tokens": 800}
+        try:
+            resp = requests.post("https://api.gemini.example/v1/generate", headers=headers, json=data, timeout=30)
+            resp.raise_for_status()
+            return resp.json().get("text") or resp.text
+        except Exception as e:
+            return f"Gemini API error: {e}"
+    else:
+        # fallback plan
+        return ("STEP 1: Extract ERROR/WARNING lines.\n"
+                "STEP 2: Prioritize issues.\n"
+                "STEP 3: Suggest fixes.\n"
+                "PLAN: 1) extract, 2) summarize, 3) recommend patches")
+
+# Parse logs
+def parse_log_text(txt):
+    lines = txt.splitlines()
+    errors = [l for l in lines if "ERROR" in l or "CRITICAL" in l or "FATAL" in l]
+    warnings = [l for l in lines if "WARNING" in l or "WARN" in l]
+    return {"errors": errors, "warnings": warnings, "total_lines": len(lines)}
+
+# Generate PDF report
+def generate_incident_report(filename, summary, issues, suggestions):
+    now = datetime.datetime.utcnow().isoformat().replace(":", "-")
+    out = REPORT_DIR / f"incident_{filename}_{now}.pdf"
+    c = canvas.Canvas(str(out), pagesize=letter)
+    c.setFont("Helvetica-Bold", 16)
+    c.drawString(40, 750, f"Incident Report - {filename}")
+    c.setFont("Helvetica", 10)
+    c.drawString(40, 730, f"Generated: {datetime.datetime.utcnow().isoformat()}")
+    c.drawString(40, 700, "Summary:")
+    c.drawString(60, 680, summary[:1000])
+    y = 640
+    c.drawString(40, y, "Issues:")
+    y -= 20
+    for it in issues[:20]:
+        c.drawString(60, y, it[:120])
+        y -= 14
+        if y < 80:
+            c.showPage(); y = 740
+    y -= 10
+    c.drawString(40, y, "Suggestions:")
+    y -= 20
+    for s in suggestions:
+        c.drawString(60, y, f"- {s[:100]}")
+        y -= 14
+        if y < 80:
+            c.showPage(); y = 740
+    c.save()
+    return str(out)
+
+def analyze_and_plan(filename):
+    r = read_mcp_file(filename)
+    if "error" in r:
+        return {"summary": "File not found", "issues": [], "suggestions": [], "plan_text": ""}
+    text = r.get("content","")
+    parsed = parse_log_text(text)
+    prompt = f"Analyze logs file {filename}. Provide summary, list issues, and 3 fix suggestions."
+    plan_text = call_gemini(prompt)
+    # fallback deterministic
+    if "STEP 1" in plan_text:
+        summary = "Detected errors and warnings; see issues."
+        issues = parsed["errors"][:10] + parsed["warnings"][:10]
+        suggestions = ["Increase DB timeout", "Add retry logic", "Investigate 500 errors"]
+    else:
+        summary = plan_text.split("\n")[0][:1000]
+        issues = parsed["errors"][:10]
+        suggestions = []
+        for line in plan_text.splitlines():
+            if "suggest" in line.lower() or "fix" in line.lower() or "recommend" in line.lower():
+                suggestions.append(line.strip())
+        if not suggestions:
+            suggestions = ["Investigate top errors", "Create incident ticket", "Add monitoring"]
+    return {"summary": summary, "issues": issues, "suggestions": suggestions, "plan_text": plan_text}
+
+def apply_fix_action(filename, action_key):
+    mapping = {
+        "increase_timeout": ("update_timeout", {"timeout": 60}),
+        "increase_retries": ("increase_retries", {"retries": 3}),
+        "mark_fixed": ("mark_fixed", {})
+    }
+    action, params = mapping.get(action_key, ("custom_action", {"note": action_key}))
+    res = apply_patch_mcp(filename, action, params)
+    memory_set(f"last_patch_{filename}", json.dumps(res))
+    return res
+
+# -----------------------
+# GRADIO UI
+# -----------------------
+with gr.Blocks() as demo:
+    gr.Markdown("## AgentOps Control Center — MCP in Action")
+    with gr.Row():
+        with gr.Column(scale=2):
+            upload = gr.File(label="Upload log file")
+            files_list = gr.Dropdown(choices=[], label="Files on MCP File Server", interactive=True)
+            btn_refresh = gr.Button("Refresh files")
+            btn_analyze = gr.Button("Analyze selected file")
+            apply_dropdown = gr.Dropdown(choices=["increase_timeout","increase_retries","mark_fixed"], label="Select fix action")
+            btn_apply = gr.Button("Apply fix")
+        with gr.Column(scale=3):
+            summary_box = gr.Textbox(label="Agent Summary", lines=6)
+            issues_box = gr.Textbox(label="Detected Issues", lines=10)
+            suggestions_box = gr.Textbox(label="Suggested Fixes", lines=6)
+            plan_box = gr.Textbox(label="Agent Plan / Reasoning", lines=6)
+            report_download = gr.File(label="Last Report (download)")
+
+    # Callbacks
+    def refresh_files():
+        resp = list_mcp_files()
+        return resp.get("files", [])
+
+    btn_refresh.click(fn=refresh_files, outputs=files_list)
+
+    def on_upload(file_obj):
+        tmp = Path(tempfile.gettempdir()) / file_obj.name
+        with open(tmp, "wb") as f:
+            f.write(file_obj.read())
+        upload_file_to_mcp(str(tmp), file_obj.name)
+        return refresh_files()
+    upload.upload(fn=on_upload, inputs=upload, outputs=files_list)
+
+    def analyze_selected(fname):
+        if not fname:
+            return {"summary_box": "Select file first", "issues_box":"", "suggestions_box":"", "plan_box":"", "report_download": None}
+        out = analyze_and_plan(fname)
+        report_path = generate_incident_report(fname, out["summary"], out["issues"], out["suggestions"])
+        return out["summary"], "\n".join(out["issues"]), "\n".join(out["suggestions"]), out["plan_text"], gr.File.update(value=report_path)
+
+    btn_analyze.click(fn=analyze_selected, inputs=[files_list], outputs=[summary_box, issues_box, suggestions_box, plan_box, report_download])
+
+    def apply_action(fname, action_key):
+        if not fname:
+            return {"error":"select file"}
+        res = apply_fix_action(fname, action_key)
+        return json.dumps(res, indent=2)
+
+    btn_apply.click(fn=apply_action, inputs=[files_list, apply_dropdown], outputs=[plan_box])
+
+# -----------------------
+# START MCP SERVERS IN THREADS
+# -----------------------
+def start_file_server():
+    uvicorn.run(file_app, host="0.0.0.0", port=FILE_SERVER_PORT, log_level="error")
+
+def start_executor_server():
+    uvicorn.run(executor_app, host="0.0.0.0", port=EXECUTOR_PORT, log_level="error")
+
+def start_memory_server():
+    uvicorn.run(memory_app, host="0.0.0.0", port=MEMORY_PORT, log_level="error")
+
+threading.Thread(target=start_file_server, daemon=True).start()
+threading.Thread(target=start_executor_server, daemon=True).start()
+threading.Thread(target=start_memory_server, daemon=True).start()
+
+# -----------------------
+# LAUNCH GRADIO
+# -----------------------
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)