Update app.py

app.py

@@ -1,20 +1,34 @@
-import google.generativeai as generativeai
-from flask import Flask, request, jsonify, render_template, send_file
-from google.genai import types
-from PIL import Image
-from io import BytesIO
-from google import genai
 import os
+from openai import OpenAI
+from flask import Flask, request, jsonify, render_template, send_file
+
 
-CHAT_API_KEY = os.getenv("CHAT_APIKEY")
-IMAGINE_API_KEY = os.getenv("IMAGE_API_KEY")
-secret_text = os.getenv("secret_text")
-#Connect to index.html
 app = Flask(__name__)
 
+client = OpenAI(
+    base_url="https://router.huggingface.co/v1",
+    api_key=os.environ["HF_TOKEN"],
+)
+
+app = Flask(__name__)
+@app.route("/")
+def index():
+    return render_template("index.html")
 
 @app.route("/write", methods=["GET", "POST"])
 def write():
+
+    WRITE_PROMPT = """
+You are TaskBot AI created by Advay Singh.
+
+Task:
+Write high-quality content based on the user's request.
+
+Rules:
+- Output only the requested content.
+- Do not say "Here is your essay/speech".
+- Do not chat with the user.
+"""
     if request.method == "GET":
         return render_template("write.html")
 
@@ -24,8 +38,6 @@ def write():
         types = request.form.get("type", "").strip()
         word_limit = request.form.get("word_limit", "").strip()
 
-        print(f"\nRAW FORM DATA -> question: '{question}', type: '{types}', word_limit: '{word_limit}'\n-------------------------------\n")
-
         if not question:
             return jsonify({"error": "Please provide a question."}), 400
 
@@ -37,27 +49,44 @@ def write():
         else:
             word_limit = None
 
-        generativeai.configure(api_key=CHAT_API_KEY)
-
         try:
-            model = generativeai.GenerativeModel("gemini-2.0-flash")
-            prompt = (
-                f"You are TaskBot AI created by Advay Singh and powered by Gemini AI. "
-                f"Write a {types if types else 'paragraph'} on the topic '{question}'"
-            )
-            if word_limit:
-                prompt += f" nearly about {word_limit} words."
-
-            response = model.generate_content(prompt)
-            print(f"ANSWER BY TASKBOT AI: \n {response.text}")
-            return jsonify({"answer": response.text})
-                
+            completion = client.chat.completions.create(
+            model="Qwen/Qwen2.5-7B-Instruct:together",
+            messages=[
+    {
+        "role": "system",
+        "content": WRITE_PROMPT
+        },
+            {
+            "role": "user",
+            "content": f"Write a {types if types else 'paragraph'} on the topic '{question} in about {word_limit} words.'"
+            }
+        ],
+    )
+
+            response = completion.choices[0].message.content
+            print(f"WRITE ABOUT: \n{question} in {types} in minimum {word_limit}\n------------------------- \n AI RESPONSE: {response} \n--------------------------")
+            return jsonify({"answer": response})
+        
         except Exception as e:
             print(f"Error: {e}")
             return jsonify({"error": "An error occurred while processing your request."}), 500
 
+
+
 @app.route("/summarize", methods=["GET", "POST"])
 def summarize():
+    SUMMARIZE_PROMPT = """
+You are TaskBot AI created by Advay Singh.
+
+Task:
+Summarize the given text.
+
+Rules:
+- Output ONLY the summary.
+- Do not add introductions like "Here is the summary".
+- Do not chat with the user.
+"""
     if request.method == "GET":
         return render_template("summarize.html")
     if request.method == "POST":
@@ -67,55 +96,47 @@ def summarize():
     if not question:
         return jsonify({"error": "Please provide a question."}), 400
 
-    generativeai.configure(api_key=CHAT_API_KEY)
-
     try:
 
-        model = generativeai.GenerativeModel('gemini-2.0-flash')
-        prompt = (
-            f"You are TaskBot AI created by Advay Singh and powered by Gemini AI. "
-            f"Write a {types if types else 'paragraph'} on the topic '{question}'")
-        if minimum_lines_points:
-            prompt += f" nearly about {minimum_lines_points} {types}."
-        response = model.generate_content(prompt)
-        answer = response.text
+        completion = client.chat.completions.create(
+            model="Qwen/Qwen2.5-7B-Instruct:together",
+            messages=[
+    {
+        "role": "system",
+        "content": SUMMARIZE_PROMPT
+        },
+            {
+            "role": "user",
+            "content": f"Summarize: \n '{question}' nearly about {minimum_lines_points if minimum_lines_points else 5} {types}."
+            }
+        ],
+    )
+
 
-        print(f"Raw Text: \n{question};  Type: {types}; Minimum {types}: {minimum_lines_points}\n------------------------- \n {answer} \n -------------------------")
+        response = completion.choices[0].message.content
+        
+        print(f"SUMMARIZE: \n{question} in {types} in minimum {minimum_lines_points} {types}\n------------------------- \n AI RESPONSE: {response} \n--------------------------")
+
+        return jsonify({"answer": response})
 
-        return jsonify({"answer": answer})
     except Exception as e:
         print(f"Error: {e}")
         return jsonify({"error": "An error occurred while processing your request."}), 500
-    
-
-@app.route("/think", methods=["GET", "POST"])
-def think():
-    if request.method == "GET":
-        return render_template("think.html")
-    if request.method == "POST":
-
-        question = request.form.get("question", "").strip()
-        if not question:
-            return jsonify({"error": "Please provide a question."}), 400
-
-        generativeai.configure(api_key=CHAT_API_KEY)
-
-        try:
-            model = generativeai.GenerativeModel('gemini-2.0-flash-thinking-exp-01-21')
-            response = model.generate_content(f"{secret_text} {question}.")
-            answer = response.text
-
-
-            print(f"Question: {question}\n------------------------- \n {answer} \n -------------------------\n")
-
-            return jsonify({"answer": answer})
-        except Exception as e:
-            print(f"Error: {e}")
-            return jsonify({"error": "An error occurred while processing your request."}), 500
 
 
 @app.route("/translate", methods=["GET", "POST"])
 def translate():
+    TRANSLATE_PROMPT = """
+You are TaskBot AI created by Advay Singh.
+
+Task:
+Translate the given text to the requested language.
+
+Rules:
+- Output ONLY the translated text.
+- Do not add explanations.
+- Do not say "Here is the translation" or something else like that, just give the answer directly.
+"""
     if request.method == "GET":
         return render_template("translate.html")
     if request.method == "POST":
@@ -124,80 +145,67 @@ def translate():
         translate_to = request.form.get("translate_to", "").strip()
         if not question:
             return jsonify({"error": "Please provide a question."}), 400
-
-        generativeai.configure(api_key=CHAT_API_KEY)
-
+        
         try:
 
-            model = generativeai.GenerativeModel('gemini-2.0-flash')
-            response = model.generate_content(f"You are TaskBot AI created by Advay Singh and powered by Gemini AI remember this and don't say  anything about this unitll asked (not even ok). Just translate {question} from {translate_from} to {translate_to} and nothing else.  ")
-            answer = response.text
+            completion = client.chat.completions.create(
+            model="Qwen/Qwen2.5-7B-Instruct:together",
+            messages=[
+        {
+        "role": "system",
+        "content": TRANSLATE_PROMPT
+        },
+            {
+            "role": "user",
+            "content": f"translate {question} from {translate_from} to {translate_to}."
+            }
+        ],
+    )
 
-            print(f"Translate: {question} from {translate_from} to {translate_to}\n------------------------- \n {answer} \n--------------------------")
+            response = completion.choices[0].message.content
+            print(f"Translate: {question} from {translate_from} to {translate_to}\n------------------------- \n AI RESPONSE: {response} \n--------------------------")
+
+            return jsonify({"answer": response})
 
-            return jsonify({"answer": answer})
         except Exception as e:
             print(f"Error: {e}")
             return jsonify({"error": "An error occurred while processing your request."}), 500
 
-@app.route("/imagine", methods=["GET", "POST"])
-def imagine():
-    if request.method == "GET":
-        return render_template("imagine.html")
-    if request.method == "POST":
-        contents = request.form.get("contents", "").strip()
-    if not contents:
-        return jsonify({"error": "Please provide a prompt."}), 400
-    
-    client = genai.Client(api_key=IMAGINE_API_KEY)
-
-    response = client.models.generate_content(
-        model="gemini-2.0-flash-preview-image-generation",
-        contents=contents,
-        config=types.GenerateContentConfig(
-          response_modalities=['TEXT', 'IMAGE']
-        )
-    )
-    print(f"\nPROMPT: {contents}\n")
-    for part in response.candidates[0].content.parts:
-        if part.inline_data is not None:
-            image = Image.open(BytesIO(part.inline_data.data))
-            img_io = BytesIO()
-            image.save(img_io, format="PNG")
-            img_io.seek(0)
-            return send_file(img_io, mimetype="image/png")
-
-    return jsonify({"error": "No image returned by model"}), 500
-
-
-@app.route("/")
-def index():
-    return render_template("index.html")
 
 @app.route("/ask", methods=["POST"])
 def ask():
-    #getting the question from the form55
+    CHAT_PROMPT = """
+You are TaskBot AI created by Advay Singh.
+
+Respond normally and conversationally.
+Never mention the underlying AI model.
+"""
     question = request.form.get("question", "").strip()
     if not question:
         return jsonify({"error": "Please provide a question."}), 400
 
-    generativeai.configure(api_key=CHAT_API_KEY)
-
     try:
-        # use Google's Gemini-2.0-Flash nodle for generating content
-        model = generativeai.GenerativeModel('gemini-2.0-flash')
-        response = model.generate_content(f"You are TaskBot AI created by Advay Singh and powered by Gemini AI. Remember that and don't say anything (not even ok) about that just answer me this question- {question}.")
-        answer = response.text
-
-        # Log the question and answer for debugging
-        print(f"Question: {question}\n------------------------- \n {answer} \n -------------------------")
-        # Return the answer as JSON
-        return jsonify({"answer": answer})
+        completion = client.chat.completions.create(
+            model="Qwen/Qwen2.5-7B-Instruct:together",
+            messages=[
+        {
+        "role": "system",
+        "content": CHAT_PROMPT
+        },
+            {
+            "role": "user",
+            "content": f"{question}"
+            }
+        ],
+    )
+
+        response = completion.choices[0].message.content
+        print(f"QUESTION: \n{question} \n-------------------------------- AI RESPONSE: \n{response} \n --------------------------------")
+        return jsonify({"answer": response})
     except Exception as e:
         print(f"Error: {e}")
         return jsonify({"error": "An error occurred while processing your request."}), 500
 
 if __name__ == '__main__':
 
-        app.run(host="0.0.0.0", port=7860)
-        
+        app.run(host="0.0.0.0", port=7860)