Upload 6 files

Dockerfile

@@ -0,0 +1,24 @@
+# Use a more stable and widely-used official Python base image
+FROM python:3.9-slim-bullseye
+
+# Set the working directory
+WORKDIR /code
+
+# Update package lists and set environment variables for caching
+RUN apt-get update && apt-get install -y --no-install-recommends git
+ENV XDG_CACHE_HOME=/tmp/.cache
+ENV HF_HOME=/tmp/.cache/huggingface
+ENV PIP_CACHE_DIR=/tmp/.cache/pip
+
+# Copy the requirements file and install dependencies
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# Copy all the Python server files
+COPY . /code/
+
+# Expose the port the app runs on (Hugging Face default)
+EXPOSE 7860
+
+# Command to run the application using gunicorn
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "app:app"]

app.py

@@ -0,0 +1,45 @@
+
+import os
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+
+# This is done in the Dockerfile now, but leaving for local dev consistency
+os.environ["XDG_CACHE_HOME"] = os.environ.get("XDG_CACHE_HOME", "/tmp/.cache")
+
+# Import handlers from other server files
+from whisper_server import handle_transcribe, model as whisper_model
+from qgen_server import handle_generate_questions, qg_model
+from qamatcher_server import handle_match_question, matcher_model
+
+app = Flask(__name__)
+
+# Configure CORS to allow all origins
+CORS(app, resources={r"/*": {"origins": "*"}})
+
+@app.route('/')
+def index():
+    return jsonify({
+        'message': 'VoiceQ AI Server is running!',
+        'models_loaded': {
+            'whisper': whisper_model is not None,
+            'question-generator': qg_model is not None,
+            'question-matcher': matcher_model is not None,
+        }
+    })
+
+@app.route('/transcribe', methods=['POST'])
+def transcribe():
+    return handle_transcribe()
+
+@app.route('/generate-questions', methods=['POST'])
+def generate_questions():
+    return handle_generate_questions()
+
+@app.route('/match-question', methods=['POST'])
+def match_question():
+    return handle_match_question()
+
+# The following block is for local development only and will not be used in the Docker container.
+if __name__ == '__main__':
+    PORT = int(os.environ.get("PORT", 5001))
+    app.run(host='0.0.0.0', port=PORT, debug=True)

qamatcher_server.py

@@ -0,0 +1,64 @@
+
+from flask import request, jsonify
+from sentence_transformers import SentenceTransformer, util
+
+print("Loading SentenceTransformer model (paraphrase-MiniLM-L6-v2)...")
+matcher_model = SentenceTransformer('paraphrase-MiniLM-L6-v2')
+print("SentenceTransformer model loaded.")
+
+# Define a threshold for a "good" match
+SIMILARITY_THRESHOLD = 0.6
+
+def handle_match_question():
+    data = request.get_json()
+    if not data or 'user_question' not in data or 'documents' not in data:
+        return jsonify({'error': 'Invalid request. "user_question" and "documents" are required.'}), 400
+
+    user_question = data['user_question']
+    documents = data['documents']
+
+    if not documents:
+        return jsonify({'answer': "There are no notes to search."})
+
+    # Flatten the list of questions from all documents
+    all_questions = []
+    # Map each question to the original note text
+    question_to_note_map = {}
+
+    for doc in documents:
+        note_text = doc.get('note_text', '')
+        for q in doc.get('questions', []):
+            all_questions.append(q)
+            question_to_note_map[q] = note_text
+    
+    if not all_questions:
+        return jsonify({'answer': "No questions have been generated for your notes yet."})
+
+    try:
+        # Encode the user's question and all stored questions
+        user_embedding = matcher_model.encode(user_question, convert_to_tensor=True)
+        stored_embeddings = matcher_model.encode(all_questions, convert_to_tensor=True)
+
+        # Compute cosine similarity
+        cosine_scores = util.pytorch_cos_sim(user_embedding, stored_embeddings)
+
+        # Find the best match
+        best_match_idx = cosine_scores.argmax()
+        best_score = float(cosine_scores[0][best_match_idx])
+        best_question = all_questions[best_match_idx]
+
+        print(f"User Question: '{user_question}'")
+        print(f"Best matched stored question: '{best_question}' with score: {best_score:.4f}")
+
+        # Check if the match is good enough
+        if best_score > SIMILARITY_THRESHOLD:
+            # Return the note associated with the best-matched question
+            answer = question_to_note_map[best_question]
+        else:
+            answer = "Sorry, I couldn't find a relevant note to answer your question."
+        
+        return jsonify({'answer': answer})
+
+    except Exception as e:
+        print(f"Error during question matching: {e}")
+        return jsonify({'error': str(e)}), 500

qgen_server.py

@@ -0,0 +1,33 @@
+
+from flask import request, jsonify
+from transformers import pipeline
+
+print("Loading Question Generation model (iarfmoose/t5-base-question-generator)...")
+# Initialize the pipeline for text2text-generation with the specified model
+qg_model = pipeline("text2text-generation", model="iarfmoose/t5-base-question-generator")
+print("Question Generation model loaded.")
+
+def handle_generate_questions():
+    data = request.get_json()
+    if not data or 'text' not in data:
+        return jsonify({'error': 'Invalid request. "text" field is required.'}), 400
+    
+    text = data['text']
+    
+    # Prepend the text with "generate questions: " as required by this model
+    input_text = f"generate questions: {text}"
+    
+    try:
+        # Generate questions
+        results = qg_model(input_text, max_length=64, num_beams=4, early_stopping=True)
+        
+        # The result is a single string with questions separated by '<sep>'
+        generated_text = results[0]['generated_text']
+        questions = [q.strip() for q in generated_text.split('<sep>') if q.strip()]
+        
+        print(f"Generated questions for text: '{text[:50]}...' -> {questions}")
+        
+        return jsonify({'questions': questions})
+    except Exception as e:
+        print(f"Error during question generation: {e}")
+        return jsonify({'error': str(e)}), 500

requirements.txt

@@ -0,0 +1,11 @@
+Flask==3.0.3
+# openai-whisper is replaced by the transformers library
+# openai-whisper==20231117
+sentence-transformers==2.7.0
+torch==2.3.0
+torchaudio==2.3.0
+flask-cors==4.0.1
+gunicorn==22.0.0
+# Added for Hugging Face model loading
+transformers==4.43.3
+accelerate

whisper_server.py

@@ -0,0 +1,77 @@
+
+import os
+import tempfile
+from flask import request, jsonify
+from transformers import pipeline
+import torch
+
+# Define a writable directory for the model cache
+cache_dir = os.path.join(os.getenv("XDG_CACHE_HOME", "/tmp/.cache"), "huggingface_models")
+os.makedirs(cache_dir, exist_ok=True)
+
+print("Loading collabora/whisper-tiny-hindi model via transformers pipeline...")
+
+# Determine device
+device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+# Initialize the ASR pipeline with the specified model
+# Using the transformers pipeline is the correct way to load custom models from the Hub.
+model = pipeline(
+    "automatic-speech-recognition",
+    model="collabora/whisper-tiny-hindi",
+    device=device
+)
+
+print("Whisper model loaded.")
+
+def handle_transcribe():
+    if 'file' not in request.files:
+        return jsonify({'error': 'No file part in the request'}), 400
+    
+    file = request.files['file']
+    
+    if file.filename == '':
+        return jsonify({'error': 'No selected file'}), 400
+
+    if file:
+        # Use a temporary file to save the upload
+        with tempfile.NamedTemporaryFile(delete=True, suffix=".webm") as temp_audio:
+            file.save(temp_audio.name)
+            
+            try:
+                print(f"Transcribing file: {temp_audio.name} with collabora/whisper-tiny-hindi pipeline")
+                
+                # The pipeline expects a file path and handles the processing.
+                result = model(temp_audio.name)
+                
+                transcribed_text = result.get('text', '')
+
+                print("Transcription successful.")
+                return jsonify({'text': transcribed_text})
+            except Exception as e:
+                print(f"Error during transcription: {e}")
+                # Provide a more specific error if possible
+                error_message = f"An unexpected error occurred during transcription: {str(e)}"
+                if "out of memory" in str(e).lower():
+                    error_message = "The model ran out of memory. Please try a smaller audio file or check server resources."
+                
+                return jsonify({'error': error_message}), 500
+
+    return jsonify({'error': 'File processing failed'}), 500
+
+# This part is for standalone execution if needed for testing
+if __name__ == '__main__':
+    from flask import Flask
+    from flask_cors import CORS
+
+    app = Flask(__name__)
+    CORS(app)
+    PORT = int(os.environ.get("PORT", 5001))
+    
+    @app.route('/transcribe', methods=['POST'])
+    def standalone_transcribe():
+        return handle_transcribe()
+        
+    app.run(host='0.0.0.0', port=PORT, debug=True)
+
+