Update app.py

app.py

@@ -23,35 +23,54 @@ def compressed_length(s):
     return len(gzip.compress(s.encode('utf-8')))
 
 def ncd(x, y):
+    """
+    Normalized Compression Distance for strings x and y.
+    """
     Cx = compressed_length(x)
     Cy = compressed_length(y)
     Cxy = compressed_length(x + " " + y)
     return (Cxy - min(Cx, Cy)) / max(Cx, Cy)
 
 def normalize_scores(scores, reverse=False):
+    """
+    Scale a list of scores to [0,1], optionally reversing (1 - x).
+    """
     min_score = min(scores)
     max_score = max(scores)
+    if max_score == min_score:
+        return [0] * len(scores)
     if reverse:
         return [(max_score - x) / (max_score - min_score) for x in scores]
     return [(x - min_score) / (max_score - min_score) for x in scores]
 
 def hybrid_retrieval(query, passages, embeddings, alpha=0.7, beta=0.3):
+    """
+    Combine cosine similarity (SentenceTransformer) and
+    Normalized Compression Distance (NCD) for retrieval.
+    """
     query_embedding = model.encode(query)
     cosine_similarities = cosine_similarity([query_embedding], embeddings)[0]
     
+    # Normalize
     normalized_cosine_similarities = normalize_scores(cosine_similarities)
     
+    # Calculate NCD
     ncd_values = [ncd(query, passage) for passage in passages]
     normalized_ncd_values = normalize_scores(ncd_values, reverse=True)
     
-    final_scores = [alpha * cos_sim + beta * ncd_sim 
-                    for cos_sim, ncd_sim in zip(normalized_cosine_similarities, normalized_ncd_values)]
+    # Combine
+    final_scores = [
+        alpha * cos_sim + beta * ncd_sim
+        for cos_sim, ncd_sim in zip(normalized_cosine_similarities, normalized_ncd_values)
+    ]
     
     most_similar_index = np.argmax(final_scores)
-    
     return most_similar_index, cosine_similarities[most_similar_index], ncd_values[most_similar_index], final_scores[most_similar_index]
 
 def llama_query(prompt, system_content):
+    """
+    Send a prompt to the Together LLaMa model and return the response.
+    """
     response = client.chat.completions.create(
         model="meta-llama/Llama-3.3-70B-Instruct-Turbo",
         messages=[
@@ -69,80 +88,125 @@ def llama_query(prompt, system_content):
     return response.choices[0].message.content
 
 def check_blood_donation_relevance(question):
-    prompt = f"Is the following question related to blood donation? Answer with 'Yes' or 'No': {question}"
+    """
+    Use LLaMa to check whether 'question' is about blood donation.
+    """
+    prompt = f"Is the following question related to blood donation? Answer ONLY with 'Yes' or 'No': {question}"
     system_content = "You are an assistant that determines if a question is related to blood donation."
-    response = llama_query(prompt, system_content)
-    return response.strip().lower() == 'yes'
+    response = llama_query(prompt, system_content).strip().lower()
+    return response == 'yes'
 
 def detect_language(text):
-    prompt = f"Detect the language of this text. If it's Swahili, return 'Swahili'. If it's English, return 'English'. Here's the text: {text}"
+    """
+    Use LLaMa to detect language (English or Swahili).
+    Returns 'swahili' or 'english'.
+    """
+    prompt = (
+        "Detect the language of this text. If it's Swahili, return 'Swahili'. "
+        "If it's English, return 'English'. Here's the text:\n\n"
+        f"{text}"
+    )
     system_content = "You are a language detection assistant."
-    response = llama_query(prompt, system_content)
-    return response.strip().lower()
+    response = llama_query(prompt, system_content).strip().lower()
+    # Attempt to match strictly 'swahili' or 'english' from the response
+    if "swahili" in response:
+        return "swahili"
+    if "english" in response:
+        return "english"
+    # Fallback: default to English
+    return "english"
 
 def translate_to_english(text):
+    """
+    Translate Swahili text to English using LLaMa.
+    """
     prompt = f"Translate the following Swahili text to English: {text}"
     system_content = "You are a translation assistant that translates from Swahili to English."
     response = llama_query(prompt, system_content)
-    return response
+    return response.strip()
 
 def translate_to_swahili(text):
+    """
+    Translate any text to simple Swahili using LLaMa.
+    """
     prompt = f"Translate the following text to simple Swahili, avoiding difficult words: {text}"
     system_content = "You are a translation assistant that translates to simple Swahili."
     response = llama_query(prompt, system_content)
-    return response
+    return response.strip()
 
 def refine_answer(question, retrieved_answer):
-    prompt = f"Question: {question}\nRetrieved Answer: {retrieved_answer}\nPlease refine the retrieved answer according to the question asked, ensuring it's clear and concise."
+    """
+    Refine the retrieved answer, making it more relevant and natural.
+    """
+    prompt = (
+        f"Question: {question}\n\n"
+        f"Retrieved Answer: {retrieved_answer}\n\n"
+        "Please refine the retrieved answer so it's direct, clear, and specifically addresses the question."
+    )
     system_content = "You are an assistant that refines answers to make them more relevant and natural."
-    return llama_query(prompt, system_content)
+    return llama_query(prompt, system_content).strip()
 
 def get_answer(user_question, threshold=0.3):
+    # 1) Detect user language
     language = detect_language(user_question)
-
+    
+    # 2) Convert user question to English for checking & retrieval
     if language == 'swahili':
         english_question = translate_to_english(user_question)
     else:
         english_question = user_question
 
-    index, cosine_sim, ncd_value, final_score = hybrid_retrieval(english_question, df['Question'].tolist(), question_embeddings)
-
+    # 3) Check if the question is about blood donation using LLaMa
+    is_blood_related = check_blood_donation_relevance(english_question)
+    
+    if not is_blood_related:
+        # Off-topic response
+        off_topic_message = "I'm sorry, but your question doesn't seem to be related to blood donation. Could you please ask a question about blood donation?"
+        if language == 'swahili':
+            off_topic_message = translate_to_swahili(off_topic_message)
+        return off_topic_message, 0.0
+    
+    # If it is about blood donation, proceed with hybrid retrieval
+    index, cosine_sim, ncd_value, final_score = hybrid_retrieval(
+        english_question, 
+        df['Question'].tolist(), 
+        question_embeddings
+    )
+    
+    # 4) If retrieval confidence is high enough, refine the CSV answer
     if final_score > threshold:
         retrieved_answer = df.iloc[index]['Answer']
-        refined_answer = refine_answer(english_question, retrieved_answer)
-
+        refined_answer_english = refine_answer(english_question, retrieved_answer)
+        # Translate back to user language if needed
         if language == 'swahili':
-            refined_answer = translate_to_swahili(refined_answer)
-
-        return refined_answer, final_score
+            return translate_to_swahili(refined_answer_english), final_score
+        else:
+            return refined_answer_english, final_score
     else:
-        # Use LLaMa to determine if the question is related to blood donation
-        if check_blood_donation_relevance(english_question):
-            llama_response = llama_query(
-                f"Please provide a brief, general answer to this blood donation related question: {english_question}",
-                "You are an assistant knowledgeable about blood donation. Provide brief, accurate answers."
-            )
-            if language == 'swahili':
-                llama_response = translate_to_swahili(llama_response)
-            return llama_response, 0
+        # 5) If retrieval is below threshold, ask LLaMa for a general blood-donation-related answer
+        llama_response_english = llama_query(
+            f"Please provide a concise, accurate answer about blood donation for the question: {english_question}",
+            "You are an assistant knowledgeable about blood donation. Provide concise, accurate answers."
+        )
+        llama_response_english = llama_response_english.strip()
+        
+        # Translate back to user language if needed
+        if language == 'swahili':
+            return translate_to_swahili(llama_response_english), final_score
         else:
-            off_topic_message = "I'm sorry, but your question doesn't seem to be related to blood donation. Could you please ask a question about blood donation?"
-            if language == 'swahili':
-                off_topic_message = translate_to_swahili(off_topic_message)
-            return off_topic_message, 0
+            return llama_response_english, final_score
 
 # Gradio app
 def gradio_app(user_question):
     answer, similarity = get_answer(user_question)
     return f"Similarity: {similarity:.2f}\nAnswer: {answer}"
 
-# Launch the Gradio app
 iface = gr.Interface(
     fn=gradio_app,
     inputs=gr.Textbox(label="Enter your question"),
     outputs=gr.Textbox(label="Answer"),
     title="Blood Donation Q&A",
-    description="Ask questions related to blood donation and get answers in English or Swahili.",
+    description="Ask questions about blood donation in English or Swahili. The system first checks if it's related to blood donation."
 )
 
-iface.launch()
+iface.launch()