Upload 3 files

qamatcher_server.py

@@ -0,0 +1,69 @@
+
+import os
+from flask import request, jsonify
+from sentence_transformers import SentenceTransformer, util
+
+# 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 SentenceTransformer model (paraphrase-MiniLM-L6-v2)...")
+matcher_model = SentenceTransformer('paraphrase-MiniLM-L6-v2', cache_folder=cache_dir)
+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,38 @@
+
+import os
+from flask import request, jsonify
+from transformers import pipeline
+
+# 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 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", model_kwargs={"cache_dir": cache_dir})
+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

whisper_server (1).py

@@ -0,0 +1,61 @@
+
+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,
+    model_kwargs={"cache_dir": cache_dir}
+)
+
+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