Upload 6 files

.env

@@ -0,0 +1,4 @@
+GEMINI_API_KEY=AIzaSyAr-nyhXQ3-O4ZkfzomHP_7cRmrRoNyOXg
+GOOGLE_API_KEY=AIzaSyAr-nyhXQ3-O4ZkfzomHP_7cRmrRoNyOXg
+OPENAI_API_URL=https://api.groq.com/openai/v1
+MODEL=openai/gpt-oss-20b

Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.12-slim
+
+# Create non-root user
+RUN useradd -m appuser
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy project files
+COPY . .
+
+# Change ownership to non-root user
+RUN chown -R appuser:appuser /app
+
+# Switch to non-root user
+USER appuser
+
+# Expose only main app port
+EXPOSE 5000
+
+# Start all three apps
+CMD ["sh", "-c", "\
+    gunicorn -b 0.0.0.0:5000 main:app & \
+    gunicorn -b 0.0.0.0:5001 disease:app & \
+    gunicorn -b 0.0.0.0:5002 medicine:app && \
+    wait \
+"]

disease.py

@@ -0,0 +1,145 @@
+import os
+import json
+from flask import Flask, request, jsonify
+import google.generativeai as genai
+import dotenv
+
+dotenv.load_dotenv()
+
+# --- Configuration ---
+FACT_SHEET_DIR = "Text_Files"
+
+# --- System Instruction for the Gemini Model ---
+# This instruction guides the model's behavior, ensuring it stays on task
+# and uses only the tools and information we provide.
+SYSTEM_INSTRUCTION = """
+You are a helpful Health Fact Sheet Assistant. Your role is to answer questions
+about specific diseases based ONLY on the information contained in the fact sheets
+provided to you through the get_disease_fact_sheet tool. 
+Generate response in same language as user query.
+
+Follow these rules strictly:
+1. Use the fact sheet for answers whenever possible.
+2. To get information, call the get_disease_fact_sheet function.
+3. If the fact sheet doesn't cover the answer, reply using general knowledge and include a disclaimer.
+4. First, check the user's query to see which disease it refers to, then fetch that fact sheet.
+5. If the query isn't about a specific disease, reply using general knowledge with a disclaimer.
+6. Keep responses clear, short, and simple. Don't mention the source of the information.
+"""
+
+# Configure the Google Generative AI SDK.
+try:
+    # This will automatically look for the GOOGLE_API_KEY environment variable.
+    genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+
+    # Initialize the Gemini model with the system instruction.
+    # We recommend using a model that is highly optimized for tool use.
+    model = genai.GenerativeModel(
+        'gemini-1.5-flash',
+        system_instruction=SYSTEM_INSTRUCTION
+    )
+except Exception as e:
+    print(f"Error configuring Google Generative AI: {e}")
+    print("Please make sure your GOOGLE_API_KEY environment variable is set.")
+    model = None
+
+# --- Flask App Initialization ---
+app = Flask(__name__)
+
+
+# --- Helper Functions (Tool Implementation) ---
+
+def get_available_diseases():
+    """Scans the directory for available disease fact sheets."""
+    if not os.path.isdir(FACT_SHEET_DIR):
+        return []
+    # Create a clean list of names from filenames (e.g., "Chickenpox_and_Shingles.txt" -> "Chickenpox and Shingles")
+    return [os.path.splitext(f)[0].replace('_', ' ') for f in os.listdir(FACT_SHEET_DIR) if f.endswith(".txt")]
+
+def get_disease_fact_sheet(disease_name: str):
+    """
+    This is the actual Python function that gets executed by the model.
+    It reads the content of a specific disease's text file from the local directory.
+    """
+    print(f"--- TOOL EXECUTION: Running get_disease_fact_sheet(disease_name='{disease_name}') ---")
+    # Convert the friendly name back to a filename format
+    filename = disease_name.replace(' ', '_') + ".txt"
+    filepath = os.path.join(FACT_SHEET_DIR, filename)
+
+    if os.path.exists(filepath):
+        with open(filepath, 'r', encoding='utf-8') as f:
+            content = f.read()
+        print(f"--- SUCCESS: Found and read '{filename}' ---")
+        # Return a dictionary, which will be implicitly handled by the Gemini SDK
+        return {"disease": disease_name, "content": content}
+    else:
+        print(f"--- ERROR: Fact sheet not found for '{disease_name}' ---")
+        return {"error": f"Fact sheet not found for the disease: {disease_name}."}
+
+
+# --- Main API Endpoint ---
+
+@app.route('/ask', methods=['POST'])
+def ask_question():
+    """
+    Handles user queries by orchestrating the interaction with the Gemini model,
+    which is guided by the system instruction to use the provided tools and context.
+    """
+    if not model:
+        return jsonify({"error": "Gemini client is not configured. Check your API key."}), 500
+
+    data = request.get_json()
+    if not data or 'query' not in data:
+        return jsonify({"error": "Request must be JSON and contain a 'query' field."}), 400
+
+    user_query = data['query']
+    print(f"\n=================================================")
+    print(f"Received new query: '{user_query}'")
+    print(f"=================================================")
+
+
+    available_diseases = get_available_diseases()
+    if not available_diseases:
+        return jsonify({"error": f"No fact sheets found in the '{FACT_SHEET_DIR}' directory."}), 500
+
+    # === Orchestration with Gemini ===
+    try:
+        # We start a chat session. The model will automatically handle calling the
+        # function and using its output to generate a final answer, thanks to
+        # automatic function calling and the system instruction.
+        chat = model.start_chat(enable_automatic_function_calling=True)
+
+        # Construct a more informative prompt for the model.
+        prompt = f"""
+        Here is the user's question: '{user_query}'
+
+        Please use your tools to answer it. The available diseases you can look up are:
+        {', '.join(available_diseases)}
+        """
+
+        print("--- Sending request to Gemini... ---")
+        # Send the user's query and the definitions of the available tools
+        response = chat.send_message(
+            prompt,
+            tools=[get_disease_fact_sheet] # Pass the actual function reference
+        )
+
+        final_answer = response.text
+        print(f"--- Gemini's Final Answer: ---\n{final_answer}\n")
+        return jsonify({"response": final_answer})
+
+    except Exception as e:
+        print(f"--- An unexpected error occurred: {e} ---")
+        return jsonify({"error": f"Gemini API Error: {e}"}), 500
+
+
+# --- To run the app ---
+if __name__ == '__main__':
+    # Make sure the Text_Files directory exists before starting
+    if not os.path.isdir(FACT_SHEET_DIR):
+        print(f"CRITICAL ERROR: The directory '{FACT_SHEET_DIR}' does not exist.")
+        print("Please create it and populate it with the disease .txt files.")
+    else:
+        print("Starting Flask server...")
+        print(f"Fact sheets loaded for: {', '.join(get_available_diseases())}")
+        app.run(debug=True, port=5001)

main.py

@@ -0,0 +1,192 @@
+import os
+import uuid
+import json
+import requests
+from flask import Flask, request, jsonify
+from werkzeug.utils import secure_filename
+import google.generativeai as genai
+from dotenv import load_dotenv
+from flask_cors import CORS
+
+
+# Step 1: API Key aur Environment Setup
+load_dotenv()
+try:
+    genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+except TypeError:
+    print("ERROR: Google API Key nahi mila.")
+    print("Ek .env file banayein aur usmein 'GOOGLE_API_KEY=your_key_here' likhein.")
+    exit()
+
+app = Flask(__name__)
+CORS(app)
+
+# Step 2: API Endpoints aur Session Storage
+API_ENDPOINTS = {
+    "skin_disease": "https://your-api-domain.com/skin-disease-detection",
+    "medicine_info": "http://localhost:5002/api/query",
+    "report_reading": "https://your-api-domain.com/report-reading",
+    "disease_query": "http://localhost:5001/ask"
+}
+SESSIONS = {}
+
+# Step 3: Gemini se Query Classify karne ka Function
+def classify_query_with_gemini(query: str):
+    """User ki query ko Gemini API ka istemal karke classify karta hai."""
+    model = genai.GenerativeModel('gemini-2.5-flash-lite')
+    
+    # *** PROMPT HAS BEEN IMPROVED ***
+    prompt = f"""
+    Analyze the user's medical query and classify it into one of the following categories:
+    - skin_disease: For queries about skin conditions, rashes, moles, spots, or any visible symptoms on the skin.
+    - medicine_info: For query about medicine(like how to use it, side effects, etc.) and also questions about a specific Medicine shown in attached image (optional) .
+    - report_reading: For queries asking to interpret or explain a medical report, lab test, or blood work from an image.
+    - disease_query: For general questions about diseases, symptoms, causes, or treatments.
+
+    Based on the classification, determine if an image is essential to answer the query accurately.
+    Generate response in English only.
+
+    The user query is: 
+    ---START OF QUERY---
+    {query}
+    ---END OF QUERY---
+
+    Provide the output ONLY in a valid JSON format with two keys: "category" (string) and "image_required" (boolean).
+
+    Example 1:
+    Query: "what are the symptoms of typhoid"
+    Output: {{"category": "disease_query", "image_required": false}}
+
+    Example 2:
+    Query: "I have a red circular rash on my arm, what is it?"
+    Output: {{"category": "skin_disease", "image_required": true}}
+
+    Example 3:
+    Query: "Can you tell me what this lab report says?"
+    Output: {{"category": "report_reading", "image_required": true}}
+
+    Example 4:
+    Query: "What is this white pill with 'IP 204' written on it?"
+    Output: {{"category": "medicine_info", "image_required": true}}
+    """
+    
+    try:
+        response = model.generate_content(prompt)
+        cleaned_text = response.text.strip().replace('```json', '').replace('```', '')
+        result = json.loads(cleaned_text)
+        return result
+    except Exception as e:
+        print(f"Gemini API call ya JSON parsing mein error: {e}")
+        return None
+
+# Step 4: API Routes (Endpoints)
+@app.route('/start_session', methods=['POST'])
+def start_session():
+    session_id = str(uuid.uuid4())
+    SESSIONS[session_id] = {"status": "started"}
+    print(f"Session started: {session_id}")
+    return jsonify({"session_id": session_id}), 200
+
+@app.route('/process_query', methods=['POST'])
+def process_query():
+    data = request.get_json()
+    session_id = data.get('session_id')
+    query = data.get('query')
+
+    if not session_id or session_id not in SESSIONS:
+        return jsonify({"error": "Invalid or missing session_id"}), 400
+    if not query:
+        return jsonify({"error": "Query is required"}), 400
+
+    print(f"Session {session_id}: Query received: '{query}'")
+    classification = classify_query_with_gemini(query)
+    
+    if not classification:
+        return jsonify({"error": "Could not classify the query."}), 500
+
+    SESSIONS[session_id]['classification'] = classification
+    SESSIONS[session_id]['query'] = query
+    
+    if classification.get('image_required'):
+        print(f"Session {session_id}: Image required for category '{classification.get('category')}'")
+        return jsonify({
+            "status": "image_required",
+            "message": "Please send the request to /process_with_image with the required photo."
+        }), 200
+    else:
+        print(f"Session {session_id}: No image required. Forwarding to '{classification.get('category')}' API.")
+        # Asli API ko call karein (Abhi ke liye mock response)
+        # Session se query aur classification nikalein
+        query = SESSIONS[session_id].get('query')
+        classification = SESSIONS[session_id].get('classification')
+        category = classification['category']
+        endpoint_url = API_ENDPOINTS.get(category)
+        response = requests.post(endpoint_url, json={"query": query}) or requests.post(endpoint_url, data={"query": query}) or requests.post(endpoint_url, files={"query": query}) or requests.post(endpoint_url, payload={"query": query})
+        del SESSIONS[session_id]
+        print(f"Session {session_id} closed.")
+        return jsonify({
+            "status": "success",
+            "response": response.json(),
+            "data": f"Information about '{query}': This is a tuned response from the {classification.get('category')} service."
+        })
+
+@app.route('/process_with_image', methods=['POST'])
+def process_with_image():
+    session_id = request.form.get('session_id')
+    
+    if not session_id or session_id not in SESSIONS:
+        return jsonify({"error": "Invalid or missing session_id"}), 400
+    
+    if 'photo' not in request.files:
+        return jsonify({"error": "No photo file found in the request"}), 400
+        
+    file = request.files['photo']
+    if file.filename == '':
+        return jsonify({"error": "No selected file"}), 400
+
+    # Session se query aur classification nikalein
+    query = SESSIONS[session_id].get('query')
+    classification = SESSIONS[session_id].get('classification')
+    category = classification['category']
+    endpoint_url = API_ENDPOINTS.get(category)
+    
+    print(f"Session {session_id}: Image received. Preparing to forward to '{category}' API.")
+
+    # *** NEW: FORWARDING LOGIC THAT MATCHES YOUR CURL COMMAND ***
+    # The file object from Flask needs its stream to be readable by `requests`
+    # We pass the file stream, filename, and mimetype to requests
+    # The dictionary key 'file' matches the '-F file=@...' part of your curl command
+    files_payload = {'file': (file.filename, file.stream, file.mimetype)}
+    
+    # The dictionary key 'query' matches the '-F query=...' part
+    data_payload = {'query': query}
+
+    try:
+        # NOTE: Neeche di gayi line asli API call hai.
+        # Jab aapka backend service (e.g., http://localhost:5002/api/query) taiyaar ho,
+        # to is line ko uncomment kar dein.
+        
+        response_from_service = requests.post(endpoint_url, files=files_payload, data=data_payload)
+        response_from_service.raise_for_status() # Agar 4xx/5xx error ho to exception raise karega
+        tuned_response = response_from_service.json() # Assume service returns JSON
+
+        # Abhi ke liye, hum ek mock response bhej rahe hain
+        mock_response = {
+            "status": "success",
+            "response": tuned_response,
+            "data": f"Analysis for '{query}' based on your image: This is a tuned MOCK response from the {category} service."
+        }
+        
+        # Session close karein
+        del SESSIONS[session_id]
+        print(f"Session {session_id} closed.")
+        
+        return jsonify(mock_response)
+
+    except requests.exceptions.RequestException as e:
+        del SESSIONS[session_id]
+        print(f"Session {session_id} closed after failed API call.")
+        return jsonify({"status": "error", "message": f"Backend service call failed: {e}"}), 503
+
+if __name__ == '__main__':
+    app.run(debug=True, port=5000)

medicine.py

@@ -0,0 +1,193 @@
+import os
+import io
+from flask import Flask, request, jsonify
+from PIL import Image
+from dotenv import load_dotenv
+import google.generativeai as genai
+import json
+
+# --- INITIAL SETUP ---
+
+# Load environment variables from the .env file
+load_dotenv()
+
+# Configure the Gemini API with your key
+api_key = os.getenv("GOOGLE_API_KEY")
+if not api_key:
+    raise ValueError("GOOGLE_API_KEY not found. Please set it in your .env file.")
+genai.configure(api_key=api_key)
+
+# Initialize the Flask application
+app = Flask(__name__)
+
+# --- CONFIGURATION ---
+TEXT_FILES_DIR = "Text_Files"
+# Allowed file extensions for image uploads
+ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif'}
+
+# Get a list of available knowledge base files
+try:
+    AVAILABLE_FILES = [f for f in os.listdir(TEXT_FILES_DIR) if f.endswith('.txt')]
+    if not AVAILABLE_FILES:
+        raise FileNotFoundError("No .txt files found in the 'Text_Files' directory.")
+except FileNotFoundError:
+    print("Warning: 'Text_Files' directory not found. The API will not have a knowledge base.")
+    AVAILABLE_FILES = []
+
+# --- HELPER FUNCTIONS ---
+
+def allowed_file(filename):
+    return '.' in filename and \
+           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+def find_relevant_file(topic: str) -> str | None:
+    """
+    Uses Gemini to determine the most relevant file for a given topic.
+    This is more robust than simple keyword matching.
+    """
+    if not AVAILABLE_FILES:
+        return None
+        
+    try:
+        model = genai.GenerativeModel('gemini-2.5-flash-lite')
+        prompt = f"""
+        From the following list of files, which one is the most relevant for a query about "{topic}"?
+        Respond with only the single, most relevant filename dont include any other text.
+
+        File List:
+        {', '.join(AVAILABLE_FILES)}
+        """
+        response = model.generate_content(prompt)
+        # Clean up the response to get just the filename
+        filename = response.text.strip().replace("`", "")
+        
+        if filename in AVAILABLE_FILES:
+            print(f"Gemini identified relevant file: {filename} for topic: {topic}")
+            return filename
+        else:
+            print(f"Warning: Gemini suggested a file that doesn't exist: {filename}")
+            return None
+    except Exception as e:
+        print(f"Error in find_relevant_file: {e}")
+        return None
+
+def get_context_from_file(filename: str) -> str | None:
+    """Reads and returns the content of a specified text file."""
+    filepath = os.path.join(TEXT_FILES_DIR, filename)
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return f.read()
+    except FileNotFoundError:
+        return None
+
+# --- CORE API LOGIC ---
+
+@app.route('/api/query', methods=['POST'])
+def handle_query():
+    """
+    Main API endpoint to handle user queries.
+    Accepts form data with 'query' (required) and 'file' (optional image upload).
+    """
+    # 1. Get and validate the request data
+    form_data = request.form
+    if not form_data or 'query' not in form_data:
+        return jsonify({"error": "Missing 'query' in request"}), 400
+
+    user_query = form_data.get('query')
+    medicine_topic = None
+    
+    # 2. Handle File Upload (if provided)
+    if 'file' in request.files:
+        file = request.files['file']
+        if file.filename == '':
+            return jsonify({"error": "No selected file"}), 400
+            
+        if file and allowed_file(file.filename):
+            try:
+                print("Image file received. Identifying medicine from image...")
+                # Read the uploaded file directly
+                img = Image.open(file.stream)
+                
+                # Use the vision model to identify the medicine
+                vision_model = genai.GenerativeModel('gemini-2.5-flash')
+                prompt = ["""Identify the specific formula or Rx or medicine name or  primary subject from this image.""", img]
+                response = vision_model.generate_content(prompt)
+                
+                medicine_topic = response.text.strip()
+                print(f"Medicine identified from image: {medicine_topic}")
+
+            except Exception as e:
+                print(f"Error processing image: {e}")
+                return jsonify({"error": "Failed to process the uploaded image."}), 500
+        else:
+            return jsonify({"error": f"Invalid file type. Allowed types: {', '.join(ALLOWED_EXTENSIONS)}"}), 400
+    
+    # 3. Handle Text-Only Input (or use the topic identified from the image)
+    if not medicine_topic:
+        print("No image provided. Identifying topic from text query...")
+        try:
+            model = genai.GenerativeModel('gemini-2.5-flash')
+            prompt = f"""
+            From the user query '{user_query}', identify the main medicine or medical topic.
+            Respond with only the name of the topic or medicine (e.g., 'Ibuprofen', 'Antacids', 'Cough Suppressants').
+
+            """
+            response = model.generate_content(prompt)
+            medicine_topic = response.text.strip()
+            print(f"Topic identified from query: {medicine_topic}")
+        except Exception as e:
+            print(f"Error identifying topic from query: {e}")
+            return jsonify({"error": "Failed to understand the query topic."}), 500
+
+    # 4. Find the Relevant Knowledge Base File
+    relevant_filename = find_relevant_file(medicine_topic)
+    if not relevant_filename:
+        return jsonify({"error": f"Could not find a relevant information file for '{medicine_topic}'."}), 404
+
+    # 5. Get the Context from the File
+    context = get_context_from_file(relevant_filename)
+    if not context:
+        return jsonify({"error": "Failed to read the content of the relevant file."}), 500
+
+    # 6. Generate the Final Response Using the Context
+    try:
+        model = genai.GenerativeModel('gemini-2.5-flash-lite')
+        final_prompt = f"""
+        You are a helpful medical information assistant.
+        Your task is to answer the user's question based ONLY on the provided context from the guide.
+        Generate response in same language as user query.
+        If there have no information about any medicine then prepare response using given context and your knowlage base make sure there have satisfied answer.
+        if there have any relevent medicine of provided medicine in context then prepare answer using that context.
+        Answer should be in simple language and short not more than 200 words.
+        If the answer cannot be found in the provided context, then you have to prepare response using your knowlage base make sure there have satisfied answer.
+        ---important---
+        Dont tell user to i have no information about that medicine. inplace of that prepare answer using given context and your knowlage base make sure there have satisfied answer.
+        user is also provide the medicine name and description of the medicine.
+        name:{medicine_topic}
+        ---important---
+        
+        --- CONTEXT FROM THE GUIDE ---
+        {context}
+        --- END OF CONTEXT ---
+
+        USER'S QUESTION: {user_query}
+
+        YOUR ANSWER:
+        """
+        
+        final_response = model.generate_content(final_prompt)
+        
+        # 7. Return the final, context-aware response
+        return jsonify({
+            "response": final_response.text.strip(),
+            "identified_topic": medicine_topic,
+            "source_file": relevant_filename
+        })
+
+    except Exception as e:
+        print(f"Error generating final response: {e}")
+        return jsonify({"error": "An error occurred while generating the response."}), 500
+
+if __name__ == '__main__':
+    # Runs the Flask server
+    app.run(host='0.0.0.0', port=5002, debug=True)

requirements.txt

@@ -0,0 +1,5 @@
+flask
+flask-cors
+google-generativeai
+python-dotenv
+waitress