Update backend/app.py

backend/app.py

@@ -1,145 +1,40 @@
-from flask import Flask, request, Response, jsonify
+from flask import Flask, request, jsonify
 from flask_cors import CORS
 from PIL import Image
 import torch
 from transformers import AutoProcessor, BlipForConditionalGeneration
-from llama_cpp import Llama
-import json
-from tavily import TavilyClient
-import os
-from dotenv import load_dotenv
-
-load_dotenv()
-
-TAVILY_API_KEY = os.getenv("TAVILY_API_KEY")
 
 app = Flask(__name__)
-CORS(app, resources={
-    r"/*": {"origins": "*"} # Use a more permissive CORS for cloud deployment
-})
-
+CORS(app, resources={r"/*": {"origins": "*"}})
 device = "cuda" if torch.cuda.is_available() else "cpu"
-vision_processor, vision_model, llm, tavily_client = None, None, None, None
-
-# --- Load Models ---
-print("--- F-P-U-I --- Attempting to load models...")
+vision_processor, vision_model = None, None
 
 try:
     vision_processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-large")
     vision_model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-large").to(device)
-    print("BLIP Vision model loaded successfully.")
-except Exception as e:
-    print(f"Error loading Vision model: {e}")
-
-try:
-    llm = Llama.from_pretrained(
-        repo_id="ranggafermata/Effort-1",
-        filename="EffortQ43B.gguf",
-        n_ctx=2048,
-        n_gpu_layers=-1,
-        verbose=False,
-        chat_format="llama-3"
-    )
-    print("--- F-P-U-I --- Effort-1 text model loaded successfully.")
+    print("--- VISION SERVICE --- BLIP Vision model loaded successfully.")
 except Exception as e:
-    print(f"--- F-P-U-I --- CRITICAL ERROR loading Effort-1 model: {e}")
-
-try:
-    tavily_client = TavilyClient(api_key=TAVILY_API_KEY)
-    print("--- F-P-U-I --- Tavily client initialized successfully.")
-except Exception as e:
-    print(f"--- F-P-U-I --- CRITICAL ERROR initializing Tavily client: {e}")
-
-@app.route("/research", methods=["POST"])
-def research():
-
-    global tavily_client
-
-    if not tavily_client:
-        return jsonify({"error": "Tavily client not available"}), 500
-
-    data = request.get_json()
-    task = data.get("task")
-    query = data.get("query")
+    print(f"--- VISION SERVICE --- CRITICAL ERROR loading Vision model: {e}")
 
-    if not task or not query:
-        return jsonify({"error": "Missing task or query"}), 400
-
-    try:
-        if task == 'search':
-            results = tavily_client.search(query=query, search_depth="advanced")
-        elif task == 'extract':
-            results = tavily_client.extract(urls=[query])
-        else:
-            return jsonify({"error": "Invalid task"}), 400
-        
-        return jsonify(results)
-
-    except Exception as e:
-        print(f"Error during Tavily research: {e}")
-
-        return jsonify({"error": str(e)}), 500
-        
-
-# --- Main Endpoint ---
-@app.route("/completion", methods=["POST"])
-def completion():
-    global llm, vision_model, vision_processor # Declare usage of globals
+@app.route("/describe_image", methods=["POST"])
+def describe_image():
+    if not vision_model:
+        return jsonify({"error": "Vision model not available."}), 500
     
-    prompt = request.form.get("prompt", "")
-    history_json = request.form.get("history", "[]")
+    user_prompt = request.form.get("prompt", "")
     image_file = request.files.get("image")
-    model_choice = request.form.get("model_choice", "effort-1")
-    
-
-    pil_image = None
-    if image_file:
-        try:
-            pil_image = Image.open(image_file.stream).convert("RGB")
-        except Exception as e:
-            print(f"Error opening image file: {e}")
+    if not image_file:
+        return jsonify({"error": "No image file found."}), 400
 
     try:
-        chat_history = json.loads(history_json)
-    except json.JSONDecodeError:
-        chat_history = []
-
-    def generate_stream(user_prompt, image_obj, history, choice):
-        if image_obj:
-            if vision_model and vision_processor:
-                try:
-                    inputs = (vision_processor(images=image_obj, text=user_prompt, return_tensors="pt").to(device) if user_prompt else vision_processor(images=image_obj, return_tensors="pt").to(device))
-                    output = vision_model.generate(**inputs, max_new_tokens=50)
-                    caption = vision_processor.decode(output[0], skip_special_tokens=True).strip()
-                    yield f"data: {json.dumps({'content': caption})}\n\n"
-                except Exception as e:
-                    print(f"Error processing image: {e}")
-                    yield f"data: {json.dumps({'content': 'Sorry, I had trouble reading that image.'})}\n\n"
-            else:
-                yield f"data: {json.dumps({'content': 'Vision model not available.'})}\n\n"
-        
-        else:
-            # --- Text Path ---
-
-            if llm:
-                try:
-                    system_message = {"role": "system", "content": "You are a helpful and brilliant AI assistant named Effort."}
-                    messages = [system_message] + history + [{"role": "user", "content": user_prompt}]
-                    
-                    print(f"Sending {len(messages)} messages to the Effort-1 model.")
-
-                    stream = llm.create_chat_completion(messages=messages, max_tokens=1024, temperature=0.7, stream=True)
-                    for output in stream:
-                        token = output["choices"][0]["delta"].get("content", "")
-                        if token:
-                            yield f"data: {json.dumps({'content': token})}\n\n"
-                except Exception as e:
-                    print(f"Error during text generation: {e}")
-                    yield f"data: {json.dumps({'content': 'I encountered an error.'})}\n\n"
-            else:
-                yield f"data: {json.dumps({'content': 'Requested text model not available.'})}\n\n"
-
-    return Response(generate_stream(prompt, pil_image, chat_history, model_choice), mimetype="text-event-stream")
+        image_obj = Image.open(image_file.stream).convert("RGB")
+        inputs = (vision_processor(images=image_obj, text=user_prompt, return_tensors="pt").to(device) if user_prompt else vision_processor(images=image_obj, return_tensors="pt").to(device))
+        output = vision_model.generate(**inputs, max_new_tokens=50)
+        caption = vision_processor.decode(output[0], skip_special_tokens=True).strip()
+        return jsonify({"content": caption})
+    except Exception as e:
+        print(f"Error processing image: {e}")
+        return jsonify({"error": "Sorry, I had trouble processing that image."}), 500
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=8080)
+    app.run(host="0.0.0.0", port=8081) # Use a different port for local testing