Spewed some formatting code for database data retrieval; will have to wait for actual database entries to further test

api_monitor.py

@@ -391,7 +391,7 @@ def activate_monitoring(config_id, mcp_api_key):
         }
 
 
-def retrieve_monitored_data(config_id, mcp_api_key):
+def retrieve_monitored_data(config_id, mcp_api_key, mode="summary"):
     """
     TOOL: Retrieve monitored data for a specific API configuration.
 
@@ -400,11 +400,10 @@ def retrieve_monitored_data(config_id, mcp_api_key):
 
     PREREQUISITE: Must call validate_api_configuration() first and obtain a config_id from successful validation, then activate_monitoring() to start monitoring.
 
-    This function can be called at any time after monitoring activation to retrieve the latest data collected by the monitoring system.
-
-    Parameters:
+    This function can be called at any time after monitoring activation to retrieve the latest data collected by the monitoring system.    Parameters:
     - config_id: The ID of the API configuration to retrieve data for (required)
     - mcp_api_key: User's MCP API key for verification (must match validation step)
+    - mode: Data return mode - "summary" (LLM-optimized), "details" (full responses, minimal metadata), "full" (everything)
 
     Input Examples:
     1. Retrieve data for stock monitoring:
@@ -413,28 +412,71 @@ def retrieve_monitored_data(config_id, mcp_api_key):
 
     2. Retrieve data for weather alerts:
         config_id: 987654321
-        mcp_api_key: "your_mcp_key_here"
+        mcp_api_key: "your_mcp_key_here"    Returns:
+    - Dictionary with monitoring status in one of three formats based on mode parameter
 
-    Returns:
-    - Dictionary with success status, data, and message
-    - If no data found, returns success=False with appropriate message
-    Example return:
+    SUMMARY mode (LLM-optimized, default):
     {
         "success": True,
-        "data": [
-            {"timestamp": "2025-06-04T12:00:00Z", "response": {...}},
-            {"timestamp": "2025-06-04T12:20:00Z", "response": {...}},
+        "config_name": "Weather Alert Monitor",
+        "summary": {
+            "status": "active",  // "active", "inactive"
+            "health": "good",    // "good", "degraded", "no_data"
+            "calls_made": 15,
+            "success_rate": 93.3,
+            "last_call": "2025-06-05T15:20:00",
+            "last_success": "2025-06-05T15:20:00"
+        },
+        "recent_calls": [
+            {
+                "timestamp": "2025-06-05T15:20:00",
+                "success": true,
+                "error": null,
+                "response_preview": "{'alerts': [{'type': 'tornado'}]}..."  // truncated
+            }
+            // ... up to 5 most recent calls
         ],
-        "message": "Data retrieved successfully for config_id 123456789"
+        "full_data_available": 15,
+        "monitoring_details": {
+            "interval_minutes": 20,
+            "is_finished": false
+        }
     }
-    - If config_id not found or invalid, returns success=False with error message
-    - If mcp_api_key does not match, returns success=False with error message
 
-    Example error return:
+    DETAILS mode (full responses, minimal metadata):
+    {
+        "success": True,
+        "config_name": "Weather Alert Monitor",
+        "status": "active",
+        "calls_made": 15,
+        "success_rate": 93.3,
+        "recent_responses": [
+            {
+                "timestamp": "2025-06-05T15:20:00",
+                "success": true,
+                "response_data": {...},  // full response data
+                "error": null
+            }
+            // ... up to 10 most recent calls with full responses
+        ]
+    }
+
+    FULL mode (everything):
+    {
+        "success": True,
+        "config_name": "Weather Alert Monitor",
+        "config_description": "Monitor severe weather alerts",
+        "is_active": True,
+        "is_finished": False,
+        "progress": {...},
+        "schedule_info": {...},
+        "data": [...]  // all historical data
+    }
+
+    Error return format:
     {
         "success": False,
-        "message": "Invalid config_id or mcp_api_key",
-        "data": []
+        "message": "Invalid config_id or mcp_api_key"
     }
     ERROR HANDLING: If config_id not found or invalid, returns success=False with error message
     """
@@ -444,25 +486,200 @@ def retrieve_monitored_data(config_id, mcp_api_key):
         cur.execute(
             "SELECT * FROM api_configurations WHERE config_id = %s", (config_id,)
         )
-        config = cur.fetchone()
+        config_row = cur.fetchone()
 
-        if not config:
+        if not config_row:
             conn.close()
             return {
                 "success": False,
                 "message": "Invalid config_id",
                 "data": [],
             }
-        print(config)
-        # 2. Query the api_configurations table for the given config_id
-        # 3. If found, retrieve the associated monitored data
-        # 4. Return the data in the specified format
-        conn.close()
-        return {
-            "success": False,
-            "message": "Function not implemented yet; this is a placeholder.",
-            "data": [],
+
+        config = dict(config_row)
+        print(f"Retrieved config: {config}")
+
+        if config["mcp_api_key"] != mcp_api_key:
+            conn.close()
+            return {
+                "success": False,
+                "message": "Invalid mcp_api_key. You are not authorized to access this configuration.",
+                "data": [],
+            }
+
+        # Query the api_call_results table for monitored data
+        cur.execute(
+            "SELECT * FROM api_call_results WHERE config_id = %s ORDER BY called_at DESC",
+            (config_id,),
+        )
+        monitored_data_rows = cur.fetchall()
+
+        # Convert rows to dictionaries and format timestamps
+        monitored_data = []
+        for row in monitored_data_rows:
+            row_dict = dict(row)
+            # Format the timestamp for better readability
+            if row_dict.get("called_at"):
+                row_dict["called_at"] = row_dict["called_at"].isoformat()
+            monitored_data.append(row_dict)
+
+        # Check if monitoring is finished
+        now = datetime.now()
+        stop_time = config.get("time_to_start")
+        if stop_time and config.get("schedule_interval_minutes"):
+            # Calculate when monitoring should stop
+            stop_after_hours = (
+                config.get("schedule_interval_minutes", 24) / 60 * 24
+            )  # Default fallback
+            if hasattr(stop_time, "replace"):
+                stop_at = stop_time + timedelta(hours=stop_after_hours)
+            else:
+                stop_at = datetime.fromisoformat(str(stop_time)) + timedelta(
+                    hours=stop_after_hours
+                )
+            is_finished = now > stop_at or config.get("stop", False)
+        else:
+            is_finished = config.get("stop", False)
+
+        # Calculate progress statistics
+        total_expected_calls = 0
+        if config.get("time_to_start") and config.get("schedule_interval_minutes"):
+            start_time = config["time_to_start"]
+            if hasattr(start_time, "replace"):
+                start_dt = start_time
+            else:
+                start_dt = datetime.fromisoformat(str(start_time))
+
+            elapsed_minutes = (now - start_dt).total_seconds() / 60
+            if elapsed_minutes > 0:
+                total_expected_calls = max(
+                    1, int(elapsed_minutes / config["schedule_interval_minutes"])
+                )
+
+        # Get success/failure counts
+        successful_calls = len(
+            [d for d in monitored_data if d.get("is_successful", False)]
+        )
+        failed_calls = len(
+            [d for d in monitored_data if not d.get("is_successful", True)]
+        )
+        total_calls = len(
+            monitored_data
+        )  # Create simplified summary for LLM consumption
+        summary = {
+            "status": (
+                "active"
+                if config.get("is_active", False) and not is_finished
+                else "inactive"
+            ),
+            "health": (
+                "good"
+                if total_calls > 0 and (successful_calls / total_calls) > 0.8
+                else "degraded" if total_calls > 0 else "no_data"
+            ),
+            "calls_made": total_calls,
+            "success_rate": (
+                round(successful_calls / total_calls * 100, 1) if total_calls > 0 else 0
+            ),
+            "last_call": monitored_data[0]["called_at"] if monitored_data else None,
+            "last_success": next(
+                (d["called_at"] for d in monitored_data if d.get("is_successful")), None
+            ),
         }
+
+        # Handle different return modes
+        if mode == "full":
+            # Return complete detailed data (original detailed format)
+            return {
+                "success": True,
+                "message": f"Full data retrieved for config_id {config_id}",
+                "config_name": config.get("name", "Unknown"),
+                "config_description": config.get("description", ""),
+                "is_active": config.get("is_active", False),
+                "is_finished": is_finished,
+                "progress": {
+                    "total_calls": total_calls,
+                    "successful_calls": successful_calls,
+                    "failed_calls": failed_calls,
+                    "expected_calls": total_expected_calls,
+                    "success_rate": (
+                        round(successful_calls / total_calls * 100, 2)
+                        if total_calls > 0
+                        else 0
+                    ),
+                },
+                "schedule_info": {
+                    "interval_minutes": config.get("schedule_interval_minutes"),
+                    "started_at": (
+                        config.get("time_to_start").isoformat()
+                        if config.get("time_to_start")
+                        else None
+                    ),
+                    "is_stopped": config.get("stop", False),
+                },
+                "data": monitored_data,
+            }
+
+        elif mode == "details":
+            # Return full response data but minimal metadata (up to 10 recent calls)
+            recent_responses = []
+            for item in monitored_data[:10]:  # Last 10 calls with full responses
+                recent_responses.append(
+                    {
+                        "timestamp": item["called_at"],
+                        "success": item.get("is_successful", False),
+                        "response_data": item.get(
+                            "response_data"
+                        ),  # Full response data
+                        "error": (
+                            item.get("error_message")
+                            if not item.get("is_successful")
+                            else None
+                        ),
+                    }
+                )
+
+            return {
+                "success": True,
+                "config_name": config.get("name", "Unknown"),
+                "status": summary["status"],
+                "calls_made": total_calls,
+                "success_rate": summary["success_rate"],
+                "recent_responses": recent_responses,
+            }
+
+        else:  # mode == "summary" (default)
+            # Get recent data (last 5 calls) with essential info only
+            recent_data = []
+            for item in monitored_data[:5]:  # Only last 5 calls
+                recent_data.append(
+                    {
+                        "timestamp": item["called_at"],
+                        "success": item.get("is_successful", False),
+                        "error": (
+                            item.get("error_message")
+                            if not item.get("is_successful")
+                            else None
+                        ),
+                        "response_preview": (
+                            str(item.get("response_data", ""))[:100] + "..."
+                            if item.get("response_data")
+                            else None
+                        ),
+                    }
+                )
+
+            return {
+                "success": True,
+                "config_name": config.get("name", "Unknown"),
+                "summary": summary,
+                "recent_calls": recent_data,
+                "full_data_available": len(monitored_data),
+                "monitoring_details": {
+                    "interval_minutes": config.get("schedule_interval_minutes"),
+                    "is_finished": is_finished,
+                },
+            }
     except Exception as e:
         return {
             "success": False,
@@ -503,4 +720,4 @@ if __name__ == "__main__":
         config_id=activate_monitoring_response.get("config_id"),
         mcp_api_key="your_api_key",
     )
-    print(response)
+    print(json.dumps(response, indent=2, default=str))

main.py

@@ -1,6 +1,10 @@
 import gradio as gr
 from api_client import call_api
-from api_monitor import validate_api_configuration, activate_monitoring
+from api_monitor import (
+    validate_api_configuration,
+    activate_monitoring,
+    retrieve_monitored_data,
+)
 import json
 
 
@@ -125,10 +129,42 @@ scheduler_tab = gr.Interface(
     ],
 )
 
+# Retrieve Data Tab
+retrieve_tab = gr.Interface(
+    fn=retrieve_monitored_data,
+    inputs=[
+        gr.Number(label="Config ID", value=None),
+        gr.Textbox(
+            label="MCP API Key", placeholder="Enter your MCP API key", type="password"
+        ),
+        gr.Dropdown(
+            choices=["summary", "details", "full"],
+            label="Data Mode",
+            value="summary",
+            info="summary: LLM-optimized | details: full responses, minimal metadata | full: everything",
+        ),
+    ],
+    outputs=gr.JSON(label="Monitoring Progress & Data"),
+    title="Retrieve Monitoring Data",
+    description="STEP 3: Check the progress and retrieve data from your active monitoring configurations. Use the Config ID from the validation step. Three modes: 'summary' (LLM-optimized), 'details' (full responses), 'full' (complete debug info).",
+    flagging_mode="manual",
+    flagging_options=[
+        "Config Not Found",
+        "Invalid API Key",
+        "No Data Available",
+        "Other",
+    ],
+    examples=[
+        [123456789, "test_mcp_key_123", "summary"],
+        [987654321, "test_mcp_key_456", "details"],
+        [456789123, "test_mcp_key_789", "full"],
+    ],
+)
+
 # Create tabbed interface
 demo = gr.TabbedInterface(
-    [validation_tab, scheduler_tab],
-    ["Validate & Store", "Activate Scheduler"],
+    [validation_tab, scheduler_tab, retrieve_tab],
+    ["Validate & Store", "Activate Scheduler", "Retrieve Data"],
     title="MCP API Monitoring System",
 )