Update app.py

app.py

@@ -1,74 +1,267 @@
+# app.py
+import os
+import threading
+import tempfile
+import json
+import datetime
+from pathlib import Path
+import requests
+
 import gradio as gr
-from llama_index import (
-    SimpleDirectoryReader,
-    VectorStoreIndex,
-    ServiceContext,
-)
-from llama_index.embeddings.huggingface import HuggingFaceEmbedding
-from llama_index.llms import HuggingFacePipeline
-
-from transformers import pipeline
-
-# --- Configure HuggingFace pipeline ---
-hf_model_name = "google/flan-t5-small"  # small, fast text2text model
-pipe = pipeline("text2text-generation", model=hf_model_name)
-llm = HuggingFacePipeline(pipeline=pipe)
-
-# Embedding model
-embed_model = HuggingFaceEmbedding(model_name="sentence-transformers/all-mpnet-base-v2")
-
-service_context = ServiceContext.from_defaults(llm=llm, embed_model=embed_model)
-
-index = None
-
-# --- Functions ---
-def ingest_files(files):
-    global index
-    if not files:
-        return "No files uploaded."
-    
-    tmp_dir = "uploaded_data"
-    import os
-    os.makedirs(tmp_dir, exist_ok=True)
-    
-    for f in files:
-        dest = os.path.join(tmp_dir, f.name)
-        with open(dest, "wb") as out_f:
-            out_f.write(f.read())
-    
-    docs = SimpleDirectoryReader(tmp_dir).load_data()
-    index = VectorStoreIndex.from_documents(docs, service_context=service_context)
-    return f"Ingested {len(docs)} documents successfully."
-
-def answer_question(messages, user_message):
-    global index
-    if index is None:
-        return "No documents indexed yet. Upload files first."
-    
-    query_engine = index.as_query_engine()
-    resp = query_engine.query(user_message)
-    return resp.response
-
-# --- Gradio UI ---
-with gr.Blocks(title="HuggingFace LlamaIndex Chat") as demo:
-    gr.Markdown("<h2 style='text-align:center;color:#4A90E2;'>Upload + HuggingFace LlamaIndex Chatbot</h2>")
-    
+from fastapi import FastAPI, UploadFile, File
+from fastapi.responses import PlainTextResponse
+import uvicorn
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+
+# -----------------------
+# CONFIG
+# -----------------------
+REPORT_DIR = Path("./reports")
+REPORT_DIR.mkdir(exist_ok=True)
+
+# MCP ports
+FILE_SERVER_PORT = 8001
+EXECUTOR_PORT = 8002
+MEMORY_PORT = 8003
+
+# -----------------------
+# 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
+# -----------------------
+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()
+
+# -----------------------
+# LOG ANALYSIS & PLAN
+# -----------------------
+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)}
+
+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)
+    summary = f"Detected {len(parsed['errors'])} errors and {len(parsed['warnings'])} warnings"
+    issues = parsed["errors"][:10] + parsed["warnings"][:10]
+    suggestions = [
+        "Investigate top errors",
+        "Check system configuration",
+        "Add proper exception handling"
+    ]
+    plan_text = "\n".join([
+        "STEP 1: Review errors",
+        "STEP 2: Apply suggested fixes",
+        "STEP 3: Re-run analysis"
+    ])
+    return {"summary": summary, "issues": issues, "suggestions": suggestions, "plan_text": plan_text}
+
+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()}")
+    y = 700
+    c.drawString(40, y, "Summary:")
+    c.drawString(60, y-20, summary[:1000])
+    y -= 60
+    c.drawString(40, y, "Issues:")
+    for it in issues:
+        y -= 14
+        c.drawString(60, y, it[:120])
+        if y < 80:
+            c.showPage(); y = 740
+    y -= 20
+    c.drawString(40, y, "Suggestions:")
+    for s in suggestions:
+        y -= 14
+        c.drawString(60, y, f"- {s[:100]}")
+        if y < 80:
+            c.showPage(); y = 740
+    c.save()
+    return str(out)
+
+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 MCP - Log Analysis & Agent Planning")
     with gr.Row():
-        with gr.Column(scale=1):
-            file_input = gr.File(
-                file_types=[".txt", ".pdf", ".md", ".csv"],
-                file_count="multiple",
-                label="Upload files"
-            )
-            ingest_btn = gr.Button("Ingest / Index")
-            status = gr.Textbox(label="Status", interactive=False)
         with gr.Column(scale=2):
-            chatbot = gr.Chatbot(label="Chat with your docs", height=400)
-            user_input = gr.Textbox(label="Ask a question")
-            send_btn = gr.Button("Send")
-    
-    ingest_btn.click(ingest_files, inputs=file_input, outputs=status)
-    send_btn.click(answer_question, inputs=[chatbot, user_input], outputs=chatbot)
+            upload = gr.File(label="Upload log file")
+            files_list = gr.Dropdown(choices=[], label="Files on MCP 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)")
+
+    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):
+        if file_obj is None:
+            return refresh_files()
+        tmp = Path(tempfile.gettempdir()) / file_obj.name
+        with open(tmp, "wb") as f:
+            f.write(file_obj.read())
+        try:
+            upload_file_to_mcp(str(tmp), file_obj.name)
+        except Exception as e:
+            print("Upload error:", e)
+        return refresh_files()
+
+    upload.upload(fn=on_upload, inputs=upload, outputs=files_list)
+
+    def analyze_selected(fname):
+        if not fname:
+            return "Select file first", "", "", "", 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 "Select file first"
+        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
+# -----------------------
+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()
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(server_name="0.0.0.0", server_port=7860)
+