Update app.py

app.py

@@ -1,4 +1,3 @@
-# app.py
 import os
 import base64
 import json
@@ -7,51 +6,22 @@ from huggingface_hub import upload_file, InferenceClient
 from datetime import datetime
 import traceback
 from typing import Optional, Dict, Any
-
-from fastmcp import FastMCP
+import asyncio
+from fastmcp import Client
 
 # --- Configuration ---
 HF_DATASET_REPO = os.environ.get("HF_DATASET_REPO", "OppaAI/Robot_MCP")
 HF_VLM_MODEL = os.environ.get("HF_VLM_MODEL", "Qwen/Qwen2.5-VL-7B-Instruct")
-
-mcp = FastMCP("Robot_MCP")
-
-# -----------------------------------------------------
-# Register Robot Tools (MCP)
-# -----------------------------------------------------
-@mcp.tool()
-def speak(text: str, emotion: str = "neutral"):
-    """Makes the robot speak a given text with an emotion."""
-    return {"status": "success", "action_executed": "speak", "payload": {"text": text, "emotion": emotion}}
-
-@mcp.tool()
-def navigate(direction: str, distance_meters: float):
-    """Moves the robot a specified distance in a direction (max 5m)."""
-    if distance_meters > 5.0:
-        return {"status": "error", "message": "Safety limit exceeded"}
-    return {"status": "success", "action_executed": "navigate", "payload": {"direction": direction, "distance": distance_meters}}
-
-@mcp.tool()
-def scan_hazard(hazard_type: str, severity: str):
-    """Logs a potential hazard detected by the robot."""
-    timestamp = datetime.now().isoformat()
-    return {"status": "warning_logged", "log": f"[{timestamp}] HAZARD: {hazard_type} (Severity: {severity})"}
-
-@mcp.tool()
-def analyze_human(clothing_color: str, estimated_action: str):
-    """Tracks human activity based on visual input."""
-    return {"status": "human_tracked", "details": f"Human wearing {clothing_color} is {estimated_action}"}
+REMOTE_MCP_URL = os.environ.get("REMOTE_MCP_URL", "https://abidlabs-mcp-tools.hf.space/")
 
 # -----------------------------------------------------
 # Save and upload image to HF
 # -----------------------------------------------------
 def save_and_upload_image(image_b64: str, hf_token: str):
-    """Decodes a base64 image, saves it locally, and uploads to Hugging Face Hub."""
     try:
         image_bytes = base64.b64decode(image_b64)
         size_bytes = len(image_bytes)
 
-        # Ensure the /tmp directory exists
         os.makedirs("/tmp", exist_ok=True)
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
         local_path = f"/tmp/robot_img_{timestamp}.jpg"
@@ -61,7 +31,6 @@ def save_and_upload_image(image_b64: str, hf_token: str):
 
         filename = f"robot_{timestamp}.jpg"
 
-        # Corrected Hugging Face Hub upload
         from huggingface_hub import HfApi
         api = HfApi()
         api.upload_file(
@@ -84,7 +53,6 @@ def save_and_upload_image(image_b64: str, hf_token: str):
 # JSON parsing helper
 # -----------------------------------------------------
 def safe_parse_json_from_text(text: str) -> Optional[Dict[str, Any]]:
-    """Safely extract JSON from messy VLM output"""
     if not text:
         return None
     try:
@@ -104,25 +72,22 @@ def safe_parse_json_from_text(text: str) -> Optional[Dict[str, Any]]:
     return None
 
 # -----------------------------------------------------
-# Call MCP tool safely using public API
+# Call remote MCP tool asynchronously
 # -----------------------------------------------------
+async def call_remote_tool(tool_name: str, **kwargs):
+    async with Client(REMOTE_MCP_URL) as client:
+        result = await client.call_tool(tool_name, **kwargs)
+        return result
+
 def validate_and_call_tool(tool_name: str, tool_args: dict) -> Dict[str, Any]:
-    """Use public API instead of _tools"""
     try:
-        # FastMCP v2.11.2 provides call_tool
-        if hasattr(mcp, "call_tool"):
-            return mcp.call_tool(tool_name, tool_args)
-        # fallback: call the registered function directly
-        if hasattr(mcp, tool_name):
-            tool_fn = getattr(mcp, tool_name)
-            return tool_fn(**tool_args)
-        return {"error": f"Unknown tool '{tool_name}'"}
+        return asyncio.run(call_remote_tool(tool_name, **tool_args))
     except Exception as e:
         traceback.print_exc()
-        return {"error": f"Tool execution error: {str(e)}"}
+        return {"error": f"Remote tool execution error: {str(e)}"}
 
 # -----------------------------------------------------
-# Main pipeline: image → VLM → tool
+# Main pipeline: image → VLM → remote tool
 # -----------------------------------------------------
 def process_and_describe(payload: Dict[str, Any]) -> Dict[str, Any]:
     if isinstance(payload, str):
@@ -176,7 +141,7 @@ Respond in STRICT JSON ONLY:
     vlm_output = response.choices[0].message.content.strip()
     parsed = safe_parse_json_from_text(vlm_output)
     if parsed is None:
-        return {"status": "model_no_json", "robot_id": robot_id, "image_url": hf_url, "vlm_raw": vlm_output, "message": "VLM returned invalid JSON"}
+        return {"status": "model_no_json", "robot_id": robot_id, "vlm_raw": vlm_output, "message": "VLM returned invalid JSON"}
 
     tool_name = parsed.get("tool_name")
     tool_args = parsed.get("arguments") or {}
@@ -185,7 +150,6 @@ Respond in STRICT JSON ONLY:
     return {
         "status": "success",
         "robot_id": robot_id,
-        #"image_url": hf_url,
         "file_size_bytes": size_bytes,
         "vlm_description": parsed.get("description"),
         "chosen_tool": tool_name,
@@ -197,7 +161,7 @@ Respond in STRICT JSON ONLY:
 # ------------------------------
 # Gradio Interface
 # ------------------------------
-iface = gr.Interface(
+app = gr.Interface(
     fn=process_and_describe,
     inputs=gr.JSON(label="Input JSON Payload (must include hf_token & image_b64)"),
     outputs=gr.JSON(label="Output JSON Result"),
@@ -211,5 +175,6 @@ iface = gr.Interface(
 if __name__ == "__main__":
     print(f"[Config] HF_DATASET_REPO: {HF_DATASET_REPO}")
     print(f"[Config] HF_VLM_MODEL: {HF_VLM_MODEL}")
+    print(f"[Config] REMOTE_MCP_URL: {REMOTE_MCP_URL}")
     print("[Gradio] Launching interface...")
-    iface.launch(server_name="0.0.0.0", server_port=7860)
+    app.launch(server_name="0.0.0.0", server_port=7860)