3

Author: sudo-junaiddev

app.py

@@ -1,11 +1,7 @@
-from flask import Flask, send_from_directory, request, jsonify
+from flask import Flask, render_template, jsonify, request
 import requests
-from werkzeug.exceptions import NotFound
 from ollamaClient import OllamaClient
 
-# Constants
-TEMPLATE_FOLDER = "./templates"
-
 # Initialize Flask app and Ollama client
 app = Flask(__name__)
 ai = OllamaClient()
@@ -14,36 +10,30 @@
 # Route to serve the main index page
 @app.route("/")
 def index():
-    return send_from_directory(directory=TEMPLATE_FOLDER, path="index.html")
-
+    return render_template("index.html"),200
 
-# Route to handle other static pages
-@app.route("/<path:name>")
-def page_handler(name):
-    try:
-        return send_from_directory(directory=TEMPLATE_FOLDER, path=name)
-    except NotFound:
-        return send_from_directory(directory=TEMPLATE_FOLDER, path="404.html"), 404
 
+@app.errorhandler(Exception)
+def error_page(error):
+    if hasattr(error, "code") and error.code == 404:
+        return render_template("404.html"), 404
 
-# Custom 404 error handler
-@app.errorhandler(404)
-def page_not_found(error):
-    return send_from_directory(directory=TEMPLATE_FOLDER, path="404.html"), 404
+    return (
+        render_template("error.html", error=str(error)),
+        500,
+    )  # Return 500 for general errors
 
 
 # API endpoint to check connection to the Ollama server
 @app.route("/api/connection")
 def api_connection():
     try:
-        # Attempt to connect to the Ollama server
         res = requests.get("http://localhost:11434", timeout=5)
         status_code = res.status_code
     except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
         print("[LOG] ERROR: UNABLE TO CONNECT TO SERVER")
         status_code = 404
 
-    # Return appropriate response based on connection status
     if status_code == 200:
         return jsonify({"host": "localhost", "port": 11434, "status": "OK"}), 200
     else:
@@ -53,14 +43,12 @@ def api_connection():
 # API endpoint to get connection stats (available and active models)
 @app.route("/api/connection/stats")
 def api_connection_stats():
-    list_of_models = ai.listModels()
-    list_of_active_models = ai.listActiveModels()
+    list_of_models = ai.list_models()
+    list_of_active_models = ai.list_active_models()
 
-    # Handle cases where no models are available or active
     if not list_of_models and not list_of_active_models:
         return jsonify({"error": "No models found"}), 404
 
-    # Prepare response data
     data = {
         "available": list_of_models,
         "active": list_of_active_models,
@@ -69,22 +57,24 @@ def api_connection_stats():
     return jsonify(data), 200
 
 
-# API endpoint to handle chat requests
 @app.route("/api/chat", methods=["POST"])
 def api_chat():
-    data = request.get_json()
+    # Get JSON data from the request
+    data = request.json
+    prompt = data.get("prompt")
+    model = data.get("model")
 
-    # Validate required fields in the request
-    if not data or "prompt" not in data or "model" not in data:
-        return jsonify({"error": "Missing 'prompt' or 'model' in request"}), 400
+    if not prompt:
+        return jsonify({"error": "Missing 'prompt' in request"}), 400
+    if not model:
+        return jsonify({"error": "Missing 'model' in request"}), 400
+
+    # Assuming ai.chat is a function that takes prompt and model as arguments
+    res = ai.chat(prompt=prompt, model=model)
+
+    # Return the response as JSON
+    return jsonify({"response": res}), 200
 
-    try:
-        # Send the chat request to the Ollama client
-        res = ai.chat(prompt=data.get("prompt"), model=data.get("model"))
-        return jsonify(res), 200
-    except Exception as e:
-        print(f"[LOG] ERROR: {e}")
-        return jsonify({"error": "Failed to process chat request"}), 500
 
 if __name__ == "__main__":
-    app.run()  
+    app.run(debug=True)  # Set debug=True for development

ollamaClient.py

@@ -1,82 +1,105 @@
 import requests
 import json
 
-ollama_serve = "http://localhost:11434"
-collection_of_apis = {
+# Constants
+OLLAMA_SERVER = "http://localhost:11434"
+API_ENDPOINTS = {
     "list-models": "/api/tags",
     "list-active-models": "/api/ps",
     "chat": "/api/chat",
 }
 
-def get_data(url):
-    try:
-        res = requests.get(url, timeout=5)
-        data = res.json()
-    except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
-        print("[LOG] ERROR  : UNABLE TO CONNECT TO SERVER")
-        data = {}
-
-    return data
 
-def post_data(url, data):
-    headers = {'Content-Type': 'application/json'}
+# Helper functions
+def fetch_data(url):
+    """Fetch data from a given URL using a GET request."""
     try:
-        res = requests.post(url, json=data, headers=headers,stream=True)
-        content = res.text  # parse response as JSON
-    except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
-        print("[LOG] ERROR : UNABLE TO CONNECT TO SERVER")
-        content = {}
-
-    return content
-
+        response = requests.get(url, timeout=5)
+        response.raise_for_status()  # Raise an exception for HTTP errors
+        return response.json()
+    except (requests.exceptions.ConnectionError, requests.exceptions.Timeout) as e:
+        print(f"[LOG] ERROR: Unable to connect to server - {e}")
+        return {}
+    except requests.exceptions.RequestException as e:
+        print(f"[LOG] ERROR: Request failed - {e}")
+        return {}
+
+
+def send_data(url, data):
+    """Send data to a given URL using a POST request."""
+    headers = {"Content-Type": "application/json"}
+    try:
+        response = requests.post(url, json=data, headers=headers, stream=True)
+        response.raise_for_status()  # Raise an exception for HTTP errors
+        return response.text  # Return text instead of raw content
+    except (requests.exceptions.ConnectionError, requests.exceptions.Timeout) as e:
+        print(f"[LOG] ERROR: Unable to connect to server - {e}")
+        return ""
+    except requests.exceptions.RequestException as e:
+        print(f"[LOG] ERROR: Request failed - {e}")
+        return ""
+
+
+# Ollama Client Class
 class OllamaClient:
-
     @staticmethod
-    def listModels():
-        data = get_data(ollama_serve + collection_of_apis.get("list-models"))
-
-        if data == {}:
+    def list_models():
+        """Fetch and return a list of available models."""
+        data = fetch_data(OLLAMA_SERVER + API_ENDPOINTS["list-models"])
+        if not data:
             return []
 
-        filter_data = data.get('models')   # should be 'models' not 'model'
-
-        results = []
-        for item in filter_data:
-            results.append({"name": item.get("name"), "model": item.get("model")})
-
-        return results
+        models = data.get("models", [])
+        return [
+            {"name": item.get("name", ""), "model": item.get("model", "")}
+            for item in models
+        ]
 
     @staticmethod
-    def listActiveModels():
-        data = get_data(ollama_serve + collection_of_apis.get("list-active-models"))
-
-        if data=={}:
+    def list_active_models():
+        """Fetch and return a list of active models."""
+        data = fetch_data(OLLAMA_SERVER + API_ENDPOINTS["list-active-models"])
+        if not data:
             return []
 
-        filter_data = data.get("models")  # should be 'models' not 'model'
-
-        results = []
-        for item in filter_data:
-            results.append({"name": item.get("name"), "model": item.get("model")})
-
-        return results
+        models = data.get("models", [])
+        return [
+            {"name": item.get("name", ""), "model": item.get("model", "")}
+            for item in models
+        ]
 
     @staticmethod
     def chat(model, prompt):
+        """Send a chat prompt to a specified model and return the response."""
         data = {
             "model": model,
             "messages": [{"role": "user", "content": prompt}],
         }
 
-        res = post_data(ollama_serve + collection_of_apis.get("chat"), data)
-        # return res
-        lines = res.split('\n')[:-1]
-        parsed_json = []
-        for line in lines:
-            parsed_json.append(json.loads(line))
-
-        results=[]
-        for item in parsed_json:
-            results.append(item["message"]["content"])
-
-        return "".join(results)
+        response_text = send_data(OLLAMA_SERVER + API_ENDPOINTS["chat"], data)
+        if not response_text:
+            return ""
+
+        # Parse the response (assuming it's a stream of JSON objects)
+        parsed_lines = []
+        for line in response_text.split("\n"):
+            if line.strip():
+                try:
+                    parsed_lines.append(json.loads(line))
+                except json.JSONDecodeError as e:
+                    print(f"[LOG] ERROR: Failed to parse JSON - {e}")
+
+        # Extract the message contents
+        response_messages = [
+            item.get("message", {}).get("content", "")
+            for item in parsed_lines
+            if "message" in item
+        ]
+
+        response_str = "".join(response_messages)
+
+        print(
+            f"[LOG] INCOMING DATA:\nmodel: {model}\nprompt: {prompt}\nOUTGOING:\nResponse: {response_str}"
+        )
+
+        return response_str