Update with enhanced AI Research Assistant - streaming output, 8192 tokens, improved UI

README.md

@@ -1,10 +1,4 @@
 ---
-license: apache-2.0
-title: AI Research Assistant
-sdk: gradio
----
-# README.md
----
 title: AI Research Assistant
 sdk: gradio
 sdk_version: 4.38.1
@@ -12,61 +6,128 @@ app_file: app.py
 license: apache-2.0
 ---
 
-# AI Research Assistant
+# 🧠 AI Research Assistant
+
+An advanced AI-powered research assistant that combines web search capabilities with contextual awareness to provide comprehensive answers to complex questions.
+
+## 🌟 Key Features
+
+- **Real-time Streaming Output**: See responses as they're generated for immediate feedback
+- **Contextual Awareness**: Incorporates current weather and space weather data
+- **Web Search Integration**: Powered by Tavily API for up-to-date information
+- **Smart Caching**: Redis-based caching for faster repeated queries
+- **Intelligent Server Monitoring**: Clear guidance during model warm-up periods
+- **Accurate Citations**: Real sources extracted from search results
+- **Asynchronous Processing**: Parallel execution for optimal performance
+- **Responsive Interface**: Modern Gradio UI with example queries
+
+## 🏗️ Architecture
 
-An AI-powered research assistant that gathers and analyzes information with web search, weather, and space weather context.
+The application follows a modular architecture for maintainability and scalability:
+myspace134v/
+├── app.py # Main Gradio interface
+├── modules/
+│ ├── analyzer.py # LLM interaction with streaming
+│ ├── citation.py # Citation generation and formatting
+│ ├── context_enhancer.py # Weather and space context (async)
+│ ├── formatter.py # Response formatting
+│ ├── input_handler.py # Input validation
+│ ├── retriever.py # Web search with Tavily
+│ ├── server_cache.py # Redis caching
+│ ├── server_monitor.py # Server health monitoring
+│ ├── status_logger.py # Event logging
+│ ├── visualizer.py # Output rendering
+│ └── visualize_uptime.py # System uptime monitoring
+├── tests/ # Unit tests
+├── requirements.txt # Dependencies
+└── version.json # Version tracking
 
-## Features
 
-- Web search integration with Tavily API
-- Context enrichment with weather and space weather data
-- LLM analysis using Hugging Face Inference Endpoint
-- Redis caching for improved performance
-- Citation generation for sources
-- Responsive Gradio interface
 
-## Architecture
+## 🤖 AI Model Information
 
-The application follows a modular architecture:
+This assistant uses the **DavidAU/OpenAi-GPT-oss-20b-abliterated-uncensored-NEO-Imatrix-gguf** model hosted on Hugging Face Endpoints. This is a powerful open-source language model with:
 
-- `app.py`: Main Gradio interface
-- `modules/analyzer.py`: Interacts with Hugging Face Inference Endpoint
-- `modules/citation.py`: Manages source tracking and formatting
-- `modules/context_enhancer.py`: Adds weather, space weather, and time context
-- `modules/formatter.py`: Structures and formats final output
-- `modules/input_handler.py`: Validates and prepares user input
-- `modules/retriever.py`: Uses Tavily API for web search
-- `modules/server_cache.py`: Uses Redis for caching frequent queries
-- `modules/status_logger.py`: Logs system status and performance
-- `modules/visualizer.py`: Renders output in a user-friendly format
-- `modules/visualize_uptime.py`: Monitors system uptime
+- **20 Billion Parameters**: Capable of handling complex reasoning tasks
+- **Extended Context Window**: Supports up to 8192 tokens per response
+- **Uncensored Capabilities**: Provides comprehensive answers without artificial limitations
+- **Specialized Training**: Optimized for research and analytical tasks
 
-## API Integrations
+## 🔧 API Integrations
 
-- **Tavily**: Web search capabilities
-- **Hugging Face Inference Endpoint**: LLM processing
-- **Redis**: Caching layer
-- **NASA**: Space weather and astronomical data
-- **OpenWeatherMap**: Current weather data
+| Service | Purpose | Usage |
+|---------|---------|-------|
+| **Tavily** | Web Search | Real-time information retrieval |
+| **Hugging Face Inference** | LLM Processing | Natural language understanding |
+| **Redis** | Caching | Performance optimization |
+| **NASA** | Space Data | Astronomical context |
+| **OpenWeatherMap** | Weather Data | Environmental context |
 
-## Setup Instructions
+## ⚡ Enhanced Features
 
+### 🔁 Streaming Output
+Responses stream in real-time, allowing users to start reading before the complete answer is generated. This creates a more natural conversational experience.
+
+### 📚 Dynamic Citations
+All information is properly sourced with clickable links to original content, ensuring transparency and enabling further exploration.
+
+### ⚡ Asynchronous Operations
+Weather data, space weather, and web searches run in parallel, significantly reducing response times.
+
+### 🧠 Contextual Intelligence
+Each query is enhanced with:
+- Current weather conditions
+- Recent space events
+- Accurate timestamps
+
+### 🛡️ Server State Management
+Intelligent monitoring detects when the model server is initializing and provides clear user guidance with estimated wait times.
+
+## 🚀 Getting Started
+
+### Prerequisites
+- Python 3.8+
+- Hugging Face account and token
+- API keys for Tavily, NASA, and OpenWeatherMap
+- Redis instance for caching
+
+### Setup Instructions
 1. Clone the repository
-2. Set up the required secrets in your environment:
-   - `HF_TOKEN`: Hugging Face access token
-   - `TAVILY_API_KEY`: Tavily API key
-   - `REDIS_HOST`, `REDIS_PORT`, `REDIS_USERNAME`, `REDIS_PASSWORD`: Redis connection details
-   - `NASA_API_KEY`: NASA API key
-   - `OPENWEATHER_API_KEY`: OpenWeatherMap API key
-3. Install dependencies: `pip install -r requirements.txt`
-4. Run the application: `python app.py`
+2. Set up required environment variables:
+   ```bash
+   export HF_TOKEN="your_hugging_face_token"
+   export TAVILY_API_KEY="your_tavily_api_key"
+   export REDIS_HOST="your_redis_host"
+   export REDIS_PORT="your_redis_port"
+   export REDIS_USERNAME="your_redis_username"
+   export REDIS_PASSWORD="your_redis_password"
+   export NASA_API_KEY="your_nasa_api_key"
+   export OPENWEATHER_API_KEY="your_openweather_api_key"
+Install dependencies:
+
+pip install -r requirements.txt
+Run the application:
+
+python app.py
+📊 System Monitoring
+The assistant includes built-in monitoring capabilities:
 
-## Deployment
+Server Health Tracking: Detects and reports server state changes
+Performance Metrics: Logs request processing times
+Uptime Monitoring: Tracks system availability
+Failure Recovery: Automatic handling of transient errors
+📋 Example Queries
+Try these sample questions to see the assistant in action:
 
-Deploy as a Hugging Face Space with the following configuration:
-- SDK: Gradio
-- Secrets: Configure all API keys as described above
+"What are the latest developments in fusion energy research?"
+"How does climate change impact global food security?"
+"Explain the significance of recent Mars rover discoveries"
+"What are the economic implications of AI advancement?"
+📄 License
+This project is licensed under the Apache 2.0 License - see the LICENSE file for details.
 
-## License
+🤝 Contributing
+Contributions are welcome! Please feel free to submit a Pull Request.
 
-Apache 2.0
+📞 Support
+For issues, questions, or feedback, please open an issue on the repository.

app.py

@@ -1,61 +1,151 @@
 import gradio as gr
+import asyncio
 from modules.input_handler import validate_input
 from modules.retriever import perform_search
 from modules.context_enhancer import add_weather_context, add_space_weather_context
 from modules.analyzer import analyze_with_model
 from modules.formatter import format_output
-from modules.citation import generate_citations
-from modules.visualizer import render_output
+from modules.citation import generate_citations, format_citations
 from modules.server_cache import get_cached_result, cache_result
 from modules.status_logger import log_request
+from modules.server_monitor import ServerMonitor
 
-def research_assistant(query):
+server_monitor = ServerMonitor()
+
+async def research_assistant(query):
     log_request("Research started", query=query)
 
-    # Check cache first
     cached = get_cached_result(query)
     if cached:
         log_request("Cache hit", query=query)
-        return cached
+        yield cached
+        return
+
+    try:
+        validated_query = validate_input(query)
+    except ValueError as e:
+        yield f"⚠️ Input Error: {str(e)}"
+        return
+
+    # Run context enhancement and search in parallel
+    weather_task = asyncio.create_task(add_weather_context())
+    space_weather_task = asyncio.create_task(add_space_weather_context())
+    search_task = asyncio.create_task(asyncio.to_thread(perform_search, validated_query))
+
+    weather_data = await weather_task
+    space_weather_data = await space_weather_task
+    search_results = await search_task
+
+    # Handle search errors
+    if isinstance(search_results, list) and len(search_results) > 0 and "error" in search_results[0]:
+        yield f"🔍 Search Error: {search_results[0]['error']}"
+        return
 
-    # Input validation
-    validated_query = validate_input(query)
+    # Format search content for LLM
+    search_content = ""
+    answer_content = ""
+    for result in search_results:
+        if result.get("type") == "answer":
+            answer_content = f"Direct Answer: {result['content']}\n\n"
+        elif result.get("type") == "source":
+            search_content += f"Source: {result['content']}\n\n"
 
-    # Context enhancement
-    weather_data = add_weather_context()
-    space_weather_data = add_space_weather_context()
+    enriched_input = f"{validated_query}\n\n{answer_content}Weather: {weather_data}\nSpace Weather: {space_weather_data}\n\nSearch Results:\n{search_content}"
 
-    # Web search
-    search_results = perform_search(validated_query)
+    server_status = server_monitor.check_server_status()
+    if not server_status["available"]:
+        wait_time = server_status["estimated_wait"]
+        yield (
+            f"⏳ **Server Initializing** ⏳\n\n"
+            f"The AI model server is currently starting up. This happens automatically after periods of inactivity.\n\n"
+            f"**Estimated wait time: {wait_time} minutes**\n\n"
+            f"**What you can do:**\n"
+            f"- Wait for {wait_time} minutes and try again\n"
+            f"- Try a simpler query which might process faster\n"
+            f"- Check back shortly - the server will be ready soon!\n\n"
+            f"*Technical Details: {server_status['message']}*"
+        )
+        return
 
-    # Combine context
-    enriched_input = f"{validated_query}\n\nWeather: {weather_data}\nSpace Weather: {space_weather_data}\n\nSearch Results:\n{search_results}"
+    try:
+        stream = analyze_with_model(enriched_input)
+        full_response = ""
 
-    # LLM Analysis
-    analysis = analyze_with_model(enriched_input)
+        for chunk in stream:
+            full_response += chunk
+            yield format_output(full_response)
 
-    # Formatting and citations
-    formatted_output = format_output(analysis)
-    citations = generate_citations(search_results)
+        citations = generate_citations(search_results)
+        citation_text = format_citations(citations)
+        full_output = format_output(full_response) + citation_text
 
-    # Final output
-    final_output = render_output(formatted_output, citations)
+        cache_result(query, full_output)
+        server_monitor.report_success()
+        log_request("Research completed", result_length=len(full_output))
 
-    # Cache result
-    cache_result(query, final_output)
+    except Exception as e:
+        server_monitor.report_failure()
+        yield f"🤖 **Unexpected Error** 🤖\n\nAn unexpected error occurred:\n\n{str(e)}"
 
-    log_request("Research completed", result_length=len(final_output))
-    return final_output
+# Wrapper for Gradio
+def research_assistant_wrapper(query):
+    return asyncio.run(research_assistant(query))
 
-# Gradio Interface
-demo = gr.Interface(
-    fn=research_assistant,
-    inputs=gr.Textbox(label="Enter your research question"),
-    outputs=gr.Markdown(label="Research Summary"),
-    title="AI Research Assistant",
-    description="An AI-powered research assistant that gathers and analyzes information with web search, weather, and space weather context.",
-    allow_flagging="never"
-)
+# Gradio Interface for Streaming
+with gr.Blocks(theme=gr.themes.Soft(), title="AI Research Assistant") as demo:
+    gr.Markdown("# 🧠 AI Research Assistant")
+    gr.Markdown("This advanced AI assistant combines web search with contextual awareness to answer complex questions. "
+                "It incorporates current weather and space weather data for richer context.")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("## How to Use")
+            gr.Markdown("""
+            1. Enter a research question in the input box
+            2. Click Submit or press Enter
+            3. Watch as the response streams in real-time
+            4. Review sources at the end of each response
+            
+            ## Features
+            - 🔍 Web search integration
+            - 🌤️ Weather context
+            - 🌌 Space weather context
+            - 📚 Real-time citations
+            - ⚡ Streaming output
+            """)
+            
+        with gr.Column(scale=2):
+            chatbot = gr.Chatbot(height=500, label="Research Conversation")
+            msg = gr.Textbox(
+                label="Research Question",
+                placeholder="Ask a complex research question...",
+                lines=3
+            )
+            submit_btn = gr.Button("Submit Research Query")
+            clear_btn = gr.Button("Clear Conversation")
+            
+            examples = gr.Examples(
+                examples=[
+                    "What are the latest developments in quantum computing?",
+                    "How does climate change affect ocean currents?",
+                    "Explain the significance of the James Webb Space Telescope findings",
+                    "What are the economic implications of renewable energy adoption?",
+                    "How do solar flares affect satellite communications?"
+                ],
+                inputs=msg,
+                label="Example Questions"
+            )
+    
+    def respond(message, chat_history):
+        bot_response = ""
+        for partial_response in research_assistant_wrapper(message):
+            bot_response = partial_response
+            yield bot_response
+    
+    submit_btn.click(respond, [msg, chatbot], chatbot)
+    msg.submit(respond, [msg, chatbot], chatbot)
+    
+    clear_btn.click(lambda: None, None, chatbot, queue=False)
 
 if __name__ == "__main__":
     demo.launch()

modules/analyzer.py

@@ -1,5 +1,6 @@
 from openai import OpenAI
 import os
+import time
 
 client = OpenAI(
     base_url="https://zxzbfrlg3ssrk7d9.us-east-1.aws.endpoints.huggingface.cloud/v1/",
@@ -7,14 +8,30 @@ client = OpenAI(
 )
 
 def analyze_with_model(prompt):
+    """Analyze prompt with LLM, returning a generator for streaming"""
     try:
         response = client.chat.completions.create(
             model="DavidAU/OpenAi-GPT-oss-20b-abliterated-uncensored-NEO-Imatrix-gguf",
             messages=[{"role": "user", "content": prompt}],
-            stream=False,
+            stream=True,  # Enable streaming
             temperature=0.7,
-            max_tokens=1000
+            max_tokens=8192,  # Increased token limit
+            timeout=120  # Increased timeout for longer responses
         )
-        return response.choices[0].message.content
+
+        for chunk in response:
+            content = chunk.choices[0].delta.content
+            if content:
+                yield content
+            time.sleep(0.01)  # Smooth out the stream
+
     except Exception as e:
-        return f"Error during analysis: {str(e)}"
+        error_msg = str(e)
+        if "503" in error_msg:
+            yield f"Error during analysis: Service temporarily unavailable (503). The model server is likely initializing. Please wait 5 minutes and try again. Details: {error_msg}"
+        elif "timeout" in error_msg.lower():
+            yield f"Error during analysis: Request timed out. The model server may be initializing. Please wait 5 minutes and try again. Details: {error_msg}"
+        elif "connection" in error_msg.lower():
+            yield f"Error during analysis: Connection error. The model server may be initializing. Please wait 5 minutes and try again. Details: {error_msg}"
+        else:
+            yield f"Error during analysis: {error_msg}"

modules/citation.py

@@ -1,14 +1,14 @@
-import json
-
 def generate_citations(search_results):
-    """Generate citations from search results"""
+    """Generate citations from structured search results"""
     try:
-        # For now, return a placeholder citation
-        # In a real implementation, this would parse actual search results
-        return [
-            {"source": "Web Search Result 1", "url": "https://example.com/1"},
-            {"source": "Web Search Result 2", "url": "https://example.com/2"}
-        ]
+        citations = []
+        for result in search_results:
+            if result.get("type") == "source" and result.get("url"):
+                citations.append({
+                    "source": result.get("title", "Unknown Source"),
+                    "url": result.get("url")
+                })
+        return citations
     except Exception as e:
         return [{"error": f"Citation generation failed: {str(e)}"}]
 
@@ -16,7 +16,7 @@ def format_citations(citations):
     """Format citations for display"""
     if not citations:
         return ""
-    
+
     formatted = "\n\n**Sources:**\n"
     for i, citation in enumerate(citations, 1):
         if "error" in citation:

modules/context_enhancer.py

@@ -1,41 +1,37 @@
-import requests
+import aiohttp
 import os
 from datetime import datetime
 
-def add_weather_context(location="London"):
-    """Add current weather context to the query"""
+async def add_weather_context(location="London"):
     try:
         api_key = os.getenv("OPENWEATHER_API_KEY")
         if not api_key:
             return "Weather data unavailable (API key not configured)"
-        
+
         url = f"http://api.openweathermap.org/data/2.5/weather?q={location}&appid={api_key}&units=metric"
-        response = requests.get(url, timeout=5)
-        response.raise_for_status()
-        data = response.json()
-        
-        return f"Current weather in {location}: {data['weather'][0]['description']}, {data['main']['temp']}°C"
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, timeout=5) as response:
+                response.raise_for_status()
+                data = await response.json()
+                return f"Current weather in {location}: {data['weather'][0]['description']}, {data['main']['temp']}°C"
     except Exception as e:
         return f"Weather data unavailable: {str(e)}"
 
-def add_space_weather_context():
-    """Add space weather context to the query"""
+async def add_space_weather_context():
     try:
         api_key = os.getenv("NASA_API_KEY")
         if not api_key:
             return "Space weather data unavailable (API key not configured)"
-        
-        # Using a different NASA endpoint that doesn't require parameters
+
         url = f"https://api.nasa.gov/planetary/apod?api_key={api_key}"
-        response = requests.get(url, timeout=5)
-        response.raise_for_status()
-        data = response.json()
-        
-        return f"Space context: Astronomy Picture of the Day - {data.get('title', 'N/A')}"
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, timeout=5) as response:
+                response.raise_for_status()
+                data = await response.json()
+                return f"Space context: Astronomy Picture of the Day - {data.get('title', 'N/A')}"
     except Exception as e:
         return f"Space weather data unavailable: {str(e)}"
 
 def add_time_context():
-    """Add current time context"""
     now = datetime.now()
     return f"Current date and time: {now.strftime('%Y-%m-%d %H:%M:%S %Z')}"

modules/retriever.py

@@ -4,25 +4,31 @@ import os
 tavily = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
 
 def perform_search(query):
-    """Perform web search using Tavily API"""
+    """Perform web search using Tavily API and return structured results"""
     try:
         if not os.getenv("TAVILY_API_KEY"):
-            return "Web search unavailable (API key not configured)"
-        
+            return [{"error": "API key not configured"}]
+
         response = tavily.search(
-            query=query, 
+            query=query,
             max_results=5,
             include_answer=True,
             include_raw_content=False
         )
-        
+
         results = []
         if response.get('answer'):
-            results.append(f"Direct Answer: {response['answer']}")
-        
+            results.append({"type": "answer", "content": response['answer']})
+
         for result in response.get('results', []):
-            results.append(f"Source: {result['content']}")
-        
-        return "\n\n".join(results) if results else "No relevant results found."
+            results.append({
+                "type": "source",
+                "title": result.get("title"),
+                "url": result.get("url"),
+                "content": result.get("content")
+            })
+
+        return results
+
     except Exception as e:
-        return f"Search failed: {str(e)}"
+        return [{"error": f"Search failed: {str(e)}"}]

modules/server_monitor.py

@@ -0,0 +1,167 @@
+import redis
+import os
+import time
+from datetime import datetime, timedelta
+
+class ServerMonitor:
+    def __init__(self):
+        try:
+            self.redis_client = redis.Redis(
+                host=os.getenv("REDIS_HOST", "localhost"),
+                port=int(os.getenv("REDIS_PORT", 6379)),
+                username=os.getenv("REDIS_USERNAME"),
+                password=os.getenv("REDIS_PASSWORD"),
+                decode_responses=True
+            )
+            # Test connection
+            self.redis_client.ping()
+            self.connected = True
+        except Exception:
+            self.redis_client = None
+            self.connected = False
+    
+    def report_failure(self):
+        """Report a server failure (e.g., 503 error)"""
+        if not self.connected:
+            return
+            
+        try:
+            # Increment failure counter
+            key = f"server_failures:{datetime.now().strftime('%Y-%m-%d:%H')}"
+            self.redis_client.incr(key)
+            self.redis_client.expire(key, 3600)  # Expire in 1 hour
+            
+            # Record last failure time
+            self.redis_client.set("last_failure", datetime.now().isoformat())
+            self.redis_client.expire("last_failure", 86400)  # Expire in 24 hours
+        except Exception:
+            pass  # Silently fail to avoid breaking the main app
+    
+    def report_success(self):
+        """Report a successful request"""
+        if not self.connected:
+            return
+            
+        try:
+            # Reset failure counter for current hour
+            key = f"server_failures:{datetime.now().strftime('%Y-%m-%d:%H')}"
+            self.redis_client.delete(key)
+            
+            # Record last success time
+            self.redis_client.set("last_success", datetime.now().isoformat())
+            self.redis_client.expire("last_success", 86400)  # Expire in 24 hours
+        except Exception:
+            pass  # Silently fail to avoid breaking the main app
+    
+    def check_server_status(self):
+        """Check if server is likely available based on recent activity"""
+        if not self.connected:
+            return {"available": True, "message": "Redis not configured, assuming server available"}
+        
+        try:
+            # Get recent failures
+            now = datetime.now()
+            failures_last_hour = 0
+            
+            # Check current and previous hour
+            for i in range(2):
+                check_time = now - timedelta(hours=i)
+                key = f"server_failures:{check_time.strftime('%Y-%m-%d:%H')}"
+                failures = self.redis_client.get(key)
+                if failures:
+                    failures_last_hour += int(failures)
+            
+            # Get last failure time
+            last_failure_str = self.redis_client.get("last_failure")
+            last_success_str = self.redis_client.get("last_success")
+            
+            # If we had recent failures but no recent success, server might be down
+            if failures_last_hour > 3:
+                if last_success_str:
+                    last_success = datetime.fromisoformat(last_success_str)
+                    minutes_since_success = (now - last_success).total_seconds() / 60
+                    if minutes_since_success < 15:
+                        return {
+                            "available": True, 
+                            "message": "Recent success detected, server likely available",
+                            "estimated_wait": 0
+                        }
+                
+                # Estimate wait time based on typical warmup
+                return {
+                    "available": False, 
+                    "message": f"High failure rate detected ({failures_last_hour} failures recently)",
+                    "estimated_wait": 5
+                }
+            
+            # If we had a very recent failure (< 5 mins), suggest waiting
+            if last_failure_str:
+                last_failure = datetime.fromisoformat(last_failure_str)
+                minutes_since_failure = (now - last_failure).total_seconds() / 60
+                if minutes_since_failure < 5:
+                    return {
+                        "available": False, 
+                        "message": f"Recent failure {int(minutes_since_failure)} minutes ago",
+                        "estimated_wait": max(1, 5 - int(minutes_since_failure))
+                    }
+            
+            return {
+                "available": True, 
+                "message": "Server appears to be available",
+                "estimated_wait": 0
+            }
+            
+        except Exception as e:
+            # On any Redis error, assume server is available
+            return {
+                "available": True, 
+                "message": f"Monitoring check failed: {str(e)}, assuming server available",
+                "estimated_wait": 0
+            }
+    
+    def get_system_stats(self):
+        """Get detailed system statistics"""
+        if not self.connected:
+            return {"error": "Redis not configured"}
+        
+        try:
+            stats = {}
+            
+            # Get recent failures
+            now = datetime.now()
+            total_failures = 0
+            for i in range(24):  # Last 24 hours
+                check_time = now - timedelta(hours=i)
+                key = f"server_failures:{check_time.strftime('%Y-%m-%d:%H')}"
+                failures = self.redis_client.get(key)
+                if failures:
+                    total_failures += int(failures)
+            
+            stats["failures_last_24h"] = total_failures
+            
+            # Get last events
+            last_failure = self.redis_client.get("last_failure")
+            last_success = self.redis_client.get("last_success")
+            
+            stats["last_failure"] = last_failure if last_failure else "None recorded"
+            stats["last_success"] = last_success if last_success else "None recorded"
+            
+            # Calculate uptime percentage (approximate)
+            if last_failure and last_success:
+                failure_time = datetime.fromisoformat(last_failure)
+                success_time = datetime.fromisoformat(last_success)
+                if success_time > failure_time:
+                    stats["status"] = "Operational"
+                else:
+                    stats["status"] = "Degraded"
+            elif last_success:
+                stats["status"] = "Operational"
+            elif last_failure:
+                stats["status"] = "Issues Detected"
+            else:
+                stats["status"] = "Unknown"
+                
+            return stats
+            
+        except Exception as e:
+            return {"error": str(e)}

requirements.txt

@@ -2,5 +2,6 @@ gradio==4.38.1
 openai
 tavily-python
 redis
+aiohttp
 requests
 python-dotenv

version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.0.0",
-  "description": "Initial modular architecture with Redis, weather, and space weather integration"
+"version": "1.0.0",
+"description": "Initial modular architecture with Redis, weather, and space weather integration"
 }