Upload 12 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+disease.db filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY . .
+
+
+# Run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"] 

README.md

@@ -1,10 +1,38 @@
----
-title: Qwendr
-emoji: 🌍
-colorFrom: purple
-colorTo: blue
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Medical Symptom Checker
+
+An interactive medical symptom checker that helps users explore symptoms and related diseases using vector similarity search and a database of medical conditions.
+
+## Features
+
+- Enter symptoms to find related diseases
+- See semantically similar symptoms through vector search
+- Discover related symptoms from matching diseases
+- Interactive UI for refining symptom selection
+
+## How It Works
+
+1. **Vector Search**: Uses Sentence Transformers and ChromaDB to find semantically similar symptoms
+2. **Database Matching**: Finds diseases that match all selected symptoms
+3. **Related Symptoms**: Shows other symptoms from matching diseases
+
+## Usage
+
+Enter a symptom in the search box (e.g., "fever", "cough", "headache") and click "Search" or press Enter.
+
+The system will:
+1. Show diseases that have that symptom
+2. Display semantically similar symptoms
+3. Show other symptoms from the matching diseases
+
+Click on any symptom in the "Similar Symptoms" or "Related Symptoms" sections to add it to your selection. This will narrow down the diseases to those that have ALL selected symptoms.
+
+## Technical Details
+
+- **Frontend**: HTML, CSS, JavaScript
+- **Backend**: FastAPI, SQLite
+- **Vector Search**: Sentence Transformers, ChromaDB
+- **Data**: Diseases and symptoms dataset
+
+## Deployment
+
+This application is deployed on Hugging Face Spaces.

app.py

@@ -0,0 +1,68 @@
+from fastapi import FastAPI, Query, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from utils.vector_search import get_similar_symptoms
+from utils.sql_queries import get_diseases_by_symptoms, get_related_symptoms
+import sqlite3
+
+app = FastAPI()
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allow all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allow all methods
+    allow_headers=["*"],  # Allow all headers
+)
+
+templates = Jinja2Templates(directory="templates")
+
+@app.get("/", response_class=HTMLResponse)
+def index(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+# Helper function to check if a symptom exists in the database
+def is_valid_symptom(symptom):
+    conn = sqlite3.connect("disease.db")
+    cur = conn.cursor()
+    cur.execute("SELECT COUNT(*) FROM symptom WHERE name = ?", (symptom,))
+    count = cur.fetchone()[0]
+    conn.close()
+    return count > 0
+
+@app.get("/search")
+def search(symptom: str, selected: list[str] = Query([])):
+    # Get similar symptoms from vector search
+    similar = get_similar_symptoms(symptom)
+    
+    # Check if the exact symptom exists in our database
+    if is_valid_symptom(symptom):
+        # Use the exact symptom if it exists
+        search_symptoms = [symptom] + selected
+    else:
+        # Otherwise, try to use the first similar symptom that exists in our database
+        valid_symptom_found = False
+        for sim in similar:
+            if is_valid_symptom(sim):
+                search_symptoms = [sim] + selected
+                valid_symptom_found = True
+                break
+        
+        # If no valid symptom found, just use all similar symptoms
+        if not valid_symptom_found:
+            search_symptoms = similar + selected
+    
+    # Get diseases that have ALL the selected search symptoms
+    diseases = get_diseases_by_symptoms(search_symptoms)
+    
+    # Get related symptoms from the matching diseases, excluding already selected symptoms
+    suggestions = get_related_symptoms(diseases, exclude=search_symptoms)
+
+    return {
+        "matching_diseases": diseases,
+        "related_symptoms": suggestions,
+        "semantic_matches": similar
+    }

disease.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e27f4415320952a05ceca7b615c053bc08b151ed3963e0ec714d431f519a2b1d
+size 172032

main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from llamadr!")
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,7 @@
+[project]
+name = "llamadr"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = []

requirements.txt

@@ -0,0 +1,8 @@
+fastapi>=0.95.0
+uvicorn>=0.22.0
+jinja2>=3.1.2
+qdrant-client>=1.13.3
+sentence-transformers>=2.2.2
+datasets>=2.12.0
+pandas>=2.0.0
+python-dotenv>=1.1.0

templates/index.html

@@ -0,0 +1,389 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+  <title>Medical Symptom Checker</title>
+  <style>
+    body {
+      font-family: 'Segoe UI', sans-serif;
+      background: linear-gradient(135deg, #fdfbfb, #ebedee);
+      margin: 0;
+      padding: 40px 20px;
+      color: #333;
+    }
+
+    h1 {
+      text-align: center;
+      font-size: 2.5rem;
+      margin-bottom: 30px;
+      background: linear-gradient(to right, #3b82f6, #9333ea);
+      -webkit-background-clip: text;
+      background-clip: text;
+      -webkit-text-fill-color: transparent;
+    }
+
+    .search-container {
+      text-align: center;
+      margin-bottom: 30px;
+    }
+
+    input[type="text"] {
+      padding: 12px 20px;
+      width: 60%;
+      max-width: 500px;
+      border-radius: 30px;
+      border: 1px solid #ccc;
+      box-shadow: 0 4px 10px rgba(0,0,0,0.05);
+      transition: all 0.3s ease;
+    }
+
+    input[type="text"]:focus {
+      outline: none;
+      border-color: #6366f1;
+      box-shadow: 0 4px 15px rgba(99,102,241,0.2);
+    }
+
+    button {
+      padding: 12px 25px;
+      margin-left: 10px;
+      border: none;
+      border-radius: 30px;
+      background: linear-gradient(to right, #3b82f6, #9333ea);
+      color: white;
+      cursor: pointer;
+      font-weight: bold;
+      box-shadow: 0 4px 10px rgba(0,0,0,0.1);
+      transition: background 0.3s ease;
+    }
+
+    button:hover {
+      background: linear-gradient(to right, #2563eb, #7e22ce);
+    }
+
+    .selected-symptoms {
+      display: flex;
+      flex-wrap: wrap;
+      justify-content: center;
+      gap: 10px;
+      margin-bottom: 30px;
+    }
+
+    .symptom-tag {
+      background: #e0e7ff;
+      color: #1e40af;
+      padding: 8px 15px;
+      border-radius: 20px;
+      display: flex;
+      align-items: center;
+      animation: fadeIn 0.3s ease;
+    }
+
+    .remove-symptom {
+      margin-left: 10px;
+      cursor: pointer;
+      color: #555;
+      font-weight: bold;
+    }
+
+    .container {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 20px;
+      justify-content: center;
+    }
+
+    .panel {
+      flex: 1 1 300px;
+      background: white;
+      border-radius: 15px;
+      padding: 20px;
+      box-shadow: 0 10px 20px rgba(0,0,0,0.05);
+      transition: transform 0.2s ease;
+      animation: fadeIn 0.5s ease;
+    }
+
+    .panel:hover {
+      transform: translateY(-5px);
+    }
+
+    .panel h2 {
+      margin-top: 0;
+      background: linear-gradient(to right, #2563eb, #9333ea);
+      -webkit-background-clip: text;
+      background-clip: text;
+      -webkit-text-fill-color: transparent;
+      font-size: 1.5rem;
+    }
+
+    ul {
+      list-style: none;
+      padding: 0;
+    }
+
+    li {
+      padding: 10px 0;
+      border-bottom: 1px solid #eee;
+      transition: background 0.2s ease;
+    }
+
+    .clickable {
+      color: #6366f1;
+      cursor: pointer;
+    }
+
+    .clickable:hover {
+      text-decoration: underline;
+    }
+
+    #error-notification {
+      background-color: #fee2e2;
+      color: #b91c1c;
+      padding: 12px 20px;
+      border-radius: 8px;
+      margin: 0 auto 20px auto;
+      max-width: 600px;
+      text-align: center;
+      display: none;
+    }
+
+    @keyframes fadeIn {
+      from { opacity: 0; transform: translateY(10px); }
+      to { opacity: 1; transform: translateY(0); }
+    }
+
+    @media screen and (max-width: 768px) {
+      input[type="text"] {
+        width: 80%;
+      }
+      .container {
+        flex-direction: column;
+        align-items: stretch;
+      }
+    }
+  </style>
+</head>
+<body>
+  <h1>Medical Symptom Checker</h1>
+
+  <div class="search-container">
+    <input type="text" id="symptom-search" placeholder="Enter a symptom..."/>
+    <button id="search-button">Search</button>
+  </div>
+
+  <div id="error-notification"></div>
+
+  <div class="selected-symptoms" id="selected-symptoms">
+    <!-- Selected symptoms will appear here -->
+  </div>
+
+  <div class="container">
+    <div class="panel">
+      <h2>Matching Diseases</h2>
+      <ul id="diseases-list"></ul>
+    </div>
+    <div class="panel">
+      <h2>Similar Symptoms</h2>
+      <ul id="similar-list"></ul>
+    </div>
+    <div class="panel">
+      <h2>Related Symptoms</h2>
+      <ul id="related-list"></ul>
+    </div>
+  </div>
+
+  <!-- Keep your JavaScript at the bottom (same as before, or I can refactor it too if you want) -->
+  <script>
+        // Store selected symptoms
+        let selectedSymptoms = [];
+        
+        // DOM elements
+        const searchInput = document.getElementById('symptom-search');
+        const searchButton = document.getElementById('search-button');
+        const selectedSymptomsDiv = document.getElementById('selected-symptoms');
+        const diseasesList = document.getElementById('diseases-list');
+        const similarList = document.getElementById('similar-list');
+        const relatedList = document.getElementById('related-list');
+        const errorElement = document.getElementById('error-notification');
+        
+        // Function to show error message
+        function showError(message) {
+            errorElement.textContent = message;
+            errorElement.style.display = 'block';
+            setTimeout(() => {
+                errorElement.style.display = 'none';
+            }, 5000);
+        }
+        
+        // New function to handle both initial search and updates after selections
+        async function performSearch(inputSymptom) {
+            // Clear any previous errors
+            errorElement.style.display = 'none';
+            
+            try {
+                // Create base URL with inputSymptom if provided, otherwise use first selected symptom
+                let symptomParam = inputSymptom;
+                if (!symptomParam && selectedSymptoms.length > 0) {
+                    symptomParam = selectedSymptoms[0];
+                }
+                
+                if (!symptomParam) return; // Exit if no symptom to search
+                
+                let url = `${window.location.origin}/search?symptom=${encodeURIComponent(symptomParam)}`;
+                
+                // Add remaining selected symptoms to query
+                if (selectedSymptoms.length > 0) {
+                    selectedSymptoms.forEach((s, index) => {
+                        // Skip the first one if it's the same as symptomParam
+                        if (index === 0 && s === symptomParam) return;
+                        url += `&selected=${encodeURIComponent(s)}`;
+                    });
+                }
+                
+                const response = await fetch(url);
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                
+                const data = await response.json();
+                
+                displayResults(data);
+                
+                // Clear search input only if this was initiated from the search box
+                if (inputSymptom) {
+                    searchInput.value = '';
+                }
+            } catch (error) {
+                showError(`Error searching for symptom: ${error.message}. Please try again.`);
+                console.error('Error fetching data:', error);
+            }
+        }
+        
+        // Update search function to use the new performSearch function
+        async function searchSymptoms() {
+            const symptom = searchInput.value.trim();
+            if (!symptom) return;
+            performSearch(symptom);
+        }
+        
+        // Display results
+        function displayResults(data) {
+            // Update diseases list
+            diseasesList.innerHTML = '';
+            if (!data.matching_diseases || data.matching_diseases.length === 0) {
+                diseasesList.innerHTML = '<li>No matching diseases found</li>';
+            } else {
+                data.matching_diseases.forEach(disease => {
+                    diseasesList.innerHTML += `<li>${escapeHTML(disease)}</li>`;
+                });
+            }
+            
+            // Update similar symptoms
+            similarList.innerHTML = '';
+            if (data.semantic_matches && data.semantic_matches.length > 0) {
+                data.semantic_matches.forEach(symptom => {
+                    if (!selectedSymptoms.includes(symptom)) {
+                        similarList.innerHTML += `<li class="clickable" onclick="addSymptom('${escapeJS(symptom)}')">${escapeHTML(symptom)}</li>`;
+                    }
+                });
+            } else {
+                similarList.innerHTML = '<li>No similar symptoms found</li>';
+            }
+            
+            // Update related symptoms - sort them alphabetically
+            relatedList.innerHTML = '';
+            if (!data.related_symptoms || data.related_symptoms.length === 0) {
+                relatedList.innerHTML = '<li>No related symptoms found</li>';
+            } else {
+                // Sort the related symptoms alphabetically
+                const sortedSymptoms = [...data.related_symptoms].sort((a, b) => a.localeCompare(b));
+                
+                sortedSymptoms.forEach(symptom => {
+                    if (!selectedSymptoms.includes(symptom)) {
+                        relatedList.innerHTML += `<li class="clickable" onclick="addSymptom('${escapeJS(symptom)}')">${escapeHTML(symptom)}</li>`;
+                    }
+                });
+            }
+            
+            // Update selected symptoms
+            updateSelectedSymptoms();
+        }
+        
+        // Helper function to escape HTML
+        function escapeHTML(str) {
+            return str
+                .replace(/&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/"/g, '&quot;')
+                .replace(/'/g, '&#39;');
+        }
+        
+        // Helper function to escape strings for JavaScript
+        function escapeJS(str) {
+            return str
+                .replace(/\\/g, '\\\\')
+                .replace(/'/g, "\\'")
+                .replace(/"/g, '\\"')
+                .replace(/\n/g, '\\n')
+                .replace(/\r/g, '\\r')
+                .replace(/\t/g, '\\t');
+        }
+        
+        // Add a symptom to the selected list
+        function addSymptom(symptom) {
+            if (!selectedSymptoms.includes(symptom)) {
+                selectedSymptoms.push(symptom);
+                updateSelectedSymptoms();
+                
+                // Instead of calling searchSymptoms which expects input from search box,
+                // directly make a request with the current selected symptoms
+                performSearch(null);
+            }
+        }
+        
+        // Remove a symptom from the selected list
+        function removeSymptom(symptom) {
+            selectedSymptoms = selectedSymptoms.filter(s => s !== symptom);
+            updateSelectedSymptoms();
+            if (selectedSymptoms.length > 0) {
+                performSearch(null);
+            } else {
+                // Clear results if no symptoms are selected
+                diseasesList.innerHTML = '<li>Enter a symptom to get started</li>';
+                similarList.innerHTML = '';
+                relatedList.innerHTML = '';
+            }
+        }
+        
+        // Update the selected symptoms display
+        function updateSelectedSymptoms() {
+            selectedSymptomsDiv.innerHTML = '';
+            selectedSymptoms.forEach(symptom => {
+                const tag = document.createElement('div');
+                tag.className = 'symptom-tag';
+                tag.innerHTML = `
+                    ${escapeHTML(symptom)}
+                    <span class="remove-symptom" onclick="removeSymptom('${escapeJS(symptom)}')">×</span>
+                `;
+                selectedSymptomsDiv.appendChild(tag);
+            });
+        }
+        
+        // Event listeners
+        searchButton.addEventListener('click', searchSymptoms);
+        searchInput.addEventListener('keypress', function(e) {
+            if (e.key === 'Enter') {
+                searchSymptoms();
+            }
+        });
+        
+        // Initialize
+        diseasesList.innerHTML = '<li>Enter a symptom to get started</li>';
+    
+    // Paste your exact same JS from earlier here — no changes needed.
+    // Let me know if you'd like animation when adding/removing tags.
+  </script>
+</body>
+</html>

utils/sql_queries.py

@@ -0,0 +1,77 @@
+import sqlite3
+
+def get_diseases_by_symptoms(symptoms):
+    """
+    Get diseases that have ALL the given symptoms.
+    
+    Parameters:
+    - symptoms: List of symptom names
+    """
+    if not symptoms:
+        return []
+        
+    conn = sqlite3.connect("disease.db")
+    cur = conn.cursor()
+
+    try:
+        placeholder = ",".join(["?"] * len(symptoms))
+        
+        # Find diseases that have ALL the symptoms
+        query = f"""
+            SELECT d.name
+            FROM disease d
+            WHERE (
+                SELECT COUNT(DISTINCT s.name)
+                FROM disease_symptom ds
+                JOIN symptom s ON s.id = ds.symptom_id
+                WHERE ds.disease_id = d.id AND s.name IN ({placeholder})
+            ) = ?
+        """
+        
+        cur.execute(query, symptoms + [len(symptoms)])
+        result = [row[0] for row in cur.fetchall()]
+        return result
+    except Exception as e:
+        print(f"SQL Error in get_diseases_by_symptoms: {e}")
+        return []
+    finally:
+        conn.close()
+
+def get_related_symptoms(disease_names, exclude=[]):
+    """
+    Get ALL symptoms from the specified diseases, excluding the ones provided.
+    
+    Parameters:
+    - disease_names: List of disease names to get symptoms from
+    - exclude: List of symptom names to exclude from the results
+    """
+    if not disease_names:
+        return []
+
+    conn = sqlite3.connect("disease.db")
+    cur = conn.cursor()
+
+    try:
+        placeholder = ",".join(["?"] * len(disease_names))
+        exclude_clause = ""
+        if exclude:
+            exclude_placeholder = ",".join(["?"] * len(exclude))
+            exclude_clause = f"AND s.name NOT IN ({exclude_placeholder})"
+        
+        # Get ALL OTHER symptoms from the matching diseases
+        query = f"""
+            SELECT DISTINCT s.name 
+            FROM symptom s
+            JOIN disease_symptom ds ON s.id = ds.symptom_id
+            JOIN disease d ON d.id = ds.disease_id
+            WHERE d.name IN ({placeholder}) {exclude_clause}
+        """
+        
+        cur.execute(query, disease_names + (exclude if exclude else []))
+        result = [row[0] for row in cur.fetchall()]
+        return result
+    except Exception as e:
+        print(f"SQL Error in get_related_symptoms: {e}")
+        return []
+    finally:
+        conn.close()

utils/vector_search.py

@@ -0,0 +1,37 @@
+from qdrant_client import QdrantClient
+from sentence_transformers import SentenceTransformer
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Initialize Qdrant Cloud client
+url=os.environ.get("QDRANT_URL")
+api_key=os.environ.get("QDRANT_API_KEY")
+qdrant_client = QdrantClient(
+        url=url,  # Use environment variable
+        api_key=api_key,  # Use environment variable
+    timeout=30.0
+)
+
+# Initialize SentenceTransformer model
+model = SentenceTransformer("all-MiniLM-L6-v2")
+
+# Collection name (must match the one used during upsert)
+collection_name = "symptoms"
+
+def get_similar_symptoms(symptom):
+    # Encode the input symptom
+    vector = model.encode(symptom)
+    
+    # Perform similarity search
+    results = qdrant_client.search(
+        collection_name=collection_name,
+        query_vector=vector.tolist(),
+        limit=5,  # Return top 5 similar symptoms
+        with_payload=True  # Include payload (e.g., symptom name)
+    )
+    
+    # Extract symptom names from results
+    similar_symptoms = [result.payload["name"] for result in results]
+    return similar_symptoms