Modular architecture: logging_config.py, cloudflare_client.py, app.py for Cloudflare AI

app.py

@@ -1,157 +1,133 @@
+# app.py - Main Gradio Application
 import gradio as gr
-import requests
-import logging
-import sys
-import os
+from logging_config import setup_logging, log_banner, log_section, log_startup_info
+from cloudflare_client import CloudflareAIClient
 import json
-from datetime import datetime
 
 # ============================================================================
-#                    LOGGING SETUP
+#                    INITIALIZATION
 # ============================================================================
-logging.basicConfig(
-    level=logging.DEBUG,
-    format="%(asctime)s | %(levelname)-8s | %(message)s",
-    handlers=[logging.StreamHandler(sys.stdout)]
-)
-logger = logging.getLogger("ChatbotBrain")
-
-def log_banner(text):
-    logger.info("=" * 60)
-    logger.info(f"  {text}")
-    logger.info("=" * 60)
-
-log_banner("CPU CHATBOT - CLOUDFLARE AI BACKEND")
-logger.info(f"Start Time: {datetime.now().isoformat()}")
-logger.info(f"Python: {sys.version}")
-logger.info(f"Gradio: {gr.__version__}")
+logger = setup_logging()
+log_startup_info(logger)
 
 # ============================================================================
-#                    CLOUDFLARE API CONFIGURATION  
+#                    CLOUDFLARE CONFIGURATION
 # ============================================================================
-# Your Cloudflare Worker endpoint
-CLOUDFLARE_ENDPOINT = "https://cloudflare.nlhughes08.workers.dev"
+# Your Cloudflare Worker endpoint - update this when deployed!
+CLOUDFLARE_ENDPOINT = "https://cloudflarellamaworker.nlhughes08.workers.dev"
 
-logger.info(f"Backend: {CLOUDFLARE_ENDPOINT}")
+log_section(logger, "CLOUDFLARE AI CLIENT SETUP")
+ai_client = CloudflareAIClient(logger, CLOUDFLARE_ENDPOINT)
+
+# Test connection on startup
+logger.info("Testing Cloudflare endpoint on startup...")
+connection_ok = ai_client.test_connection()
+if connection_ok:
+    logger.info("Cloudflare endpoint is REACHABLE")
+else:
+    logger.warning("Cloudflare endpoint may not be ready - check deployment")
 
 # ============================================================================
-#                    API CALL FUNCTION
+#                    CHAT RESPONSE FUNCTION
 # ============================================================================
-def call_cloudflare_ai(message, history):
-    """Call the Cloudflare Workers AI backend."""
-    logger.info("-" * 40)
-    logger.info(f"USER MESSAGE: {message}")
-    logger.info(f"History length: {len(history)}")
+def respond(message, history):
+    """Generate AI response using Cloudflare Workers AI."""
+    log_section(logger, "NEW USER MESSAGE")
+    logger.info(f"User: {message}")
+    logger.info(f"History: {len(history)} previous messages")
     
-    # Build messages array
-    messages = []
-    for user_msg, bot_msg in history:
-        messages.append({"role": "user", "content": user_msg})
-        if bot_msg:
-            messages.append({"role": "assistant", "content": bot_msg})
-    messages.append({"role": "user", "content": message})
+    # Build context from history (simple approach)
+    context = ""
+    if history:
+        for user_msg, bot_msg in history[-5:]:  # Last 5 exchanges
+            context += f"User: {user_msg}\n"
+            if bot_msg:
+                context += f"Assistant: {bot_msg}\n"
     
-    # Try multiple endpoint patterns
-    endpoints_to_try = [
-        (f"{CLOUDFLARE_ENDPOINT}/api/chat", {"messages": messages}),
-        (f"{CLOUDFLARE_ENDPOINT}/chat", {"messages": messages}),
-        (f"{CLOUDFLARE_ENDPOINT}/api/chat", {"message": message, "history": history}),
-        (f"{CLOUDFLARE_ENDPOINT}", {"messages": messages}),
-    ]
+    # Full prompt with context
+    if context:
+        full_prompt = f"{context}User: {message}\nAssistant:"
+    else:
+        full_prompt = message
     
-    for url, payload in endpoints_to_try:
-        logger.info(f"Trying: {url}")
-        logger.debug(f"Payload: {json.dumps(payload)[:200]}")
-        
-        try:
-            response = requests.post(
-                url,
-                headers={"Content-Type": "application/json"},
-                json=payload,
-                timeout=60
-            )
-            
-            logger.info(f"Status: {response.status_code}")
-            
-            if response.status_code == 200:
-                try:
-                    result = response.json()
-                    logger.info(f"Response: {json.dumps(result)[:200]}")
-                    
-                    # Try different response formats
-                    if isinstance(result, dict):
-                        text = (
-                            result.get("response") or 
-                            result.get("message") or 
-                            result.get("content") or
-                            result.get("choices", [{}])[0].get("message", {}).get("content") or
-                            str(result)
-                        )
-                    else:
-                        text = str(result)
-                    
-                    if text:
-                        logger.info(f"SUCCESS: Got response from {url}")
-                        return text
-                except:
-                    text = response.text
-                    if text:
-                        logger.info(f"SUCCESS (text): Got response from {url}")
-                        return text
-            
-            logger.warning(f"Failed: {response.status_code} - {response.text[:100]}")
-            
-        except Exception as e:
-            logger.error(f"Error calling {url}: {e}")
-            continue
+    logger.debug(f"Full prompt length: {len(full_prompt)} chars")
     
-    # If all endpoints fail, return error with helpful info
-    error_msg = f"""Sorry, I could not connect to the AI backend.
-
-Tried endpoints:
-- {CLOUDFLARE_ENDPOINT}/api/chat
-- {CLOUDFLARE_ENDPOINT}/chat  
-- {CLOUDFLARE_ENDPOINT}
-
-You can use the AI directly at:
-{CLOUDFLARE_ENDPOINT}
-
-Please check the Container Logs for details."""
+    # Call Cloudflare AI
+    result = ai_client.call_ai(full_prompt)
     
-    return error_msg
+    if result["success"]:
+        response_text = result["response"]
+        # Clean up any model artifacts like <|start_header_id|>
+        for tag in ["<|start_header_id|>", "<|end_header_id|>", "<|eot_id|>"]:
+            response_text = response_text.replace(tag, "")
+        return response_text.strip()
+    else:
+        # Return error with diagnostic info
+        error_msg = result.get("error", "Unknown error")
+        diagnosis = result.get("diagnosis", {})
+        
+        error_response = f"Error: {error_msg}\n\n"
+        
+        if diagnosis.get("suggestions"):
+            error_response += "Troubleshooting:\n"
+            for suggestion in diagnosis["suggestions"]:
+                error_response += f"• {suggestion}\n"
+        
+        error_response += f"\nEndpoint: {CLOUDFLARE_ENDPOINT}"
+        
+        return error_response
 
 # ============================================================================
 #                    GRADIO UI
 # ============================================================================
-log_banner("BUILDING GRADIO UI")
+log_section(logger, "BUILDING GRADIO UI")
 
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("# CPU Chatbot")
-    gr.Markdown("### Powered by Cloudflare Workers AI")
-    gr.Markdown(f"Backend: [{CLOUDFLARE_ENDPOINT}]({CLOUDFLARE_ENDPOINT})")
+    gr.Markdown("### Powered by Cloudflare Workers AI (Llama Guard 3)")
+    gr.Markdown(f"**Endpoint:** `{CLOUDFLARE_ENDPOINT}`")
     
-    chatbot = gr.Chatbot(height=500)
-    msg = gr.Textbox(placeholder="Ask me anything...", label="Your message")
-    clear = gr.ClearButton([msg, chatbot])
+    with gr.Row():
+        with gr.Column(scale=4):
+            chatbot = gr.Chatbot(height=500, label="Chat")
+            msg = gr.Textbox(placeholder="Ask me anything...", label="Your message")
+            with gr.Row():
+                submit_btn = gr.Button("Send", variant="primary")
+                clear = gr.ClearButton([msg, chatbot], value="Clear")
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### Status")
+            status_box = gr.JSON(
+                label="Client Stats",
+                value=ai_client.get_stats()
+            )
+            refresh_btn = gr.Button("Refresh Stats")
     
     def user_submit(message, history):
         if not message.strip():
-            return "", history
-        return "", history + [[message, None]]
+            return "", history, ai_client.get_stats()
+        return "", history + [[message, None]], ai_client.get_stats()
     
     def bot_respond(history):
         if not history:
-            return history
+            return history, ai_client.get_stats()
         user_message = history[-1][0]
-        bot_response = call_cloudflare_ai(user_message, history[:-1])
+        bot_response = respond(user_message, history[:-1])
         history[-1][1] = bot_response
-        return history
+        return history, ai_client.get_stats()
     
-    msg.submit(user_submit, [msg, chatbot], [msg, chatbot], queue=False).then(
-        bot_respond, chatbot, chatbot
+    def refresh_stats():
+        return ai_client.get_stats()
+    
+    msg.submit(user_submit, [msg, chatbot], [msg, chatbot, status_box], queue=False).then(
+        bot_respond, chatbot, [chatbot, status_box]
+    )
+    submit_btn.click(user_submit, [msg, chatbot], [msg, chatbot, status_box], queue=False).then(
+        bot_respond, chatbot, [chatbot, status_box]
     )
+    refresh_btn.click(refresh_stats, outputs=status_box)
 
-log_banner("SYSTEM READY")
+log_banner(logger, "SYSTEM READY - WAITING FOR MESSAGES")
 
 if __name__ == "__main__":
     demo.launch()

cloudflare_client.py

@@ -0,0 +1,205 @@
+# cloudflare_client.py - Cloudflare Workers AI API Client
+import requests
+import json
+from datetime import datetime
+
+class CloudflareAIClient:
+    """Client for calling Cloudflare Workers AI endpoints."""
+    
+    def __init__(self, logger, endpoint_url):
+        self.logger = logger
+        self.endpoint_url = endpoint_url
+        self.request_count = 0
+        self.success_count = 0
+        self.error_count = 0
+        self.last_error = None
+        
+        self.logger.info(f"CloudflareAIClient initialized")
+        self.logger.info(f"Endpoint: {endpoint_url}")
+    
+    def get_stats(self):
+        """Return client statistics."""
+        return {
+            "requests": self.request_count,
+            "successes": self.success_count,
+            "errors": self.error_count,
+            "last_error": self.last_error
+        }
+    
+    def test_connection(self):
+        """Test if the endpoint is reachable."""
+        self.logger.info("Testing connection to Cloudflare endpoint...")
+        try:
+            response = requests.get(self.endpoint_url, timeout=10)
+            self.logger.info(f"Connection test: Status {response.status_code}")
+            self.logger.debug(f"Response: {response.text[:200]}")
+            return response.status_code in [200, 405]  # 405 = method not allowed but reachable
+        except Exception as e:
+            self.logger.error(f"Connection test failed: {e}")
+            return False
+    
+    def call_ai(self, prompt):
+        """
+        Call the Cloudflare Workers AI with a prompt.
+        
+        Args:
+            prompt: The user's message/prompt
+            
+        Returns:
+            dict with 'success', 'response' or 'error', and 'debug_info'
+        """
+        self.request_count += 1
+        request_id = f"REQ-{self.request_count:04d}"
+        
+        self.logger.info("-" * 50)
+        self.logger.info(f"[{request_id}] NEW AI REQUEST")
+        self.logger.info(f"[{request_id}] Prompt: {prompt[:100]}...")
+        self.logger.info(f"[{request_id}] Endpoint: {self.endpoint_url}")
+        
+        debug_info = {
+            "request_id": request_id,
+            "timestamp": datetime.now().isoformat(),
+            "endpoint": self.endpoint_url,
+            "prompt_length": len(prompt)
+        }
+        
+        payload = {"prompt": prompt}
+        self.logger.debug(f"[{request_id}] Payload: {json.dumps(payload)}")
+        
+        try:
+            self.logger.info(f"[{request_id}] Sending POST request...")
+            response = requests.post(
+                self.endpoint_url,
+                headers={"Content-Type": "application/json"},
+                json=payload,
+                timeout=60
+            )
+            
+            debug_info["status_code"] = response.status_code
+            debug_info["response_time_estimate"] = "< 60s"
+            
+            self.logger.info(f"[{request_id}] Response Status: {response.status_code}")
+            self.logger.debug(f"[{request_id}] Response Headers: {dict(response.headers)}")
+            
+            if response.status_code == 200:
+                try:
+                    result = response.json()
+                    self.logger.info(f"[{request_id}] SUCCESS: Got JSON response")
+                    self.logger.debug(f"[{request_id}] Response: {json.dumps(result)[:300]}")
+                    
+                    # Extract the reply from the response
+                    reply = result.get("reply") or result.get("response") or result.get("message")
+                    
+                    if reply:
+                        self.success_count += 1
+                        self.logger.info(f"[{request_id}] AI Reply: {reply[:100]}...")
+                        return {
+                            "success": True,
+                            "response": reply,
+                            "debug_info": debug_info
+                        }
+                    else:
+                        self.logger.warning(f"[{request_id}] No reply field in response")
+                        return {
+                            "success": True,
+                            "response": str(result),
+                            "debug_info": debug_info
+                        }
+                        
+                except json.JSONDecodeError as e:
+                    self.logger.error(f"[{request_id}] JSON parse error: {e}")
+                    debug_info["error"] = f"JSON parse error: {e}"
+                    return {
+                        "success": False,
+                        "error": f"Invalid JSON response: {response.text[:200]}",
+                        "debug_info": debug_info
+                    }
+            else:
+                self.error_count += 1
+                error_msg = f"HTTP {response.status_code}: {response.text[:200]}"
+                self.last_error = error_msg
+                self.logger.error(f"[{request_id}] API ERROR: {error_msg}")
+                debug_info["error"] = error_msg
+                
+                # Provide helpful diagnostics based on error code
+                diagnosis = self._diagnose_error(response.status_code, response.text)
+                debug_info["diagnosis"] = diagnosis
+                
+                return {
+                    "success": False,
+                    "error": error_msg,
+                    "diagnosis": diagnosis,
+                    "debug_info": debug_info
+                }
+                
+        except requests.exceptions.Timeout:
+            self.error_count += 1
+            self.last_error = "Request timeout"
+            self.logger.error(f"[{request_id}] TIMEOUT after 60 seconds")
+            return {
+                "success": False,
+                "error": "Request timed out after 60 seconds",
+                "debug_info": debug_info
+            }
+        except requests.exceptions.ConnectionError as e:
+            self.error_count += 1
+            self.last_error = str(e)
+            self.logger.error(f"[{request_id}] CONNECTION ERROR: {e}")
+            return {
+                "success": False,
+                "error": f"Connection error: {e}",
+                "debug_info": debug_info
+            }
+        except Exception as e:
+            self.error_count += 1
+            self.last_error = str(e)
+            self.logger.error(f"[{request_id}] UNEXPECTED ERROR: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "debug_info": debug_info
+            }
+    
+    def _diagnose_error(self, status_code, response_text):
+        """Diagnose common errors and provide helpful suggestions."""
+        diagnosis = {"code": status_code, "suggestions": []}
+        
+        if "1042" in response_text:
+            diagnosis["issue"] = "WORKER_NOT_DEPLOYED"
+            diagnosis["suggestions"] = [
+                "The Cloudflare Worker is not deployed yet",
+                "Push the worker code to GitHub to trigger deployment",
+                "Check the Cloudflare dashboard for build errors"
+            ]
+        elif status_code == 400:
+            diagnosis["issue"] = "BAD_REQUEST"
+            diagnosis["suggestions"] = [
+                "Check the request payload format",
+                "Ensure 'prompt' field is present"
+            ]
+        elif status_code == 401 or status_code == 403:
+            diagnosis["issue"] = "AUTHENTICATION_ERROR"
+            diagnosis["suggestions"] = [
+                "Check Cloudflare API token",
+                "Verify Worker permissions"
+            ]
+        elif status_code == 404:
+            diagnosis["issue"] = "NOT_FOUND"
+            diagnosis["suggestions"] = [
+                "Worker endpoint does not exist",
+                "Check the URL is correct"
+            ]
+        elif status_code == 500:
+            diagnosis["issue"] = "SERVER_ERROR"
+            diagnosis["suggestions"] = [
+                "Check Worker logs in Cloudflare dashboard",
+                "Verify AI binding is configured"
+            ]
+        else:
+            diagnosis["issue"] = f"UNKNOWN_ERROR_{status_code}"
+            diagnosis["suggestions"] = ["Check Cloudflare dashboard for details"]
+        
+        for suggestion in diagnosis["suggestions"]:
+            self.logger.warning(f"SUGGESTION: {suggestion}")
+        
+        return diagnosis

logging_config.py

@@ -0,0 +1,33 @@
+# logging_config.py - Centralized logging configuration
+import logging
+import sys
+from datetime import datetime
+
+def setup_logging():
+    """Configure and return the application logger."""
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format="%(asctime)s | %(levelname)-8s | [%(module)s.%(funcName)s] %(message)s",
+        handlers=[logging.StreamHandler(sys.stdout)]
+    )
+    return logging.getLogger("ChatbotBrain")
+
+def log_banner(logger, text):
+    """Log a prominent banner message."""
+    logger.info("=" * 70)
+    logger.info(f"  {text}")
+    logger.info("=" * 70)
+
+def log_section(logger, text):
+    """Log a section header."""
+    logger.info("-" * 50)
+    logger.info(f"  >> {text}")
+    logger.info("-" * 50)
+
+def log_startup_info(logger):
+    """Log startup information."""
+    import gradio as gr
+    log_banner(logger, "CPU CHATBOT - CLOUDFLARE AI BACKEND")
+    logger.info(f"Timestamp: {datetime.now().isoformat()}")
+    logger.info(f"Python: {sys.version}")
+    logger.info(f"Gradio: {gr.__version__}")