Update app.py

app.py

@@ -5,20 +5,33 @@
 # No Gradio interface - Pure backend
 # =====================
 
-from flask import Flask, request, jsonify, send_from_directory
-from flask_cors import CORS
+import os
+import time
 import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer
 from sentence_transformers import SentenceTransformer
 import faiss
 import numpy as np
-import time
-import os
+
+# Import Flask with fallback
+try:
+    from flask import Flask, request, jsonify
+    from flask_cors import CORS
+    FLASK_AVAILABLE = True
+except ImportError:
+    FLASK_AVAILABLE = False
+    print("❌ Flask not available - using basic HTTP server")
 
 print("🚀 Initializing Simba AI Backend API...")
 
-app = Flask(__name__)
-CORS(app)  # Enable CORS for your frontend
+# Create Flask app if available
+if FLASK_AVAILABLE:
+    app = Flask(__name__)
+    CORS(app)
+else:
+    # Fallback to basic server
+    from http.server import HTTPServer, BaseHTTPRequestHandler
+    import json
 
 # =====================
 # LOAD AI MODEL
@@ -208,80 +221,199 @@ def generate_simba_response(message):
         }
 
 # =====================
-# API ROUTES
+# FLASK API ROUTES (If Flask is available)
 # =====================
 
-@app.route('/')
-def home():
-    return jsonify({
-        "message": "🦁 Simba AI Backend API - First African LLM",
-        "status": "running",
-        "endpoints": {
-            "/api/chat": "POST - Chat with Simba AI",
-            "/api/health": "GET - Health check",
-            "/api/info": "GET - API information"
-        }
-    })
+if FLASK_AVAILABLE:
+    @app.route('/')
+    def home():
+        return jsonify({
+            "message": "🦁 Simba AI Backend API - First African LLM",
+            "status": "running",
+            "endpoints": {
+                "/api/chat": "POST - Chat with Simba AI",
+                "/api/health": "GET - Health check",
+                "/api/info": "GET - API information"
+            }
+        })
 
-@app.route('/api/health')
-def health_check():
-    return jsonify({
-        "status": "healthy",
-        "model": model_name,
-        "timestamp": time.time()
-    })
+    @app.route('/api/health')
+    def health_check():
+        return jsonify({
+            "status": "healthy",
+            "model": model_name,
+            "timestamp": time.time()
+        })
 
-@app.route('/api/info')
-def api_info():
-    return jsonify({
-        "name": "Simba AI - First African LLM",
-        "version": "1.0",
-        "model": model_name,
-        "capabilities": [
-            "African Languages: Yoruba, Swahili, Igbo, Hausa",
-            "Python Coding & Programming",
-            "Mathematics & Problem Solving",
-            "African Innovation Knowledge"
-        ],
-        "knowledge_base_size": len(simba_knowledge_base)
-    })
+    @app.route('/api/info')
+    def api_info():
+        return jsonify({
+            "name": "Simba AI - First African LLM",
+            "version": "1.0",
+            "model": model_name,
+            "capabilities": [
+                "African Languages: Yoruba, Swahili, Igbo, Hausa",
+                "Python Coding & Programming",
+                "Mathematics & Problem Solving",
+                "African Innovation Knowledge"
+            ],
+            "knowledge_base_size": len(simba_knowledge_base)
+        })
 
-@app.route('/api/chat', methods=['POST'])
-def chat():
-    try:
-        data = request.get_json()
-        
-        if not data or 'message' not in data:
+    @app.route('/api/chat', methods=['POST'])
+    def chat():
+        try:
+            data = request.get_json()
+            
+            if not data or 'message' not in data:
+                return jsonify({
+                    "error": "Missing 'message' in request body"
+                }), 400
+            
+            user_message = data['message']
+            
+            if not user_message.strip():
+                return jsonify({
+                    "error": "Message cannot be empty"
+                }), 400
+            
+            # Generate response
+            result = generate_simba_response(user_message)
+            
             return jsonify({
-                "error": "Missing 'message' in request body"
-            }), 400
-        
-        user_message = data['message']
-        
-        if not user_message.strip():
+                "success": True,
+                "user_message": user_message,
+                "simba_response": result["response"],
+                "response_time": result["response_time"],
+                "knowledge_used": result.get("knowledge_used", []),
+                "model": result.get("model", model_name),
+                "timestamp": time.time()
+            })
+            
+        except Exception as e:
             return jsonify({
-                "error": "Message cannot be empty"
-            }), 400
-        
-        # Generate response
-        result = generate_simba_response(user_message)
+                "success": False,
+                "error": str(e),
+                "timestamp": time.time()
+            }), 500
+
+# =====================
+# BASIC HTTP SERVER (Fallback if no Flask)
+# =====================
+
+if not FLASK_AVAILABLE:
+    class SimbaAIHandler(BaseHTTPRequestHandler):
+        def do_GET(self):
+            if self.path == '/api/health':
+                self.send_response(200)
+                self.send_header('Content-type', 'application/json')
+                self.send_header('Access-Control-Allow-Origin', '*')
+                self.end_headers()
+                response = json.dumps({
+                    "status": "healthy",
+                    "model": model_name,
+                    "timestamp": time.time()
+                })
+                self.wfile.write(response.encode())
+                
+            elif self.path == '/api/info':
+                self.send_response(200)
+                self.send_header('Content-type', 'application/json')
+                self.send_header('Access-Control-Allow-Origin', '*')
+                self.end_headers()
+                response = json.dumps({
+                    "name": "Simba AI - First African LLM",
+                    "version": "1.0",
+                    "model": model_name,
+                    "capabilities": [
+                        "African Languages: Yoruba, Swahili, Igbo, Hausa",
+                        "Python Coding & Programming",
+                        "Mathematics & Problem Solving",
+                        "African Innovation Knowledge"
+                    ],
+                    "knowledge_base_size": len(simba_knowledge_base)
+                })
+                self.wfile.write(response.encode())
+                
+            else:
+                self.send_response(200)
+                self.send_header('Content-type', 'application/json')
+                self.send_header('Access-Control-Allow-Origin', '*')
+                self.end_headers()
+                response = json.dumps({
+                    "message": "🦁 Simba AI Backend API - First African LLM",
+                    "status": "running",
+                    "endpoints": {
+                        "/api/chat": "POST - Chat with Simba AI",
+                        "/api/health": "GET - Health check",
+                        "/api/info": "GET - API information"
+                    }
+                })
+                self.wfile.write(response.encode())
         
-        return jsonify({
-            "success": True,
-            "user_message": user_message,
-            "simba_response": result["response"],
-            "response_time": result["response_time"],
-            "knowledge_used": result.get("knowledge_used", []),
-            "model": result.get("model", model_name),
-            "timestamp": time.time()
-        })
+        def do_POST(self):
+            if self.path == '/api/chat':
+                content_length = int(self.headers['Content-Length'])
+                post_data = self.rfile.read(content_length)
+                
+                try:
+                    data = json.loads(post_data.decode())
+                    user_message = data.get('message', '')
+                    
+                    if not user_message.strip():
+                        self.send_response(400)
+                        self.send_header('Content-type', 'application/json')
+                        self.send_header('Access-Control-Allow-Origin', '*')
+                        self.end_headers()
+                        response = json.dumps({"error": "Message cannot be empty"})
+                        self.wfile.write(response.encode())
+                        return
+                    
+                    # Generate response
+                    result = generate_simba_response(user_message)
+                    
+                    self.send_response(200)
+                    self.send_header('Content-type', 'application/json')
+                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.end_headers()
+                    
+                    response = json.dumps({
+                        "success": True,
+                        "user_message": user_message,
+                        "simba_response": result["response"],
+                        "response_time": result["response_time"],
+                        "knowledge_used": result.get("knowledge_used", []),
+                        "model": result.get("model", model_name),
+                        "timestamp": time.time()
+                    })
+                    self.wfile.write(response.encode())
+                    
+                except Exception as e:
+                    self.send_response(500)
+                    self.send_header('Content-type', 'application/json')
+                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.end_headers()
+                    response = json.dumps({
+                        "success": False,
+                        "error": str(e),
+                        "timestamp": time.time()
+                    })
+                    self.wfile.write(response.encode())
+            
+            else:
+                self.send_response(404)
+                self.send_header('Content-type', 'application/json')
+                self.send_header('Access-Control-Allow-Origin', '*')
+                self.end_headers()
+                response = json.dumps({"error": "Endpoint not found"})
+                self.wfile.write(response.encode())
         
-    except Exception as e:
-        return jsonify({
-            "success": False,
-            "error": str(e),
-            "timestamp": time.time()
-        }), 500
+        def do_OPTIONS(self):
+            self.send_response(200)
+            self.send_header('Access-Control-Allow-Origin', '*')
+            self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+            self.send_header('Access-Control-Allow-Headers', 'Content-Type')
+            self.end_headers()
 
 # =====================
 # LAUNCH
@@ -293,5 +425,12 @@ if __name__ == '__main__':
     print("   GET  /api/health - Health check")
     print("   GET  /api/info - API information") 
     print("   POST /api/chat - Chat with Simba AI")
-    print("\n🚀 Starting server...")
-    app.run(host='0.0.0.0', port=7860, debug=False)
+    
+    if FLASK_AVAILABLE:
+        print("🚀 Starting Flask server...")
+        app.run(host='0.0.0.0', port=7860, debug=False)
+    else:
+        print("🚀 Starting basic HTTP server...")
+        server = HTTPServer(('0.0.0.0', 7860), SimbaAIHandler)
+        print("✅ Server running on http://0.0.0.0:7860")
+        server.serve_forever()