add chat

chat.py

@@ -0,0 +1,226 @@
+from flask import Flask, jsonify, send_file, abort, make_response, request, Blueprint, current_app
+from flask_cors import CORS
+import os
+print(f"GOOGLE_APPLICATION_CREDENTIALS: {os.getenv('GOOGLE_APPLICATION_CREDENTIALS')}")
+import io
+import uuid
+import requests
+import re 
+import tempfile  # needed by validate-pronounce
+
+app = Flask(__name__)
+CORS(app)
+
+# 👇 Add the helper right here
+def _cohere_headers():
+    api_key = current_app.config.get("COHERE_API_KEY") or COHERE_API_KEY
+    return {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+    
+@app.route('/')
+def home():
+    return "Welcome to the Flask app! The server is running."
+
+# API configuration for AI-based question generation
+# COHERE_API_KEY = 'WjnDKknACe0zxHvczdo7q4vwF4WAXn2429hcPHIB'
+COHERE_API_KEY = os.getenv("COHERE_API_KEY", "")
+COHERE_API_URL = 'https://api.cohere.ai/v1/generate'
+
+
+
+# Dictionary to store user conversations
+user_sessions = {}
+# Endpoint to explain grammar topics
+movie_bp = Blueprint("movie", __name__)
+
+def _cohere_generate(prompt: str, max_tokens: int = 1000, temperature: float = 0.7):
+    api_key = current_app.config.get("COHERE_API_KEY") or COHERE_API_KEY
+    if not api_key:
+        return None, ("COHERE_API_KEY not set on the server", 500)
+
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {"model": "command-r-08-2024", "prompt": prompt, "max_tokens": max_tokens, "temperature": temperature}
+    try:
+        r = requests.post(COHERE_API_URL, headers=headers, json=payload, timeout=30)
+        if r.status_code != 200:
+            return None, (f"Cohere API error: {r.text}", 502)
+        text = r.json().get("generations", [{}])[0].get("text", "").strip()
+        return text, None
+    except Exception as e:
+        current_app.logger.exception("Cohere request failed: %s", e)
+        return None, ("Upstream request failed", 502)
+
+@movie_bp.post("/explain-grammar")
+def explain_grammar():
+    try:
+        data = request.get_json()
+        print("Received Data:", data) 
+        topic = data.get('topic', '').strip()
+        session_id = data.get('session_id', str(uuid.uuid4()))  # Use provided session_id or create a new one
+
+        if not topic:
+            return jsonify({'error': 'Topic is required'}), 400
+
+        # Retrieve previous conversation history
+        conversation_history = user_sessions.get(session_id, [])
+
+        # Keep the last 10 messages to maintain better context (adjustable)
+        if len(conversation_history) > 10:
+            conversation_history = conversation_history[-10:]
+
+        # Generate a more **adaptive** prompt
+        context = "\n".join(conversation_history) if conversation_history else ""
+
+        prompt = f"""
+        You are a highly skilled grammar assistant. Your job is to maintain a **dynamic conversation** and respond intelligently based on user input, If the user asks something **unrelated to grammar**, respond with: "Please send a grammar-related question..
+
+        - Your answers must always **relate to the conversation history** and **extend naturally** based on what was previously asked.
+        - Your answers must be **concise, clear, and to the point**
+        - If the user asks for **examples**, explanations, or clarifications, **automatically infer** which topic they are referring to.
+        - If the user's question is **vague**, determine the most **logical continuation** based on prior questions.
+        - If the user asks something **unrelated to grammar**, respond with: "Please send a grammar-related question."
+
+        **Conversation so far:**
+        {context}
+
+        **User's new question:** {topic}
+        Please provide a **coherent and relevant answer** that continues the conversation naturally.
+        """
+
+        # Make the API call to Cohere
+        headers = {
+            'Authorization': f'Bearer {COHERE_API_KEY}',
+            'Content-Type': 'application/json'
+        }
+
+        payload = {
+            'model': 'command-r-08-2024',
+            'prompt': prompt,
+            'max_tokens': 1000  # Increased to allow better explanations
+        }
+
+        response = requests.post(COHERE_API_URL, headers=headers, json=payload)
+
+        if response.status_code == 200:
+            ai_response = response.json().get('generations', [{}])[0].get('text', '').strip()
+
+            # Store conversation history to maintain context
+            conversation_history.append(f"User: {topic}\nAI: {ai_response}")
+            user_sessions[session_id] = conversation_history  # Update session history
+
+            return jsonify({'response': ai_response, 'session_id': session_id})
+        else:
+            return jsonify({'error': 'Failed to fetch data from Cohere API'}), 500
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+
+@app.route('/suggest-grammar-questions', methods=['POST'])
+def suggest_grammar_questions():
+    try:
+        data = request.get_json()
+        user_input = data.get('input', '').strip()  # User's partial input (e.g., "What is v")
+
+        if not user_input:
+            return jsonify({'error': 'Input is required'}), 400
+
+        
+
+        prompt = f"""
+			You are a grammar expert. Given the user's input "{user_input}", generate **3 natural grammar-related questions** that people might ask.
+
+			- The user's input is a **partial or full grammar-related query**.
+			- AI must **infer the most likely grammar topic** based on the input.
+			- AI must **ensure all suggestions are strictly related to English grammar**.
+			- **If the input is incomplete, intelligently complete it** with the most likely grammar concept.
+			- Ensure all **questions are fully formed and relevant**.
+
+			**User input:** "{user_input}"
+			Provide exactly 3 well-structured, grammar-related questions:
+			"""
+
+        # Call Cohere API
+        headers = {
+            'Authorization': f'Bearer {COHERE_API_KEY}',
+            'Content-Type': 'application/json'
+        }
+
+        payload = {
+            'model': 'command-r-08-2024',
+            'prompt': prompt,
+            'max_tokens': 100,  # Only short responses needed
+            'temperature': 0.9,  # Some randomness for variety
+            'frequency_penalty': 0.8,  # Reduce repeated words
+            'presence_penalty': 0.8  # Encourage diverse questions
+        }
+
+        response = requests.post(COHERE_API_URL, headers=headers, json=payload)
+
+        if response.status_code == 200:
+            suggestions = response.json().get('generations', [{}])[0].get('text', '').strip().split("\n")
+            return jsonify({'suggestions': suggestions})
+        else:
+            return jsonify({'error': 'Failed to fetch suggestions', 'details': response.text}), 500
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+def validate_topic(topic):
+
+
+
+    validation_prompt = f"""
+    You are an AI grammar expert. Your task is to determine if a given topic is related to **English grammar** or not.
+
+    **Input:** "{topic}"
+
+    ### **Rules:**
+    - If the input is **in the form of a question** (e.g., it asks for an explanation or definition), return `"ask grammar topics"`, even if the topic is related to grammar.
+    - If the topic is **related to English grammar concepts** such as **parts of speech**, **verb tenses**, **sentence structure**, etc., return `"Grammar"`.
+    - If the topic is **not related to grammar**, such as general knowledge, science, math, history, or topics from other fields, return `"Not Grammar"`.
+    - Your response must be based purely on whether the topic relates to grammar, and **not** based on specific words, phrases, or examples.
+
+    **Your response must be exactly either "Grammar", "Not Grammar", or "ask grammar topics". No extra text.**
+    """
+
+
+    
+
+
+    headers = {
+        'Authorization': f'Bearer {COHERE_API_KEY}',
+        'Content-Type': 'application/json'
+    }
+
+    payload = {
+        'model': 'command-r-08-2024',
+        'prompt': validation_prompt,
+        'max_tokens': 5  # Minimal token usage for classification
+    }
+
+    try:
+        response = requests.post(COHERE_API_URL, json=payload, headers=headers)
+        validation_result = response.json().get('generations', [{}])[0].get('text', '').strip()
+        
+        # Ensure the response is strictly "Grammar" or "Not Grammar"
+        if validation_result not in ["Grammar", "Not Grammar"]:
+            return "Not Grammar"  # Fallback to avoid incorrect responses
+
+        return validation_result
+
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+
+
+
+if __name__ == '__main__':
+    # app.run(debug=True)
+    app.register_blueprint(movie_bp, url_prefix='')  # expose /explain-grammar locally
+    app.run(host='0.0.0.0', port=5012, debug=True)

test_moviepy.py

@@ -1,1021 +0,0 @@
-from flask import Flask, jsonify, send_file, abort, make_response, request, Blueprint, current_app
-from flask_cors import CORS
-from moviepy.editor import VideoFileClip
-from google.cloud import speech
-import os
-print(f"GOOGLE_APPLICATION_CREDENTIALS: {os.getenv('GOOGLE_APPLICATION_CREDENTIALS')}")
-import io
-import uuid
-import requests
-from pydub import AudioSegment
-import ffmpeg
-import re 
-import tempfile  # needed by validate-pronounce
-
-app = Flask(__name__)
-CORS(app)
-
-# 👇 Add the helper right here
-def _cohere_headers():
-    api_key = current_app.config.get("COHERE_API_KEY") or COHERE_API_KEY
-    return {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json",
-    }
-    
-@app.route('/')
-def home():
-    return "Welcome to the Flask app! The server is running."
-
-# Directories for video, audio, and transcripts
-VIDEO_FOLDER = 'static/videos'
-AUDIO_FOLDER = 'static/audio'
-TRANSCRIPT_FOLDER = 'static/transcripts'
-
-# Ensure directories exist
-os.makedirs(VIDEO_FOLDER, exist_ok=True)
-os.makedirs(AUDIO_FOLDER, exist_ok=True)
-os.makedirs(TRANSCRIPT_FOLDER, exist_ok=True)
-
-# API configuration for AI-based question generation
-# COHERE_API_KEY = 'WjnDKknACe0zxHvczdo7q4vwF4WAXn2429hcPHIB'
-COHERE_API_KEY = os.getenv("COHERE_API_KEY", "")
-COHERE_API_URL = 'https://api.cohere.ai/v1/generate'
-
-# Google Cloud Speech-to-Text Configuration
-speech_client = speech.SpeechClient()
-
-# Predefined video metadata
-# VIDEOS = [
-#     {
-#         "id": "1",
-#         "title": "Introduction to AI",
-#         "filename": "ai_intro.mp4"
-#     },
-#     {
-#         "id": "2",
-#         "title": "Machine Learning Basics",
-#         "filename": "ml_basics.mp4"
-#     }
-# ]
-
-
-
-@app.route('/videos', methods=['GET'])
-def list_videos():
-    """
-    List available videos for users to watch.
-    """
-    return jsonify(VIDEOS), 200
-
-@app.route('/videos/<filename>')
-def serve_video(filename):
-    """
-    Serve a video file to the user.
-    """
-    video_path = os.path.join(VIDEO_FOLDER, filename)
-    if not os.path.exists(video_path):
-        print(f"Video file not found: {filename}")
-        abort(404)
-
-    mime_type = 'video/mp4'
-    print(f"Serving video: {filename}, MIME type: {mime_type}")
-    return send_file(video_path, mimetype=mime_type)
-
-
-# Convert video to audio
-def convert_video_to_audio(video_path, audio_path):
-    try:
-        # Using moviepy to extract audio from video
-        video = VideoFileClip(video_path)
-        video.audio.write_audiofile(audio_path, codec='mp3')
-        return audio_path
-    except Exception as e:
-        print(f"Error converting video to audio: {str(e)}")
-        return None
-
-# Re-encode MP3 to ensure proper format
-def reencode_mp3(input_audio_path, output_audio_path):
-    try:
-        # Using pydub to convert and re-encode MP3 (ensuring correct encoding)
-        audio = AudioSegment.from_mp3(input_audio_path)
-        audio.export(output_audio_path, format="mp3", codec="libmp3lame", parameters=["-q:a", "0"])
-        return output_audio_path
-    except Exception as e:
-        print(f"Error re-encoding MP3: {str(e)}")
-        return None
-# Helper function to convert audio to the proper MP3 encoding if necessary
-def convert_audio_to_mp3(input_file_path, output_file_path):
-    """
-    Converts the audio file to a valid MP3 format with proper encoding.
-    """
-    try:
-        ffmpeg.input(input_file_path).output(output_file_path, acodec='libmp3lame', audio_bitrate='128k').run()
-        return True
-    except Exception as e:
-        print(f"Error during audio conversion: {e}")
-        return False
-
-
-# Function to compress audio dynamically
-def compress_audio(input_file_path, output_file_path, target_bitrate="128k"):
-    audio = AudioSegment.from_file(input_file_path)
-    audio.export(output_file_path, format="mp3", bitrate=target_bitrate)
-    return output_file_path
-
-
-@app.route('/upload-video', methods=['POST'])
-def upload_video():
-    print("Received upload request.")
-
-    if 'video' not in request.files:
-        print("No video file provided in the request.")
-        return jsonify({'error': 'No video file provided'}), 400
-
-    video = request.files['video']
-    if video.filename == '':
-        print("Empty filename detected.")
-        return jsonify({'error': 'No selected file'}), 400
-
-    try:
-        filename = str(uuid.uuid4()) + ".mp4"
-        video_path = os.path.join(VIDEO_FOLDER, filename)
-
-        print(f"Saving video: {filename}")
-        video.save(video_path)
-
-        print(f"Video saved successfully at {video_path}")
-        return jsonify({'message': 'Video uploaded successfully!', 'filename': filename}), 200
-
-    except Exception as e:
-        print(f"Error saving video: {str(e)}")
-        return jsonify({'error': 'Failed to save video'}), 500
-
-
-
-
-@app.route('/generate-questions-dynamicvideo', methods=['POST'])
-def generate_questions():
-    try:
-        # Expecting a JSON request body with video filename
-        data = request.json
-        video_filename = data.get('filename')
-
-        if not video_filename:
-            print("Error: No filename provided in request.")
-            return jsonify({"error": "Filename is required"}), 400
-
-        video_path = os.path.join(VIDEO_FOLDER, video_filename)
-        if not os.path.exists(video_path):
-            print(f"Error: Video file {video_filename} not found at {video_path}")
-            return jsonify({"error": "Video file not found"}), 404
-
-        print(f"Processing video: {video_filename}")
-
-        # Convert video to audio
-        audio_filename = f"{uuid.uuid4()}.mp3"
-        audio_path = os.path.join(AUDIO_FOLDER, audio_filename)
-        
-        # Convert video to audio
-        if not convert_video_to_audio(video_path, audio_path):
-            print("Error: Video to audio conversion failed.")
-            return jsonify({"error": "Failed to convert video to audio"}), 500
-
-        # Transcribe audio using Google Cloud Speech-to-Text
-        with open(audio_path, 'rb') as audio_file:
-            audio_content = audio_file.read()
-
-        audio = speech.RecognitionAudio(content=audio_content)
-        config = speech.RecognitionConfig(
-            encoding=speech.RecognitionConfig.AudioEncoding.MP3,
-            sample_rate_hertz=16000,
-            language_code="en-US",
-        )
-
-        response = speech_client.recognize(config=config, audio=audio)
-        transcripts = [result.alternatives[0].transcript for result in response.results]
-
-        if not transcripts:
-            print("Error: No transcription results found.")
-            return jsonify({"error": "No transcription results found"}), 500
-
-        transcription_text = " ".join(transcripts)
-        print(f"Transcription successful: {transcription_text[:200]}...")  # Print first 200 chars
-
-        
-
-        cohere_payload = {
-            "model": "command-r-08-2024",
-            "prompt": f"Generate exactly three multiple-choice questions based on this text:\n{transcription_text}\n"
-                      f"Each question should start with a number followed by a period (e.g., 1.) and should have four options labeled A., B., C., and D. After the options, indicate the correct answer with 'Correct answer: <option letter>' (e.g., Correct answer: A).\n"
-                      f"Please make sure to generate exactly four options per question, and only three questions in total.",
-            "max_tokens": 300,
-            "temperature": 0.9,  # Optional: Control randomness in the responses
-}
-
-        headers = _cohere_headers()
-
-        cohere_response = requests.post(COHERE_API_URL, json=cohere_payload, headers=headers)
-
-        if cohere_response.status_code != 200:
-            print(f"Error: Cohere API response failed: {cohere_response.text}")
-            return jsonify({"error": "Failed to generate questions"}), 500
-
-        questions = cohere_response.json().get("generations", [])
-        if not questions:
-            print("Error: No questions generated from Cohere API.")
-            return jsonify({"error": "No questions generated"}), 500
-
-        # Extract raw text and parse questions
-        raw_text = questions[0]["text"]
-        structured_questions = parse_questions(raw_text)
-
-        return jsonify({"questions": structured_questions}), 200
-
-    except Exception as e:
-        print(f"Critical Error: {e}")
-        return jsonify({"error": "An error occurred while generating questions"}), 500
-
-
-
-
-def parse_questions(response_text):
-    # Split the text into individual question blocks
-    question_blocks = response_text.split("\n\n")
-    questions = []
-
-    # Process each question block
-    for block in question_blocks:
-        print("\nProcessing Block:", block)  # Debug: Log each question block
-
-        # Split the block into lines
-        lines = block.strip().split("\n")
-        print("Split Lines:", lines)  # Debug: Log split lines of the block
-
-        # Ensure the block contains a question
-        if len(lines) < 2:
-            print("Skipping Invalid Block")  # Debug: Log invalid blocks
-            continue
-
-        # Extract the question text
-        question_line = lines[0]
-        question_text = question_line.split(". ", 1)[1] if ". " in question_line else question_line
-        print("Question Text:", question_text)  # Debug: Log extracted question text
-
-        # Extract the options and find the correct answer
-        options = []
-        correct_answer_letter = None
-        for line in lines[1:]:
-            line = line.strip()
-            match = re.match(r"^(?:[a-dA-D][).]?\s)?(.+)$", line)  # Regex to handle `a)`, `A.`, etc.
-            if match:
-                option_text = match.group(1).strip()
-                # Check if this line contains the correct answer
-                if option_text.startswith("Correct answer:"):
-                    correct_answer_letter = option_text.split(":")[-1].strip()
-                else:
-                    options.append(option_text)
-        print("Extracted Options:", options)  # Debug: Log extracted options
-        print("Correct Answer Letter:", correct_answer_letter)  # Debug: Log the correct answer letter
-
-        # Map the correct answer text
-        correct_answer_text = ""
-        if correct_answer_letter:
-            option_index = ord(correct_answer_letter.upper()) - ord('A')  # Convert 'A' to index 0, 'B' to index 1, etc.
-            if 0 <= option_index < len(options):
-                correct_answer_text = options[option_index]
-        print("Mapped Correct Answer Text:", correct_answer_text)  # Debug: Log mapped answer
-
-        # Append the parsed question to the list
-        questions.append({
-            "question": question_text,
-            "options": options,
-            "answer": correct_answer_text  # Use the full answer text
-        })
-
-    print("\nFinal Questions:", questions)  # Debug: Log final parsed questions
-    return questions
-
-
-generated_topics = set()
-
-
-@app.route('/generate-writing-topics', methods=['POST'])
-def generate_writing_topics():
-    """
-    Generate writing topics based on the user's grade level.
-    """
-    try:
-        # Extract grade level from the POST request
-        data = request.json
-        grade_level = data.get("grade_level", "lower").lower()  # Default to 'lower' if not provided
-
-        # Validate grade level
-        valid_levels = {"lower", "middle", "upper"}
-        if grade_level not in valid_levels:
-            return jsonify({"error": f"Invalid grade level. Choose from: {', '.join(valid_levels)}"}), 400
-
-        # Define a prompt based on the grade level
-        if grade_level == "lower":
-            prompt = (
-                "Generate one simple and short writing topic suitable for a lower-grade student. "
-                "The topic should be one sentence, easy to understand, and fun to write about. "
-                "Focus on familiar and relatable themes like family, school, or favorite activities."
-            )
-        elif grade_level == "middle":
-            prompt = (
-                "Generate one creative writing topic suitable for a middle-grade student. "
-                "The topic should encourage imagination and exploration while still being age-appropriate. "
-                "Include themes like adventures, problem-solving, or hypothetical scenarios."
-            )
-        elif grade_level == "upper":
-            prompt = (
-                "Generate one challenging and thought-provoking writing topic suitable for an upper-grade student. "
-                "The topic should require critical thinking, creativity, or self-reflection. "
-                "Include themes like ethical dilemmas, futuristic ideas, or personal experiences."
-            )
-
-        # Call Cohere API to generate topics
-        payload = {
-            "model": "command-r-08-2024",
-            "prompt": prompt,
-            "max_tokens": 150,
-            "temperature": 0.9
-        }
-        headers = _cohere_headers()
-        response = requests.post(COHERE_API_URL, json=payload, headers=headers)
-
-        if response.status_code != 200:
-            return jsonify({"error": "Failed to generate topics"}), 500
-
-        # Extract the generated text
-        raw_text = response.json().get("generations", [])[0].get("text", "")
-        topics = [topic.strip() for topic in raw_text.split("\n") if topic.strip()]
-
-        # Return the generated topics
-        return jsonify({"topics": topics}), 200
-
-    except Exception as e:
-        print(f"Error generating writing topics: {e}")
-        return jsonify({"error": "An error occurred while generating topics"}), 500
-
-
-
-
-@app.route('/validate-response', methods=['POST'])
-def validate_response():
-    """
-    Validate user response against the provided topic using AI.
-    """
-    try:
-        # Extract user input and topic from the request
-        data = request.json
-        topic = data.get("topic")
-        response = data.get("response")
-
-        if not topic or not response:
-            return jsonify({"error": "Both 'topic' and 'response' fields are required."}), 400
-
-        # Define a prompt for validation
-        # prompt = (
-        #     f"You are an English teacher. Evaluate if the following response matches the given topic. "
-        #     f"Topic: '{topic}'. Response: '{response}'. "
-        #     f"Provide feedback on relevance, grammar, and clarity. If the response is unrelated, suggest improvements to align it with the topic."
-        # )
-
-        prompt = (
-    f"You are a writing teacher. Evaluate the sentence formation, grammar, and overall writing quality of the following response. "
-    f"Provide constructive feedback highlighting any errors in grammar, spelling, punctuation, and sentence structure. "
-    f"If the response is well-written, acknowledge its strengths. "
-    f"Topic: '{topic}'. Response: '{response}'."
-)
-
-
-        # Call Cohere API for validation
-        payload = {
-            "model": "command-r-08-2024",
-            "prompt": prompt,
-            "max_tokens": 500,
-            "temperature": 0.7
-        }
-        headers = _cohere_headers()
-        api_response = requests.post(COHERE_API_URL, json=payload, headers=headers)
-
-        if api_response.status_code != 200:
-            return jsonify({"error": "Failed to validate response"}), 500
-
-        # Extract AI feedback
-        feedback = api_response.json().get("generations", [])[0].get("text", "")
-
-        return jsonify({"feedback": feedback}), 200
-
-    except Exception as e:
-        print(f"Error validating response: {e}")
-        return jsonify({"error": "An error occurred while validating the response."}), 500
-
-# Pronounciation
-
-@app.route('/validate-pronounce', methods=['POST'])
-def validate():
-    # Get the word and audio from the request
-    target_word = request.form['word']
-    audio_file = request.files['audio']
-
-    # Save the audio file temporarily
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
-        audio_path = tmp_file.name
-        audio_file.save(audio_path)
-
-    # Transcribe the audio and validate the pronunciation
-    transcribed_word = transcribe_audio(audio_path)
-    os.remove(audio_path)  # Clean up the temporary file
-
-    if not transcribed_word:
-        return jsonify({
-            "success": False,
-            "message": "Could not understand the pronunciation."
-        })
-
-    is_correct, message = validate_pronunciation(target_word, transcribed_word)
-    return jsonify({
-        "success": is_correct,
-        "message": message,
-        "transcribed_word": transcribed_word
-    })
-
-
-@app.route('/teach', methods=['GET'])
-def teach():
-    # Get the word to teach
-    word = request.args.get('word', default='', type=str)
-    if not word:
-        return jsonify({"success": False, "message": "No word provided."})
-
-    # Teach the pronunciation details
-    syllables = get_syllables(word)
-    silent_letters = detect_silent_letters(word)
-
-    return jsonify({
-        "success": True,
-        "syllables": syllables,
-        "silent_letters": silent_letters
-    })
-
-
-
-# Dictionary to store user conversations
-user_sessions = {}
-# Endpoint to explain grammar topics
-movie_bp = Blueprint("movie", __name__)
-
-def _cohere_generate(prompt: str, max_tokens: int = 1000, temperature: float = 0.7):
-    api_key = current_app.config.get("COHERE_API_KEY") or COHERE_API_KEY
-    if not api_key:
-        return None, ("COHERE_API_KEY not set on the server", 500)
-
-    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
-    payload = {"model": "command-r-08-2024", "prompt": prompt, "max_tokens": max_tokens, "temperature": temperature}
-    try:
-        r = requests.post(COHERE_API_URL, headers=headers, json=payload, timeout=30)
-        if r.status_code != 200:
-            return None, (f"Cohere API error: {r.text}", 502)
-        text = r.json().get("generations", [{}])[0].get("text", "").strip()
-        return text, None
-    except Exception as e:
-        current_app.logger.exception("Cohere request failed: %s", e)
-        return None, ("Upstream request failed", 502)
-
-@movie_bp.post("/explain-grammar")
-def explain_grammar():
-    try:
-        data = request.get_json()
-        print("Received Data:", data) 
-        topic = data.get('topic', '').strip()
-        session_id = data.get('session_id', str(uuid.uuid4()))  # Use provided session_id or create a new one
-
-        if not topic:
-            return jsonify({'error': 'Topic is required'}), 400
-
-        # Retrieve previous conversation history
-        conversation_history = user_sessions.get(session_id, [])
-
-        # Keep the last 10 messages to maintain better context (adjustable)
-        if len(conversation_history) > 10:
-            conversation_history = conversation_history[-10:]
-
-        # Generate a more **adaptive** prompt
-        context = "\n".join(conversation_history) if conversation_history else ""
-
-        prompt = f"""
-        You are a highly skilled grammar assistant. Your job is to maintain a **dynamic conversation** and respond intelligently based on user input, If the user asks something **unrelated to grammar**, respond with: "Please send a grammar-related question..
-
-        - Your answers must always **relate to the conversation history** and **extend naturally** based on what was previously asked.
-        - Your answers must be **concise, clear, and to the point**
-        - If the user asks for **examples**, explanations, or clarifications, **automatically infer** which topic they are referring to.
-        - If the user's question is **vague**, determine the most **logical continuation** based on prior questions.
-        - If the user asks something **unrelated to grammar**, respond with: "Please send a grammar-related question."
-
-        **Conversation so far:**
-        {context}
-
-        **User's new question:** {topic}
-        Please provide a **coherent and relevant answer** that continues the conversation naturally.
-        """
-
-        # Make the API call to Cohere
-        headers = {
-            'Authorization': f'Bearer {COHERE_API_KEY}',
-            'Content-Type': 'application/json'
-        }
-
-        payload = {
-            'model': 'command-r-08-2024',
-            'prompt': prompt,
-            'max_tokens': 1000  # Increased to allow better explanations
-        }
-
-        response = requests.post(COHERE_API_URL, headers=headers, json=payload)
-
-        if response.status_code == 200:
-            ai_response = response.json().get('generations', [{}])[0].get('text', '').strip()
-
-            # Store conversation history to maintain context
-            conversation_history.append(f"User: {topic}\nAI: {ai_response}")
-            user_sessions[session_id] = conversation_history  # Update session history
-
-            return jsonify({'response': ai_response, 'session_id': session_id})
-        else:
-            return jsonify({'error': 'Failed to fetch data from Cohere API'}), 500
-
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-
-
-@app.route('/suggest-grammar-questions', methods=['POST'])
-def suggest_grammar_questions():
-    try:
-        data = request.get_json()
-        user_input = data.get('input', '').strip()  # User's partial input (e.g., "What is v")
-
-        if not user_input:
-            return jsonify({'error': 'Input is required'}), 400
-
-        
-
-        prompt = f"""
-			You are a grammar expert. Given the user's input "{user_input}", generate **3 natural grammar-related questions** that people might ask.
-
-			- The user's input is a **partial or full grammar-related query**.
-			- AI must **infer the most likely grammar topic** based on the input.
-			- AI must **ensure all suggestions are strictly related to English grammar**.
-			- **If the input is incomplete, intelligently complete it** with the most likely grammar concept.
-			- Ensure all **questions are fully formed and relevant**.
-
-			**User input:** "{user_input}"
-			Provide exactly 3 well-structured, grammar-related questions:
-			"""
-
-        # Call Cohere API
-        headers = {
-            'Authorization': f'Bearer {COHERE_API_KEY}',
-            'Content-Type': 'application/json'
-        }
-
-        payload = {
-            'model': 'command-r-08-2024',
-            'prompt': prompt,
-            'max_tokens': 100,  # Only short responses needed
-            'temperature': 0.9,  # Some randomness for variety
-            'frequency_penalty': 0.8,  # Reduce repeated words
-            'presence_penalty': 0.8  # Encourage diverse questions
-        }
-
-        response = requests.post(COHERE_API_URL, headers=headers, json=payload)
-
-        if response.status_code == 200:
-            suggestions = response.json().get('generations', [{}])[0].get('text', '').strip().split("\n")
-            return jsonify({'suggestions': suggestions})
-        else:
-            return jsonify({'error': 'Failed to fetch suggestions', 'details': response.text}), 500
-
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-
-def validate_topic(topic):
-
-
-
-    validation_prompt = f"""
-    You are an AI grammar expert. Your task is to determine if a given topic is related to **English grammar** or not.
-
-    **Input:** "{topic}"
-
-    ### **Rules:**
-    - If the input is **in the form of a question** (e.g., it asks for an explanation or definition), return `"ask grammar topics"`, even if the topic is related to grammar.
-    - If the topic is **related to English grammar concepts** such as **parts of speech**, **verb tenses**, **sentence structure**, etc., return `"Grammar"`.
-    - If the topic is **not related to grammar**, such as general knowledge, science, math, history, or topics from other fields, return `"Not Grammar"`.
-    - Your response must be based purely on whether the topic relates to grammar, and **not** based on specific words, phrases, or examples.
-
-    **Your response must be exactly either "Grammar", "Not Grammar", or "ask grammar topics". No extra text.**
-    """
-
-
-    
-
-
-    headers = {
-        'Authorization': f'Bearer {COHERE_API_KEY}',
-        'Content-Type': 'application/json'
-    }
-
-    payload = {
-        'model': 'command-r-08-2024',
-        'prompt': validation_prompt,
-        'max_tokens': 5  # Minimal token usage for classification
-    }
-
-    try:
-        response = requests.post(COHERE_API_URL, json=payload, headers=headers)
-        validation_result = response.json().get('generations', [{}])[0].get('text', '').strip()
-        
-        # Ensure the response is strictly "Grammar" or "Not Grammar"
-        if validation_result not in ["Grammar", "Not Grammar"]:
-            return "Not Grammar"  # Fallback to avoid incorrect responses
-
-        return validation_result
-
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-
-@app.route('/generate-questions', methods=['POST'])
-def generate_questions_test():
-    try:
-        data = request.get_json()
-        topic = data.get('topic', '').strip() # Default to "grammar" if no topic is provided
-        # levels = data.get('levels', ['basic', 'medium', 'hard'])
-
-
-        validation_result = validate_topic(topic)
-
-        if validation_result != "Grammar":
-            return jsonify({"message": "Please enter a valid **grammar topic**, not a general word or unrelated question."}), 400
-
-
-        difficulty = data.get('difficulty', 'basic')
-
-
-         # Debugging output
-        print(f"Generating {difficulty} questions for topic: {topic}")
-
-
-
-        if difficulty == 'basic':
-            prompt = f"""
-            Generate five **completely new and unique** very basic-level fill-in-the-blank grammar questions **every time** on the topic '{topic}'. 
-
-            ### Rules:
-            - **Each question must have a different theme**, ensuring variety.
-            - **Do not repeat** themes from previous generations.
-            - Use **different sentence structures**, avoiding predictable patterns.
-            - **Avoid long words or abstract concepts**
-            - **Focus on the topic '{topic}'**, and ensure the blank is the key part of speech.
-            - Each question should contain **one blank represented by '_______'**, with the correct answer provided in parentheses at the end.
-            - The vocabulary should be **simple and suitable for beginners**.
-            - Ensure that the questions are **always new and distinct**, avoiding previously used themes.
-
-            Do not include any explanations or instructions in the response—only the five unique questions.
-            """
-
-        elif difficulty == 'elementary':
-            prompt = f"""
-            Generate five **completely new and unique** elementary-level fill-in-the-blank grammar questions **every time** on the topic '{topic}'.
-
-            ### Rules:
-            - The questions should be **slightly more challenging than basic-level questions**, incorporating **a wider range of sentence structures and vocabulary**.
-            - **Each question must have a different theme**, ensuring variety.
-            - **Use varied sentence structures**, making them slightly more complex than basic-level questions.
-            - **Ensure that the vocabulary is still simple but slightly broader** than basic-level questions.
-            - **Focus on the topic '{topic}'**, and ensure the blank is the key part of speech.
-            - Each question should contain **one blank represented by '_______'**, with the correct answer provided in parentheses at the end.
-            - Ensure that the questions are **always new and distinct**, avoiding previously used themes.
-    
-            Do not include any explanations or instructions in the response—only the five unique questions.
-            """
-
-        elif difficulty == 'pre-intermediate':
-            prompt = f"""
-            Generate five **completely new and unique** pre-intermediate-level fill-in-the-blank grammar questions **every time** on the topic '{topic}'.
-
-            ### Rules:
-            - The questions should be **more challenging than elementary-level questions**, incorporating **more varied sentence structures and an expanded vocabulary**.
-            - **Each question must have a different theme**, ensuring variety.
-            - **Ensure that the vocabulary is broader than elementary-level**, while keeping it understandable for learners.
-            - **Sentences should be longer and more descriptive** but still clear.
-            - **Focus on the topic '{topic}'**, and ensure the blank is the key part of speech.
-            - Each question should contain **one blank represented by '_______'**, with the correct answer provided in parentheses at the end.
-            - Ensure that the questions are **always new and distinct**, avoiding previously used themes.
-
-            Do not include any explanations or instructions in the response—only the five unique questions.
-            """
-
-        elif difficulty == 'intermediate':
-            prompt = f"""
-            Generate five **completely new and unique** intermediate-level fill-in-the-blank grammar questions **every time** on the topic '{topic}'.
-
-            ### Rules:
-            - The questions should be **more complex than pre-intermediate-level questions**, incorporating **a wider range of vocabulary and sentence structures**.
-            - **Each question must have a different theme**, ensuring variety.
-            - **Ensure that the vocabulary is more advanced than pre-intermediate-level** while keeping it natural for learners.
-            - **Sentences should be longer and include more detail**, improving reading comprehension.
-            - **Focus on the topic '{topic}'**, and ensure the blank is the key part of speech.
-            - Each question should contain **one blank represented by '_______'**, with the correct answer provided in parentheses at the end.
-            - Ensure that the questions are **always new and distinct**, avoiding previously used themes.
-
-            Do not include any explanations or instructions in the response—only the five unique questions.
-            """
-
-        elif difficulty == 'upper-intermediate':
-            prompt = f"""
-            Generate five **completely new and unique** upper-intermediate-level fill-in-the-blank grammar questions **every time** on the topic '{topic}'.
-
-            ### Rules:
-            - The questions should be **more complex than intermediate-level questions**, incorporating **more advanced sentence structures and vocabulary**.
-            - **Each question must have a different theme**, ensuring variety.
-            - **Ensure that the vocabulary is more refined and diverse** but still understandable for upper-intermediate learners.
-            - **Sentences should be longer and may introduce more nuanced contexts**, requiring a deeper understanding.
-            - **Focus on the topic '{topic}'**, and ensure the blank is the key part of speech.
-            - Each question should contain **one blank represented by '_______'**, with the correct answer provided in parentheses at the end.
-            - Ensure that the questions are **always new and distinct**, avoiding previously used themes.
-
-            Do not include any explanations or instructions in the response—only the five unique questions.
-            """
-
-        elif difficulty == 'advanced':
-            prompt = f"""
-            Generate five **completely new and unique** advanced-level (C1) fill-in-the-blank grammar questions **every time** on the topic '{topic}'.
-
-            ### Rules:
-            - The questions should be **more challenging than upper-intermediate (B2) level**, requiring a deep understanding of grammar, context, and vocabulary.
-            - **Ensure varied and sophisticated vocabulary**, avoiding basic words.
-            - **Each question should require nuanced comprehension**, testing knowledge of advanced grammar patterns.
-            - **The blank must be the key part of the sentence** (not an obvious answer).
-            - Each question should contain **one blank represented by '_______'**, with the correct answer provided in parentheses at the end.
-            - Ensure that the questions are **always new and distinct**, avoiding repetition of themes.
-
-            Do not include any explanations or instructions in the response—only the five unique questions.
-            """
-
-        elif difficulty == 'hard':
-            prompt = f"""
-            Generate five **completely new and unique** hard-level (C2) fill-in-the-blank grammar questions **every time** on the topic '{topic}'.
-
-            ### Rules:
-            - The questions should be **more challenging than advanced(C1) level**, requiring a deep understanding of grammar, context, and vocabulary.
-            - **Ensure varied and sophisticated vocabulary**, avoiding basic words.
-            - **Each question should require nuanced comprehension**, testing knowledge of advanced grammar patterns.
-            - **The blank must be the key part of the sentence** (not an obvious answer).
-            - Each question should contain **one blank represented by '_______'**, with the correct answer provided in parentheses at the end.
-            - Ensure that the questions are **always new and distinct**, avoiding repetition of themes.
-
-            Do not include any explanations or instructions in the response—only the five unique questions.
-            """
-
-        else:
-            return jsonify({"error": "Invalid difficulty level"}), 400
-
-        headers = {
-            'Authorization': f'Bearer {COHERE_API_KEY}',
-            'Content-Type': 'application/json'
-        }
-
-        payload = {
-            'model': 'command-r-08-2024',  # Ensure you're using the right model
-            'prompt': prompt,
-            'max_tokens': 1000  # Increase the token limit if needed
-        }
-
-        # Make the API request
-        response = requests.post(COHERE_API_URL, json=payload, headers=headers)
-
-        # Log the full response for debugging
-        print("Response status code:", response.status_code)
-        print("Response content:", response.text)
-
-        if response.status_code == 200:
-            return jsonify(response.json())  # Return the response from Cohere API
-        else:
-            return jsonify({"error": "Failed to fetch questions", "details": response.text}), 500
-    except Exception as e:
-        return jsonify({"error": str(e)}), 500
-
-# Endpoint to validate answers
-@app.route('/validate-answer', methods=['POST'])
-def validate_answer():
-    try:
-        # Get the data from the request
-        data = request.get_json()
-        topic = data.get('topic', '')  # Get the topic
-        question = data.get('question', '')
-        user_answer = data.get('user_answer', '')
-
-        # Validate if the required fields are present
-        if not question or not user_answer or not topic:
-         return jsonify({'error': 'Topic, question, and user answer are required'}), 400
-
-        # Construct the prompt for Cohere API
-        prompt = f"""
-        You are a highly knowledgeable grammar assistant. Validate whether the user's answer to the following question is correct or not based on {topic}. If the answer is incorrect, provide a helpful hint.
-        
-        Topic: {topic}
-        Question: "{question}"
-        User's Answer: "{user_answer}"
-
-        Is the answer correct? If not, please explain why and give a hint.
-        """
-
-        # Headers and payload for the Cohere API request
-        headers = {
-            'Authorization': f'Bearer {COHERE_API_KEY}',
-            'Content-Type': 'application/json'
-        }
-
-        payload = {
-            'model': 'command-r-08-2024',  # Use your model name here
-            'prompt': prompt,
-            'max_tokens': 100,
-            'temperature': 0.7
-        }
-
-        # Make the API call to Cohere
-        response = requests.post(COHERE_API_URL, headers=headers, json=payload)
-
-        # Debugging: Log response status and body
-        print(f"Status Code: {response.status_code}")
-        print(f"Response Body: {response.text}")
-
-        # Check if the request was successful
-        if response.status_code == 200:
-            data = response.json()
-            return jsonify(data)
-        else:
-            return jsonify({'error': 'Failed to fetch data from Cohere API'}), 500
-
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-
-
-# // for validating Multiple answer:
-
-# Function to validate an individual answer using Cohere API
-def validate_answer_with_ai(topic, question, user_answer):
-    try:
-        # Construct the prompt for Cohere API
-        prompt = f"""
-        You are a highly knowledgeable grammar assistant. Validate whether the user's answer to the following question is correct or not based on {topic}. If the answer is incorrect, provide a helpful hint.
-
-        Topic: {topic}
-        Question: "{question}"
-        User's Answer: "{user_answer}"
-
-        Is the answer correct? If not, please explain why and give a hint.
-        """
-
-        # Headers for the API request
-        headers = {
-            'Authorization': f'Bearer {COHERE_API_KEY}',
-            'Content-Type': 'application/json'
-        }
-
-        # Construct the payload for Cohere API request
-        payload = {
-            'model': 'command-r-08-2024',  # You can use a different model depending on your needs
-            'prompt': prompt,
-            'max_tokens': 200,
-            'temperature': 0.7,
-            'stop_sequences': ['\n']
-        }
-
-        # Make the POST request to the Cohere API
-        response = requests.post('https://api.cohere.ai/v1/generate', headers=headers, json=payload)
-
-        if response.status_code == 200:
-            result = response.json()
-            # Extract and return the relevant part of the response
-            validation_response = result['generations'][0]['text'].strip()
-            return validation_response
-        else:
-            return f"Error: {response.status_code} - {response.text}"
-
-    except Exception as e:
-        return f"An error occurred: {str(e)}"
-
-
-
-
-# Endpoint to validate multiple answers at once
-@app.route('/validate-all-answers', methods=['POST'])
-def validate_all_answers():
-    try:
-        # Get the list of questions and answers from the request body
-        data = request.get_json()
-        questions = data.get('questions', [])
-
-        if not questions:
-            return jsonify({'error': 'No questions provided'}), 400
-
-        validation_results = []
-
-        # Iterate over the list of questions and validate each answer
-        for item in questions:
-            topic = item.get('topic', '')
-            question = item.get('question', '')
-            user_answer = item.get('user_answer', '')
-
-            if not topic or not question or not user_answer:
-                validation_results.append({
-                    'question': question,
-                    'error': 'Missing required fields (topic, question, or answer).'
-                })
-                continue
-
-            # Validate the answer with the Cohere API
-            validation_response = validate_answer_with_ai(topic, question, user_answer)
-
-            # If the answer is incorrect, generate a hint
-            hint = None
-            if "incorrect" in validation_response.lower() or "not correct" in validation_response.lower():
-                # Generate the hint for the incorrect answer
-                hint = generate_hint(topic, question, user_answer)
-
-            validation_results.append({
-                'question': question,
-                'user_answer': user_answer,
-                'validation_response': validation_response,
-                'hint': hint  # Add hint to the result
-            })
-
-        return jsonify({'results': validation_results})
-
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-
-
-def generate_hint(topic, question, user_answer):
-    try:
-        # Construct the prompt for Cohere API to generate a hint for incorrect answers
-        prompt = f"""
-        You are a highly skilled grammar assistant. Your task is to generate a helpful hint for the user to improve their answer based on the following question.
-
-        Topic: {topic}
-        Question: "{question}"
-        User's Answer: "{user_answer}"
-
-        If the user's answer is incorrect, provide a specific, actionable hint to help the user correct their answer.
-        The hint should include:
-        - Explanation of the error made by the user.
-        - A hint on the correct grammatical structure or word form.
-        - A hint on how to structure the sentence correctly **without revealing the exact answer**.
-
-        Please make sure the hint is **clear** and **helpful** for the user, **without revealing the correct answer**.
-        """
-
-        headers = {
-            'Authorization': f'Bearer {COHERE_API_KEY}',
-            'Content-Type': 'application/json'
-        }
-
-        payload = {
-            'model': 'command-r-08-2024',  # Replace with the model you're using
-            'prompt': prompt,
-            'max_tokens': 250,  # Adjust token size as needed
-            'temperature': 0.7,  # Use temperature to control creativity
-        }
-
-        # Make the POST request to Cohere API
-        response = requests.post(COHERE_API_URL, headers=headers, json=payload)
-
-        if response.status_code == 200:
-            result = response.json()
-            # Extract and return the relevant hint from the response
-            hint = result['generations'][0]['text'].strip()
-            return hint
-        else:
-            return f"Error: {response.status_code} - {response.text}"
-
-    except Exception as e:
-        return f"An error occurred: {str(e)}"
-
-
-
-
-
-
-if __name__ == '__main__':
-    # app.run(debug=True)
-    app.register_blueprint(movie_bp, url_prefix='')  # expose /explain-grammar locally
-    app.run(host='0.0.0.0', port=5012, debug=True)