Docker file fix

README.md

@@ -160,7 +160,7 @@ This project was specifically designed for Gradio Agents & MCP Hackathon  featur
 - **Hyperbolic** - High-performance AI inference platform
 
 
-### 🎯 Hackathon Categories
+### 🎯 **System Features**
 
 - **🤖 AI/ML Innovation** - Novel use of agents for IT education
 - **🎨 Creative Tech** - Unique combination of technical analysis and storytelling

main.py

@@ -0,0 +1,161 @@
+# main.py
+import asyncio
+import uvicorn
+from threading import Thread
+import requests
+import logging
+from mcp_server import app as mcp_server
+#from gradio_app import start_gradio
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Function to run FastAPI
+async def run_mcp_server():
+    config = uvicorn.Config(app=mcp_server, host="0.0.0.0", port=8000)
+    server = uvicorn.Server(config)
+    logger.info("Starting mcp_server...")
+    await server.serve()
+
+import base64
+import os
+import gradio as gr
+from mcp import ClientSession, StdioServerParameters, types
+from mcp.client.stdio import stdio_client
+from smolagents import ToolCollection, CodeAgent, load_tool, tool, ToolCallingAgent, InferenceClientModel
+from smolagents.mcp_client import MCPClient
+from smolagents import TransformersModel
+from dotenv import load_dotenv
+import yaml
+import requests
+import json
+from PIL import Image
+from datetime import datetime
+from outage_odyssey_ui import GradioUI
+from io import BytesIO
+import time
+def run_outage_odyssey_app():
+    """Run the Outage Odyssey Gradio App."""
+    # Load environment variables
+    load_dotenv()
+    MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
+    ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+    CODEASTREAL_API_KEY = os.getenv("CODEASTREAL_API_KEY")
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+    HF_TOKEN = os.getenv("HF_TOKEN")
+    USE_CLOUD_MODEL = os.getenv("USE_CLOUD_MODEL", "true")
+    GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+    # Select model
+    if USE_CLOUD_MODEL == 'true':
+        from smolagents import LiteLLMModel
+        model = InferenceClientModel(
+            model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
+            provider="hf-inference",
+            api_key=HF_TOKEN,
+        )
+        model_description = "This agent uses MCP tools and LLM Models using LiteLLMModel via API."
+    else:
+        from transformers import pipeline
+        print("Loading local Qwen model...")
+        model = TransformersModel(
+            model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
+            device_map='auto',
+            max_new_tokens=8192,
+            trust_remote_code=True
+        )
+        model_description = "This agent uses MCP tools and a locally-run Qwen3-4B model."
+    
+    print(model_description)
+
+    # Define tool to convert PIL image to base64
+    @tool
+    def pil_to_base64(pil_image: Image.Image) -> str:
+        """Convert PIL image to base64."""
+        buffer = BytesIO()
+        pil_image.save(buffer, format="PNG")
+        img_str = base64.b64encode(buffer.getvalue()).decode()
+        return f"data:image/png;base64,{img_str}"
+
+    mcp_client = None
+    try:
+        # Connect to MCP Server
+        mcp_client = MCPClient({"url": "http://localhost:8000/sse"})
+        tools = mcp_client.get_tools()
+
+        tools_array = [{
+            "name": tool.name,
+            "description": tool.description,
+            "inputs": tool.inputs,
+            "output_type": tool.output_type,
+            "is_initialized": tool.is_initialized
+        } for tool in tools]
+
+        tool_names = [tool["name"] for tool in tools_array]
+        print(f"Connected to MCP server. Available tools: {', '.join(tool_names)}")
+
+        # Load prompt templates
+        with open("prompts.yml", 'r', encoding='utf-8') as stream:
+            prompt_templates = yaml.safe_load(stream)
+
+        # Create Agent
+        agent = CodeAgent(
+            tools=[pil_to_base64, *tools],
+            model=model,
+            prompt_templates=prompt_templates,
+            max_steps=10,
+            planning_interval=5,
+            additional_authorized_imports=[
+                'time', 'math', 'queue', 're', 'stat', 'collections', 'datetime', 'statistics',
+                'itertools', 'unicodedata', 'random', 'matplotlib.pyplot', 'open', 'pandas', 'numpy',
+                'json', 'yaml', 'plotly', 'pillow', 'PIL', 'base64', 'io'
+            ]
+        )
+
+        agent.name = "Outage Odyssey Agent"
+
+        # Launch Gradio UI
+        GradioUI(agent=agent).launch(share=True, mcp_server=True)
+
+    except Exception as e:
+        print(f"Error starting Gradio: {str(e)}")
+
+    finally:
+        if mcp_client is not None:
+            mcp_client.disconnect()
+            print("MCP client disconnected")
+
+# Example usage:
+# run_outage_odyssey_app()
+
+# Function to run Gradio after FastAPI is up
+def run_gradio_with_check():
+    max_attempts = 10
+    for attempt in range(max_attempts):
+        try:
+            response = requests.get("http://localhost:8000/")
+            if response.status_code == 200:
+                logger.info("FastAPI is up, starting Gradio...")
+                run_outage_odyssey_app()
+                return
+        except requests.ConnectionError:
+            logger.info(f"Waiting for FastAPI... Attempt {attempt + 1}/{max_attempts}")
+            time.sleep(1)
+    logger.error("Failed to start Gradio: FastAPI not ready")
+
+# Main function to control startup
+async def main():
+    # Start FastAPI
+    fastapi_task = asyncio.create_task(run_mcp_server())
+
+    # Start Gradio in a separate thread after FastAPI is confirmed running
+    gradio_thread = Thread(target=run_gradio_with_check)
+    gradio_thread.start()
+
+    # Wait for FastAPI task to complete
+    await fastapi_task
+
+
+if __name__ == "__main__":
+    asyncio.run(main())