add generateQuestion

generateQuestion - Cleared.py

@@ -0,0 +1,458 @@
+from flask import Flask, jsonify, send_file, abort, make_response, request
+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 
+
+
+
+
+
+
+
+
+
+app = Flask(__name__)
+CORS(app)
+# CORS(app, resources={r"/*": {"origins": "*"}})
+
+@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_URL = 'https://api.cohere.ai/v1/generate'
+
+# Google Cloud Speech-to-Text Configuration
+speech_client = speech.SpeechClient()
+
+
+
+
+
+
+
+
+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.run(host='0.0.0.0', port=5012, debug=True)

generateQuestion - Copy.py

@@ -0,0 +1,1271 @@
+from flask import Flask, jsonify, send_file, abort, make_response, request
+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 
+
+
+
+
+
+
+
+
+
+app = Flask(__name__)
+CORS(app)
+# CORS(app, resources={r"/*": {"origins": "*"}})
+
+@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_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 = {"Authorization": f"Bearer {COHERE_API_KEY}"}
+
+        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
+
+
+# @app.route('/generate-questions/<video_id>', methods=['GET'])
+# def generate_questions_videos(video_id):
+#     try:
+#         # Step 1: Get video metadata
+#         video = next((v for v in VIDEOS if v["id"] == video_id), None)
+#         if not video:
+#             return jsonify({"error": "Video not found"}), 404
+
+#         video_path = os.path.join(VIDEO_FOLDER, video["filename"])
+
+#         # Step 2: Convert video to audio
+#         audio_filename = f"{uuid.uuid4()}.mp3"
+#         audio_path = os.path.join(AUDIO_FOLDER, audio_filename)
+#         video_clip = VideoFileClip(video_path)
+#         video_clip.audio.write_audiofile(audio_path)
+
+#         # Step 3: Transcribe the audio file 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:
+#             return jsonify({"error": "No transcription results found"}), 500
+
+#         transcription_text = " ".join(transcripts)
+
+#         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 = {"Authorization": f"Bearer {COHERE_API_KEY}"}
+
+#         # Step 5: Make the API request to Cohere
+#         cohere_response = requests.post(COHERE_API_URL, json=cohere_payload, headers=headers)
+
+#         if cohere_response.status_code != 200:
+#             print(f"Cohere API error: {cohere_response.text}")
+#             return jsonify({"error": "Failed to generate questions"}), 500
+
+#         # Parse the response for questions
+#         questions = cohere_response.json().get("generations", [])
+#         if not questions:
+#             return jsonify({"error": "No questions generated"}), 500
+
+#         # Extract raw text and parse it
+#         raw_text = questions[0]["text"]
+#         structured_questions = parse_questions(raw_text)
+#         print("Raw AI Model Response:", raw_text)
+
+#         # Return the structured questions
+#         return jsonify({"questions": structured_questions}), 200
+
+#     except Exception as e:
+#         print(f"Error during question generation: {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
+
+
+# @app.route('/generate-writing-topics', methods=['POST'])
+# def generate_writing_topics():
+#     """
+#     Generate writing topics based on the user's grade level and difficulty level.
+#     """
+#     try:
+#         # Extract grade level and difficulty level from the POST request
+#         data = request.json
+#         grade_level = data.get("grade_level", "lower").lower()  # Default to 'lower' if not provided
+#         difficulty = data.get("difficulty", "basic").lower()  # Default to 'basic' 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
+
+#         # Validate difficulty level
+#         valid_difficulties = {"basic", "medium", "hard"}
+#         if difficulty not in valid_difficulties:
+#             return jsonify({"error": f"Invalid difficulty level. Choose from: {', '.join(valid_difficulties)}"}), 400
+
+#         # Define a prompt based on the grade level and difficulty level
+#         # Define a prompt based on the grade level and difficulty level
+#         if difficulty == "basic":
+#             # prompt = (
+#             #     f"Generate one simple and short writing topic suitable for a {grade_level}-grade student. "
+#             #     f"The topic should be one sentence, easy to understand, and fun to write about. "
+#             #     f"Focus on familiar and relatable themes like family, school, or favorite activities."
+#             # )
+
+#             prompt = (
+#         		f"Generate one unique and imaginative writing topic suitable for a {grade_level}-grade student. "
+#         		f"The topic should be short, easy to understand, and fun to write about. "
+#         		f"Ensure the topic explores new and diverse themes, avoiding repetition of previous ideas. "
+#         		f"Focus on creativity, variety, and age-appropriate fun."
+#     )
+#         elif difficulty == "medium":
+#             prompt = (
+#                 f"Generate one creative writing topic suitable for a {grade_level}-grade student. "
+#                 f"The topic should encourage imagination and exploration while still being age-appropriate. "
+#                 f"Include themes like adventures, problem-solving, or hypothetical scenarios."
+#             )
+#         elif difficulty == "hard":
+#             prompt = (
+#                 f"Generate one challenging and thought-provoking writing topic suitable for a {grade_level}-grade student. "
+#                 f"The topic should require critical thinking, creativity, or self-reflection. "
+#                 f"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 = {"Authorization": f"Bearer {COHERE_API_KEY}"}
+#         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
+
+
+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 = {"Authorization": f"Bearer {COHERE_API_KEY}"}
+        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 = {"Authorization": f"Bearer {COHERE_API_KEY}"}
+        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
+    })
+
+
+# # Endpoint to explain grammar topics
+# @app.route('/explain-grammar', methods=['POST'])
+# def explain_grammar():
+#     try:
+#         data = request.get_json()
+#         topic = data.get('topic', '')
+#         detail = data.get('detail', '').lower()  # Capture 'detail' from the user  # Default to 'short' if not specified
+
+
+#         if not topic:
+#             return jsonify({'error': 'Topic is required'}), 400
+
+
+#           # Check if the user is asking for more details
+#         if any(keyword in detail for keyword in ['detailed', 'more explanation', 'in detail']):
+#             # Construct the prompt for detailed explanation
+#             prompt = f"""
+#             You are a highly skilled grammar assistant. Your responsibility is to provide explanations only for grammar-related topics. 
+#             If the user submits a request that does not relate to grammar, respond with: "Please send a grammar-related question."
+
+#             Your response should be detailed and focused on grammar concepts.
+
+#             Please explain the following topic in detail: {topic}
+
+#             1. Provide a **clear explanation** of the grammar concept.
+#             2. Include **examples** to demonstrate the proper usage of the concept in context.
+#             3. List **key rules** or important points related to the topic.
+#             4. Provide **additional clarifications** or related information as necessary to give a thorough understanding.
+
+#             If the submitted topic does not belong to the domain of grammar (for example, topics related to non-grammar subjects), respond with: "Please send a grammar-related question."
+#             """
+#         else:
+#             # Construct the prompt for concise explanation
+#             prompt = f"""
+#             You are a highly skilled grammar assistant. Your responsibility is to provide explanations only for grammar-related topics. 
+#             If the user submits a request that does not relate to grammar, respond with: "Please send a grammar-related question."
+
+#             Your response should be clear, concise, and focused solely on grammar concepts.
+
+#             Please explain the following topic in brief: {topic}
+
+#             1. Provide a **brief explanation** of the grammar concept.
+#             2. Include at least **one example** to demonstrate the proper usage of the concept.
+#             3. List **key rules** or important points related to the topic.
+            
+#             If the submitted topic does not belong to the domain of grammar (for example, topics related to non-grammar subjects), respond with: "Please send a grammar-related question."
+#             """
+
+
+#         # Make the API call to Cohere
+#         headers = {
+#             'Authorization': f'Bearer {COHERE_API_KEY}',
+#             'Content-Type': 'application/json'
+#         }
+
+#         payload = {
+#             'model': 'command-r-08-2024',  # Use your Cohere model here
+#             'prompt': prompt,
+#             'max_tokens': 300
+#         }
+
+#         response = requests.post(COHERE_API_URL, headers=headers, json=payload)
+
+#         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
+
+
+# Dictionary to store user conversations
+user_sessions = {}
+# Endpoint to explain grammar topics
+@app.route('/explain-grammar', methods=['POST'])
+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 topic is related to **English grammar concepts**, such as sentence structure, parts of speech, verb tenses, or any other grammatical structures, return `"Grammar"`.
+    # # - If the topic is **in the form of a question** (e.g., "What is...", "How does..."), return `"Not 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" or "Not Grammar". No extra text.**
+    # # """
+
+
+    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')
+
+        # # Validate if the topic is grammar-related using an AI-based classification prompt
+        # validation_prompt = f"""
+        # You are a grammar assistant. Your job is to determine whether the following topic is related to English grammar:
+        # Topic: {topic}
+        # If the topic is related to grammar, respond with "Grammar".
+        # If the topic is not related to grammar, respond with "Not Grammar".
+        # """
+
+        # headers = {
+        #     'Authorization': f'Bearer {COHERE_API_KEY}',
+        #     'Content-Type': 'application/json'
+        # }
+
+        # validation_payload = {
+        #     'model': 'command-r-08-2024',
+        #     'prompt': validation_prompt,
+        #     'max_tokens': 10  # Minimal token usage for classification
+        # }
+
+        # validation_response = requests.post(COHERE_API_URL, json=validation_payload, headers=headers)
+        # validation_result = validation_response.json().get('generations', [{}])[0].get('text', '').strip()
+
+        # if validation_result != "Grammar":
+        #     return jsonify({"message": "Please ask a grammar-related question."}), 400
+
+
+         # 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.run(host='0.0.0.0', port=5012, debug=True)

generateQuestion.py

@@ -0,0 +1,492 @@
+# from flask import Flask, Blueprint, jsonify, send_file, abort, make_response, request
+from flask import Flask, Blueprint, jsonify, send_file, abort, make_response, request, 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 
+
+
+
+
+questions_bp = Blueprint("questions", __name__)
+
+
+
+
+
+app = Flask(__name__)
+CORS(app)
+# CORS(app, resources={r"/*": {"origins": "*"}})
+
+@app.route('/')
+def home():
+    return "Welcome to the Flask app! The server is running."
+
+# read from env as a fallback (works for local .env and HF Secrets)
+COHERE_API_KEY = os.getenv("COHERE_API_KEY", "")
+
+def _cohere_headers():
+    """
+    Prefer a key set on the Flask app (e.g., in verification.py: app.config["COHERE_API_KEY"]),
+    otherwise fall back to the environment variable COHERE_API_KEY.
+    """
+    api_key = current_app.config.get("COHERE_API_KEY") or COHERE_API_KEY
+    if not api_key:
+        return None
+    return {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+
+# API configuration for AI-based question generation
+# COHERE_API_KEY = 'WjnDKknACe0zxHvczdo7q4vwF4WAXn2429hcPHIB'
+COHERE_API_URL = 'https://api.cohere.ai/v1/generate'
+
+# Google Cloud Speech-to-Text Configuration
+speech_client = speech.SpeechClient()
+
+
+
+
+
+
+
+
+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'
+    # }
+    headers = _cohere_headers()
+    if not headers:
+        return "Error: COHERE_API_KEY not set"
+
+    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)}"
+
+@questions_bp.post('/generate-questions')
+# @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'
+        # }
+        headers = _cohere_headers()
+        if not headers:
+            return jsonify({"error": "COHERE_API_KEY not set on the server"}), 500
+
+        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
+@questions_bp.post('/validate-answer')
+# @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'
+        # }
+
+        headers = _cohere_headers()
+        if not headers:
+            return jsonify({"error": "COHERE_API_KEY not set on the server"}), 500
+
+        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'
+        # }
+
+        headers = _cohere_headers()
+        if not headers:
+            return "Error: COHERE_API_KEY not set"
+
+        # 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)}"
+
+
+
+@questions_bp.post('/validate-all-answers')
+# 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'
+        # }
+
+        headers = _cohere_headers()
+        if not headers:
+            return "Error: COHERE_API_KEY not set"
+
+        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(questions_bp, url_prefix='')  # expose /explain-grammar locally
+    app.run(host='0.0.0.0', port=5012, debug=True)
+

verification.py

@@ -305,8 +305,10 @@ def check_auth(username):
 # Register Blueprint: grammar (and later media) lives in testmovie.py
 # ------------------------------------------------------------------------------
 from chat import movie_bp  # ensure testmovie.py defines movie_bp = Blueprint(...)
+from generateQuestion import questions_bp  
 app.register_blueprint(movie_bp, url_prefix="/media")
-
+app.register_blueprint(questions_bp, url_prefix="/media")
+# app.register_blueprint(questions_bp, url_prefix="/media")  # <-- add this
 # ------------------------------------------------------------------------------
 # Local run (Gunicorn will import `verification:app` on Spaces)
 # ------------------------------------------------------------------------------