update

app/routers/agent_chat.py

@@ -24,10 +24,19 @@ class AgentChatDocument(BaseModel):
     extension: Optional[str] = None
 
 
+class AgentChatImage(BaseModel):
+    path: str
+    name: Optional[str] = None
+    type: Optional[str] = None
+    extension: Optional[str] = None
+    prompt: Optional[str] = None
+
+
 class AgentChatRequest(BaseModel):
     session_id: Optional[str] = None
     query: str
     document: Optional[AgentChatDocument] = None
+    image: Optional[AgentChatImage] = None
 
 
 async def stream_agent_response(agent_service: GoogleAgentService, query: str):
@@ -89,6 +98,7 @@ async def agent_chat(
             token=token,
             session_id=request.session_id,
             document=request.document.dict() if request.document else None,
+            image=request.image.dict() if request.image else None,
         )
     except Exception as exc:
         logger.error("Failed to initialise agent service: %s", exc, exc_info=True)

app/routers/chat.py

@@ -12,7 +12,6 @@ from pydantic import BaseModel
 from app.database.database_query import DatabaseQuery
 from app.middleware.auth import get_current_user, get_optional_user
 from app.services import ChatProcessor
-from app.services.image_processor import ImageProcessor
 from app.services.skincare_scheduler import SkinCareScheduler
 from app.services.wheel import EnvironmentalConditions
 from app.services.RAG_evaluation import RAGEvaluation
@@ -339,28 +338,93 @@ async def get_skin_care_wheel(
         )
 
 @router.post('/image_disease_search')
-async def disease_search(
+async def upload_skin_image(
+    image: UploadFile = File(...),
     session_id: str = Form(...),
-    query: str = Form(...),
+    query: str = Form(""),
     num_results: int = Form(3),
     num_images: int = Form(3),
-    image: UploadFile = File(...),
     authorization: str = Header(...),
     username: str = Depends(get_current_user)
 ):
     try:
-        token = authorization.split(" ")[1]
-        image_processor = ImageProcessor(
-            token=token,
-            session_id=session_id,
-            num_results=num_results,
-            num_images=num_images,
-            image=image
+        _ = authorization.split(" ")[1]
+
+        if not image.filename:
+            return JSONResponse(
+                status_code=400,
+                content={"status": "error", "error": "Empty image file provided"},
+            )
+
+        allowed_extensions = {
+            "jpg",
+            "jpeg",
+            "png",
+            "bmp",
+            "webp",
+            "avif",
+            "avifs",
+            "heic",
+            "heif",
+        }
+        file_extension = (
+            image.filename.rsplit('.', 1)[1].lower() if '.' in image.filename else ''
         )
-        response = image_processor.web_search(query=query)
-        return {"response": response}
+
+        if file_extension not in allowed_extensions:
+            return JSONResponse(
+                status_code=400,
+                content={
+                    "status": "error",
+                    "error": (
+                        "Unsupported image type. Allowed types: "
+                        f"{', '.join(sorted(allowed_extensions))}"
+                    ),
+                },
+            )
+
+        default_upload_root = os.path.abspath(
+            os.path.join(os.path.dirname(__file__), "..", "..", "uploads")
+        )
+        uploads_root = os.getenv('DERMAI_UPLOAD_DIR', default_upload_root)
+        session_upload_dir = os.path.join(uploads_root, session_id)
+        os.makedirs(session_upload_dir, exist_ok=True)
+
+        timestamp = datetime.utcnow().strftime('%Y%m%d%H%M%S%f')
+        sanitized_name = image.filename.replace(' ', '_')
+        stored_filename = f"{timestamp}_{sanitized_name}"
+        stored_path = os.path.join(session_upload_dir, stored_filename)
+
+        content = await image.read()
+        with open(stored_path, 'wb') as f:
+            f.write(content)
+
+        absolute_path = os.path.abspath(stored_path)
+        relative_root = os.path.abspath(uploads_root)
+        relative_path = os.path.relpath(absolute_path, relative_root)
+
+        return {
+            "status": "success",
+            "message": "Image uploaded successfully",
+            "file": {
+                "path": relative_path.replace('\\', '/'),
+                "name": image.filename,
+                "content_type": image.content_type,
+                "size": len(content),
+                "extension": file_extension,
+                "original_query": query,
+            },
+        }
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        logging.error(f"Error in upload_skin_image: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "status": "error",
+                "error": "Internal server error",
+                "details": str(e),
+            },
+        )
 
 @router.post('/get_rag_evaluation')
 async def rag_evaluation(

app/services/__init__.py

@@ -1,5 +1,4 @@
 # app/services/__init__.py
-from app.services.image_processor import ImageProcessor
 from app.services.image_classification_vit import SkinDiseaseClassifier
 from app.services.llm_model import Model
 from app.services.chat_processor import ChatProcessor
@@ -14,7 +13,6 @@ from app.services.wheel import EnvironmentalConditions
 from app.services.MagicConvert import MagicConvert
 
 __all__ = [
-    "ImageProcessor",
     "AISkinDetector",
     "SkinDiseaseClassifier",
     "Model", 

app/services/agentic_prompt.py

@@ -10,7 +10,7 @@ def _append_personalization(prompt: str, user_data: Dict) -> str:
         prompt += (
             "\n\n## Personalized Data Access:\n"
             f"Call `{personalized_tool}` exactly once to retrieve the patient's questionnaire-driven context after you finish using the search tools and before writing the final JSON response. "
-            "Use only the returned facts when crafting the `## Personalization Recommendation` section. Do not invent details beyond the tool output."
+            "Summarize only the details that materially influence your assessment; avoid dumping the questionnaire verbatim."
         )
     else:
         prompt += (
@@ -22,7 +22,7 @@ def _append_personalization(prompt: str, user_data: Dict) -> str:
         prompt += (
             "\n\n## Environmental Data Access:\n"
             f"Call `{environmental_tool}` exactly once when environmental guidance is relevant, ideally after the core search tools and personalization step. "
-            "Interpret the returned metrics responsibly before presenting them in the `## Environmental Condition` section."
+            "Reference these metrics only if they concretely affect the user's condition; explain the connection instead of listing raw numbers."
         )
     else:
         prompt += (
@@ -53,6 +53,23 @@ def _append_document_guidance(prompt: str, user_data: Dict) -> str:
     return prompt
 
 
+def _append_image_guidance(prompt: str, user_data: Dict) -> str:
+    image_info = user_data.get('image_info') or {}
+    tool_name = user_data.get('image_tool_name')
+    image_path = image_info.get('path')
+
+    if image_info and tool_name and image_path:
+        image_name = image_info.get('name') or 'Uploaded image'
+        prompt += (
+            "\n\n## Uploaded Image\n"
+            f"The user shared `{image_name}` located at `{image_path}`. "
+            f"Call `{tool_name}` exactly once before drafting the final JSON response to analyse the skin photo. "
+            "If the tool reports low confidence or that the picture is not skin, clearly explain the outcome and suggest the appropriate next steps."
+        )
+
+    return prompt
+
+
 def _format_json_guidance(user_data: Dict) -> str:
     references_instruction = (
         "Populate the `references` array with source links mapped from your tool calls."
@@ -85,6 +102,10 @@ def _format_json_guidance(user_data: Dict) -> str:
         if has_environmental
         else "Omit the `## Environmental Condition` section because environmental data is unavailable."
     )
+    image_instruction = (
+        "If the skin-image analysis tool succeeds, integrate its findings into `## Response from References`, cite it explicitly (e.g., [image]) and describe clinical caution."
+        " If it reports an error or low confidence, explain the limitation and advise on next best steps instead of guessing."
+    )
     safety_instruction = (
         "If the question is outside dermatology/medical scope or evidence is insufficient, respond with a safe refusal inside the JSON instead of guessing."
     )
@@ -101,6 +122,7 @@ def _format_json_guidance(user_data: Dict) -> str:
         f"{images_instruction}\n"
         f"{personalization_instruction}\n"
         f"{environmental_instruction}\n"
+        f"{image_instruction}\n"
         f"{safety_instruction}\n"
         "Return only JSON (no prose outside the JSON object).\n"
         "Do NOT hallucinate or invent facts.\n"
@@ -108,22 +130,52 @@ def _format_json_guidance(user_data: Dict) -> str:
 
 
 def get_web_search_prompt(user_data: Dict) -> str:
-    prompt = """
-You are Dr. DermAI, an evidence-based dermatology consultant.
-
-PRIMARY DIRECTIVES:
-1. ALWAYS call the `get_web_search` tool first to gather the latest medical knowledge.
-2. After reviewing text sources, call `get_image_search` if images are permitted to enrich the answer.
-3. Base every statement on retrieved sources; do not rely solely on prior training.
-4. Cite the supporting evidence inline using [1], [2], etc.
-5. Answer ONLY dermatology or medically relevant queries. Politely refuse others inside the JSON response.
-6. If the retrieved evidence is insufficient, acknowledge the limitation rather than speculating.
-
-TOOL CALL ORDER:
-- Step 1: get_web_search(query=<user question>)
-- Step 2: get_image_search(query=<key medical term>) when images are allowed
-- Step 3: Synthesize findings into the structured JSON response.
-"""
+    prompt_lines = [
+        "You are Dr. DermAI, an evidence-based dermatology consultant.",
+        "",
+        "PRIMARY DIRECTIVES:",
+    ]
+
+    if user_data.get('image_info') and user_data.get('image_tool_name'):
+        prompt_lines.append(
+            "0. If an uploaded skin image is provided, call the `analyze_skin_image` tool BEFORE any other tool."
+        )
+        prompt_lines.append(
+            "   Summarize its findings (or explain any errors) in your final response, citing it as [image]."
+    )
+
+    prompt_lines.extend(
+        [
+            "1. ALWAYS call the `get_web_search` tool next to gather the latest medical knowledge.",
+            "2. After reviewing text sources, call `get_image_search` if fresh comparison imagery would help.",
+            "3. Base every statement on retrieved sources or tool outputs; do not rely solely on prior training.",
+            "4. Cite the supporting evidence inline using [1], [2], etc.",
+            "5. Answer ONLY dermatology or medically relevant queries. Politely refuse others inside the JSON response.",
+            "6. If evidence is insufficient, state the limitation rather than speculating.",
+        ]
+    )
+
+    prompt_lines.extend(
+        [
+            "",
+            "TOOL CALL ORDER:",
+        ]
+    )
+
+    if user_data.get('image_info') and user_data.get('image_tool_name'):
+        prompt_lines.append(
+            f"- Step 0: {user_data.get('image_tool_name')}(file_path=<uploaded image path>)"
+        )
+
+    prompt_lines.extend(
+        [
+            "- Step 1: get_web_search(query=<user question>)",
+            "- Step 2: get_image_search(query=<key medical term>) when live imagery adds value",
+            "- Step 3: Synthesize findings into the structured JSON response.",
+        ]
+    )
+
+    prompt = "\n".join(prompt_lines)
     recent_history = user_data.get('recent_history')
     if recent_history:
         prompt += (
@@ -132,28 +184,59 @@ TOOL CALL ORDER:
             "Use this context to maintain continuity before answering the new query."
         )
     prompt = _append_document_guidance(prompt, user_data)
+    prompt = _append_image_guidance(prompt, user_data)
     prompt += _format_json_guidance(user_data)
     prompt = _append_personalization(prompt, user_data)
     return prompt.strip()
 
 
 def get_vector_search_prompt(user_data: Dict) -> str:
-    prompt = """
-You are Dr. DermAI, a dermatologist with access to a curated clinical knowledge base.
-
-PRIMARY DIRECTIVES:
-1. ALWAYS call the `get_vector_search` tool first to retrieve authoritative dermatology passages.
-2. After reviewing text sources, call `get_image_search` if images are permitted.
-3. Ground every recommendation in the retrieved evidence and cite it inline using [1], [2], etc.
-4. If the knowledge base lacks coverage, state this explicitly and provide a best-effort safety answer.
-5. Answer ONLY dermatology or medically relevant queries. Politely refuse others inside the JSON response.
-6. If evidence is insufficient, acknowledge the limitation instead of speculating.
-
-TOOL CALL ORDER:
-- Step 1: get_vector_search(query=<user question>)
-- Step 2: get_image_search(query=<key medical term>) when images are allowed
-- Step 3: Synthesize findings into the structured JSON response.
-"""
+    prompt_lines = [
+        "You are Dr. DermAI, a dermatologist with access to a curated clinical knowledge base.",
+        "",
+        "PRIMARY DIRECTIVES:",
+    ]
+
+    if user_data.get('image_info') and user_data.get('image_tool_name'):
+        prompt_lines.append(
+            "0. If an uploaded skin image is provided, call the `analyze_skin_image` tool BEFORE any database queries."
+        )
+        prompt_lines.append(
+            "   Summarize its findings (or any failure) using [image] in the final JSON response."
+        )
+
+    prompt_lines.extend(
+        [
+            "1. ALWAYS call the `get_vector_search` tool next to retrieve authoritative dermatology passages.",
+            "2. After reviewing text sources, call `get_image_search` if comparison imagery supports your reasoning.",
+            "3. Ground every recommendation in tool-derived evidence and cite it inline using [1], [2], etc.",
+            "4. If the knowledge base lacks coverage, state this explicitly and provide the safest guidance you can.",
+            "5. Answer ONLY dermatology or medically relevant queries. Politely refuse others inside the JSON response.",
+            "6. If evidence is insufficient, acknowledge the limitation instead of speculating.",
+        ]
+    )
+
+    prompt_lines.extend(
+        [
+            "",
+            "TOOL CALL ORDER:",
+        ]
+    )
+
+    if user_data.get('image_info') and user_data.get('image_tool_name'):
+        prompt_lines.append(
+            f"- Step 0: {user_data.get('image_tool_name')}(file_path=<uploaded image path>)"
+        )
+
+    prompt_lines.extend(
+        [
+            "- Step 1: get_vector_search(query=<user question>)",
+            "- Step 2: get_image_search(query=<key medical term>) when imagery helps",
+            "- Step 3: Synthesize findings into the structured JSON response.",
+        ]
+    )
+
+    prompt = "\n".join(prompt_lines)
     recent_history = user_data.get('recent_history')
     if recent_history:
         prompt += (
@@ -162,6 +245,7 @@ TOOL CALL ORDER:
             "Use this context to maintain continuity before answering the new query."
         )
     prompt = _append_document_guidance(prompt, user_data)
+    prompt = _append_image_guidance(prompt, user_data)
     prompt += _format_json_guidance(user_data)
     prompt = _append_personalization(prompt, user_data)
     return prompt.strip()

app/services/google_agent_service.py

@@ -19,6 +19,7 @@ from app.services.agentic_prompt import (
 from app.services.chathistory import ChatSession
 from app.services.environmental_condition import EnvironmentalData
 from app.services.tools import (
+    analyze_skin_image,
     convert_document_to_markdown,
     get_image_search,
     get_vector_search,
@@ -33,6 +34,7 @@ DEFAULT_MODEL_NAME = os.getenv("GEMINI_MODEL", "gemini-2.0-flash-exp")
 PERSONALIZED_TOOL_NAME = "get_personalized_context"
 ENVIRONMENT_TOOL_NAME = "get_environmental_context"
 DOCUMENT_CONVERSION_TOOL_NAME = "convert_uploaded_document"
+IMAGE_ANALYSIS_TOOL_NAME = "analyze_skin_image"
 
 if not os.getenv("GOOGLE_API_KEY") and GOOGLE_API_KEY:
     os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
@@ -52,6 +54,7 @@ class GoogleAgentService:
         token: str,
         session_id: Optional[str] = None,
         document: Optional[Dict[str, Any]] = None,
+        image: Optional[Dict[str, Any]] = None,
     ) -> None:
         self.token = token
         self.session_id = session_id
@@ -63,6 +66,7 @@ class GoogleAgentService:
         self.user_city = self.chat_session.get_city()
         self.environment_data = self._load_environmental_data()
         self.document = document
+        self.image = image
 
     async def process_message_async(
         self, query: str
@@ -196,9 +200,12 @@ class GoogleAgentService:
             merged_images = self._dedupe_list(collected_images + response_images)
             merged_references = self._dedupe_list(collected_references + response_refs)
 
-            context_payload = ""
+            context_chunks: List[str] = []
             if self.document and self.document.get("path"):
-                context_payload = f"document:{self.document.get('path')}"
+                context_chunks.append(f"document:{self.document.get('path')}")
+            if self.image and self.image.get("path"):
+                context_chunks.append(f"image:{self.image.get('path')}")
+            context_payload = " ".join(context_chunks)
 
             chat_payload = {
                 "query": query,
@@ -235,10 +242,17 @@ class GoogleAgentService:
             else get_vector_search_prompt(user_data)
         )
         search_tool = get_web_search if mode == "web" else get_vector_search
-        tools = [
-            FunctionTool(search_tool),
-            FunctionTool(get_image_search),
-        ]
+        tools: List[FunctionTool] = []
+
+        if self.image and self.image.get("path"):
+            tools.append(FunctionTool(self._create_image_tool()))
+
+        tools.extend(
+            [
+                FunctionTool(search_tool),
+                FunctionTool(get_image_search),
+            ]
+        )
 
         if self.document and self.document.get("path"):
             tools.append(FunctionTool(self._create_document_tool()))
@@ -268,25 +282,23 @@ class GoogleAgentService:
         allowed_path = (document_record.get("path") or "").strip()
 
         def run_document_conversion(
-            file_path: str,
+            file_path: Optional[str] = None,
             file_extension: Optional[str] = None,
         ) -> Dict[str, Any]:
-            if not file_path:
+            target_path = (file_path or allowed_path or "").replace("\\", "/").strip()
+            if not target_path:
                 return {
                     "status": "error",
                     "error_message": "file_path is required to convert a document.",
                 }
 
-            normalized_input = file_path.replace("\\", "/").strip()
             allowed_normalized = allowed_path.replace("\\", "/").strip()
-            if allowed_normalized and normalized_input != allowed_normalized:
+            if allowed_normalized and target_path != allowed_normalized:
                 return {
                     "status": "error",
                     "error_message": "The provided file_path does not match the uploaded document for this session.",
                 }
 
-            target_path = allowed_path or file_path
-
             result = convert_document_to_markdown(
                 file_path=target_path,
                 file_extension=file_extension or document_record.get("extension"),
@@ -308,6 +320,45 @@ class GoogleAgentService:
         )
         return run_document_conversion
 
+    def _create_image_tool(self) -> Callable[..., Dict[str, Any]]:
+        image_record = self.image or {}
+        allowed_path = (image_record.get("path") or "").strip()
+
+        def run_image_analysis(
+            file_path: Optional[str] = None,
+            language: Optional[str] = None,
+        ) -> Dict[str, Any]:
+            target_path = (file_path or allowed_path or "").replace("\\", "/").strip()
+            if not target_path:
+                return {
+                    "status": "error",
+                    "error_message": "file_path is required to analyse the image.",
+                }
+
+            allowed_normalized = allowed_path.replace("\\", "/").strip()
+            if allowed_normalized and target_path != allowed_normalized:
+                return {
+                    "status": "error",
+                    "error_message": "The provided file_path does not match the uploaded image for this session.",
+                }
+
+            result = analyze_skin_image(
+                file_path=target_path,
+                language=language or self.language,
+            )
+
+            if result.get("status") == "success" and allowed_path:
+                result["image_path"] = allowed_path
+
+            return result
+
+        run_image_analysis.__name__ = IMAGE_ANALYSIS_TOOL_NAME
+        run_image_analysis.__doc__ = (
+            "Analyse the user's uploaded skin image. Provide the `file_path` exactly as supplied "
+            "in the conversation context to run the classifier."
+        )
+        return run_image_analysis
+
     def _create_personalized_data_tool(self, data: str) -> Callable[[], Dict[str, Any]]:
         sanitized = (data or "").strip()
 
@@ -411,6 +462,16 @@ class GoogleAgentService:
                 "extension": self.document.get("extension"),
             }
 
+        image_info = None
+        if self.image and self.image.get("path"):
+            image_info = {
+                "path": self.image.get("path"),
+                "name": self.image.get("name") or "Uploaded image",
+                "type": self.image.get("type"),
+                "extension": self.image.get("extension"),
+                "prompt": self.image.get("prompt"),
+            }
+
         return {
             "name": self.user_profile.get("name"),
             "age": self.user_profile.get("age"),
@@ -442,6 +503,8 @@ class GoogleAgentService:
             "document_tool_name": DOCUMENT_CONVERSION_TOOL_NAME
             if document_info
             else None,
+            "image_info": image_info,
+            "image_tool_name": IMAGE_ANALYSIS_TOOL_NAME if image_info else None,
         }
 
     def _get_recent_history(self, limit: int = 10) -> str:

app/services/image_classification_vit.py

@@ -14,6 +14,9 @@ load_dotenv()
 
 HUGGINGFACE_TOKEN = os.getenv("HUGGINGFACE_TOKEN")
 
+# Set environment variables for better network handling
+os.environ['HF_HUB_DOWNLOAD_TIMEOUT'] = '300'  # Increase timeout to 5 minutes
+os.environ['TRANSFORMERS_OFFLINE'] = '0'  # Ensure online mode
 
 class SkinDiseaseClassifier:
     CLASS_NAMES = [
@@ -23,7 +26,7 @@ class SkinDiseaseClassifier:
         "Vitiligo", "Warts Molluscum and other Viral Infections"
     ]
 
-    def __init__(self, repo_id="muhammadnoman76/skin-disease-classifier"):
+    def __init__(self, repo_id="muhammadnoman76/skin-disease-classifier", cache_dir=None):
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         self.repo_id = repo_id
         self.model = self.load_trained_model()
@@ -94,6 +97,7 @@ class SkinDiseaseClassifier:
             if self.device.type == 'cuda':
                 image_tensor = image_tensor.half()
             image_tensor = image_tensor.to(self.device)
+            
             with torch.inference_mode():
                 outputs = self.model(pixel_values=image_tensor).logits
                 probabilities = F.softmax(outputs, dim=1)

app/services/image_processor.py

@@ -1,459 +0,0 @@
-from datetime import datetime, timezone, timedelta
-from typing import Dict, Any
-from concurrent.futures import ThreadPoolExecutor
-from yake import KeywordExtractor
-from app.services.chathistory import ChatSession
-from app.services.websearch import WebSearch
-from app.services.llm_model import Model
-from app.services.environmental_condition import EnvironmentalData
-from app.services.prompts import *
-from app.services.vector_database_search import VectorDatabaseSearch
-from app.services.image_classification_vit import SkinDiseaseClassifier
-import io
-from PIL import Image
-import os
-import shutil
-from werkzeug.utils import secure_filename
-
-temp_dir = "temp"
-if not os.path.exists(temp_dir):
-    os.makedirs(temp_dir)
-
-upload_dir = "uploads"
-if not os.path.exists(upload_dir):
-    os.makedirs(upload_dir)
-
-class ImageProcessor:
-    def __init__(self, token: str, session_id: str, num_results: int, num_images: int, image):
-        self.token = token
-        self.image = image
-        self.session_id = session_id
-        self.num_results = num_results
-        self.num_images = num_images
-        self.vectordb = VectorDatabaseSearch()
-        self.chat_session = ChatSession(token, session_id)
-        self.user_city = self.chat_session.get_city()
-        city = self.user_city if self.user_city else ''
-        self.environment_data = EnvironmentalData(city)
-        self.web_searcher = WebSearch(num_results=num_results, max_images=num_images)
-
-    def extract_keywords_yake(self, text: str, language: str, max_ngram_size: int = 2, num_keywords: int = 4) -> list:
-        lang_code = "en"
-        if language.lower() == "urdu":
-            lang_code = "ur"
-
-        kw_extractor = KeywordExtractor(
-            lan=lang_code,
-            n=max_ngram_size,
-            top=num_keywords,
-            features=None
-        )
-        keywords = kw_extractor.extract_keywords(text)
-        return [kw[0] for kw in keywords]
-
-    def ensure_valid_session(self, title: str = None) -> str:
-        if not self.session_id or not self.session_id.strip():
-            self.chat_session.create_new_session(title=title)
-            self.session_id = self.chat_session.session_id
-        else:
-            try:
-                if not self.chat_session.validate_session(self.session_id, title=title):
-                    self.chat_session.create_new_session(title=title)
-                    self.session_id = self.chat_session.session_id
-            except ValueError:
-                self.chat_session.create_new_session(title=title)
-                self.session_id = self.chat_session.session_id
-        return self.session_id
-    
-    def validate_upload(self):
-        """Validate if user can upload an image based on daily limit and time restriction"""
-        try:
-            # Check daily upload limit
-            daily_uploads = self.chat_session.get_user_daily_uploads()
-            print(f"Daily uploads: {daily_uploads}")
-            
-            if daily_uploads >= 5:
-                if self.chat_session.get_language().lower() == "urdu":
-                    return False, "آپ کی روزانہ کی حد (5 تصاویر) پوری ہو چکی ہے۔ براہ کرم کل کوشش کریں۔"
-                else:
-                    return False, "You've reached your daily limit (5 images). Please try again tomorrow."
-            
-            # Check time between uploads
-            last_upload_time = self.chat_session.get_user_last_upload_time()
-            print(f"Last upload time: {last_upload_time}")
-            
-            if last_upload_time:
-                # Ensure last_upload_time is timezone-aware
-                if last_upload_time.tzinfo is None:
-                    # If naive, make it timezone-aware by attaching UTC
-                    last_upload_time = last_upload_time.replace(tzinfo=timezone.utc)
-                    
-                # Now get the current time (which is already timezone-aware)
-                now = datetime.now(timezone.utc)
-                
-                # Now both times are timezone-aware, so the subtraction will work
-                time_since_last = now - last_upload_time
-                print(f"Time since last: {time_since_last}")
-                
-                if time_since_last < timedelta(minutes=1):
-                    seconds_remaining = 60 - time_since_last.seconds
-                    print(f"Seconds remaining: {seconds_remaining}")
-                    
-                    if self.chat_session.get_language().lower() == "urdu":
-                        return False, f"براہ کرم {seconds_remaining} سیکنڈ انتظار کریں اور دوبارہ کوشش کریں۔"
-                    else:
-                        return False, f"Please wait {seconds_remaining} seconds before uploading another image."
-            
-            # Log this upload
-            result = self.chat_session.log_user_image_upload()
-            print(f"Logged upload: {result}")
-            return True, ""
-        except Exception as e:
-            print(f"Error in validate_upload: {str(e)}")
-            # Fail safely - if we can't validate, we should allow the upload
-            return True, ""
-
-    def process_chat(self, query: str) -> Dict[str, Any]:
-        try:
-            is_valid, message = self.validate_upload()
-            if not is_valid:
-                return {
-                    "query": query,
-                    "response": message,
-                    "references": "",
-                    "page_no": "",
-                    "keywords": "",
-                    "images": "",
-                    "context": "",
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
-                    "session_id": self.session_id or ""
-                }
-
-            profile = self.chat_session.get_name_and_age()
-            name = profile['name']
-            age = profile['age']
-            self.chat_session.load_chat_history()
-            self.chat_session.update_title(self.session_id, query)
-            history = self.chat_session.format_history()
-            language = self.chat_session.get_language().lower()
-
-            filename = secure_filename(self.image.filename)
-            temp_path = os.path.join(temp_dir, filename)
-            upload_path = os.path.join(upload_dir, filename)
-
-            content = self.image.file.read()
-
-            with open(temp_path, 'wb') as buffer:
-                buffer.write(content)
-                self.image.file.seek(0)
-                
-            img_content = io.BytesIO(content)
-            pil_image = Image.open(img_content)
-            
-            self.image.file.seek(0)
-
-            def background_file_ops(src, dst):
-                shutil.copy2(src, dst)
-                os.remove(src)
-
-            with ThreadPoolExecutor(max_workers=1) as file_executor:
-                file_executor.submit(background_file_ops, temp_path, upload_path)
-
-            if language != "urdu":
-                response1 = "Please provide a clear image of your skin with good lighting and a proper angle, without any filters! we can only analysis the image of skin :)"
-                response3 = "You have healthy skin, MaShaAllah! I don't notice any issues at the moment. However, based on my current confidence level of {diseases_detection_confidence}, I recommend consulting a doctor for more detailed advice and analysis."
-                response4 = "I'm sorry, I'm not able to identify your skin condition yet as I'm still learning, but I hope to be able to detect any skin issues in the future. :) Right now, my confidence in identifying your skin is below 50%."
-                response5 = ADVICE_REPORT_SUGGESTION
-            else:
-                response1 = "براہ کرم اپنی جلد کی واضح تصویر اچھی روشنی اور مناسب زاویے سے فراہم کریں، کسی فلٹر کے بغیر! ہم صرف جلد کی تصویر کا تجزیہ کر سکتے ہیں"
-                response3 = "آپ کی جلد صحت مند ہے، ماشاءاللہ! مجھے اس وقت کوئی مسئلہ نظر نہیں آ رہا۔ تاہم، میری موجودہ اعتماد کی سطح {diseases_detection_confidence} کی بنیاد پر، میں مزید تفصیلی مشورے اور تجزیے کے لیے ڈاکٹر سے رجوع کرنے کی تجویز کرتا ہوں۔"
-                response4 = "معذرت، میں ابھی آپ کی جلد کی حالت کی شناخت کرنے کے قابل نہیں ہوں کیونکہ میں ابھی سیکھ رہا ہوں، لیکن مجھے امید ہے کہ مستقبل میں جلد کے کسی بھی مسئلے کو پہچان سکوں گا۔ :) اس وقت آپ کی جلد کی شناخت میں میرا اعتماد 50% سے کم ہے۔"
-                response5 = URDU_ADVICE_REPORT_SUGGESTION
-
-            model = Model()
-            result = model.llm_image(text=SKIN_NON_SKIN_PROMPT, image=pil_image)
-            result_lower = result.lower().strip()
-            is_negative = any(marker in result_lower for marker in ["<no>", "no"])
-    
-            if is_negative:
-                chat_data = {
-                    "query": query,
-                    "response": response1,
-                    "references": "",
-                    "page_no": filename,
-                    "keywords": "",
-                    "images": "",
-                    "context": "",
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
-                    "session_id": self.chat_session.session_id
-                }
-
-                if not self.chat_session.save_chat(chat_data):
-                    raise ValueError("Failed to save chat message")
-
-                return chat_data
-
-            diseases_detector = SkinDiseaseClassifier()
-            diseases_name, diseases_detection_confidence = diseases_detector.predict(pil_image, 5)
-
-            if diseases_name == "Healthy Skin":
-                chat_data = {
-                    "query": query,
-                    "response": response3.format(diseases_detection_confidence=diseases_detection_confidence),
-                    "references": "",
-                    "page_no": filename,
-                    "keywords": "",
-                    "images": "",
-                    "context": "",
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
-                    "session_id": self.chat_session.session_id
-                }
-
-                if not self.chat_session.save_chat(chat_data):
-                    raise ValueError("Failed to save chat message")
-
-                return chat_data
-
-            elif diseases_detection_confidence < 46:
-                chat_data = {
-                    "query": query,
-                    "response": response4,
-                    "references": "",
-                    "page_no": filename,
-                    "keywords": "",
-                    "images": "",
-                    "context": "",
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
-                    "session_id": self.chat_session.session_id
-                }
-
-                if not self.chat_session.save_chat(chat_data):
-                    raise ValueError("Failed to save chat message")
-                return chat_data
-            
-            
-            if not result:
-                chat_data = {
-                    "query": query,
-                    "response": response1,
-                    "references": "",
-                    "page_no": filename,
-                    "keywords": "",
-                    "images": "",
-                    "context": "",
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
-                    "session_id": self.chat_session.session_id
-                }
-
-                if not self.chat_session.save_chat(chat_data):
-                    raise ValueError("Failed to save chat message")
-
-                return chat_data
-
-            self.session_id = self.ensure_valid_session(title=query)
-            permission = self.chat_session.get_user_preferences()
-            websearch_enabled = permission.get('websearch', False)
-            env_recommendations = permission.get('environmental_recommendations', False)
-            personalized_recommendations = permission.get('personalized_recommendations', False)
-            keywords_permission = permission.get('keywords', False)
-            reference_permission = permission.get('references', False)
-            language = self.chat_session.get_language().lower()
-            language_prompt = LANGUAGE_RESPONSE_PROMPT.format(language=language)
-
-            if websearch_enabled:
-                with ThreadPoolExecutor(max_workers=2) as executor:
-                    future_web = executor.submit(self.web_searcher.search, diseases_name)
-                    future_images = executor.submit(self.web_searcher.search_images, diseases_name)
-                    web_results = future_web.result()
-                    image_results = future_images.result()
-
-                context_parts = []
-                references = []
-
-                for idx, result in enumerate(web_results, 1):
-                    if result['text']:
-                        context_parts.append(f"From Source {idx}: {result['text']}\n")
-                        references.append(result['link'])
-
-                context = "\n".join(context_parts)
-
-                if env_recommendations and personalized_recommendations:
-                    prompt = ENVIRONMENTAL_PERSONALIZED_PROMPT.format(
-                        user_name=name,
-                        user_age=age,
-                        user_details=self.chat_session.get_personalized_recommendation(),
-                        environmental_condition=self.environment_data.get_environmental_data(),
-                        previous_history="",
-                        context=context,
-                        current_query=query
-                    )
-                elif personalized_recommendations:
-                    prompt = PERSONALIZED_PROMPT.format(
-                        user_name=name,
-                        user_age=age,
-                        user_details=self.chat_session.get_personalized_recommendation(),
-                        previous_history="",
-                        context=context,
-                        current_query=query
-                    )
-                elif env_recommendations:
-                    prompt = ENVIRONMENTAL_PROMPT.format(
-                        user_name=name,
-                        user_age=age,
-                        environmental_condition=self.environment_data.get_environmental_data(),
-                        previous_history="",
-                        context=context,
-                        current_query=query
-                    )
-                else:
-                    prompt = DEFAULT_PROMPT.format(
-                        previous_history="",
-                        context=context,
-                        current_query=query
-                    )
-
-                prompt = prompt + f"\the query is related to {diseases_name}" + language_prompt
-
-                llm_response = Model().llm(prompt, query)
-
-                response = response5.format(
-                    diseases_name=diseases_name,
-                    diseases_detection_confidence=diseases_detection_confidence,
-                    response=llm_response
-                )
-
-                keywords = ""
-
-                if keywords_permission:
-                    keywords = self.extract_keywords_yake(response, language=language)
-                if not reference_permission:
-                    references = ""
-
-                chat_data = {
-                    "query": query,
-                    "response": response,
-                    "references": references,
-                    "page_no": filename,
-                    "keywords": keywords,
-                    "images": image_results,
-                    "context": context,
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
-                    "session_id": self.chat_session.session_id
-                }
-
-                if not self.chat_session.save_chat(chat_data):
-                    raise ValueError("Failed to save chat message")
-                return chat_data
-            
-            else:
-                attach_image = False
-
-                with ThreadPoolExecutor(max_workers=2) as executor:
-                    future_images = executor.submit(self.web_searcher.search_images, diseases_name)
-                    image_results = future_images.result()
-
-                results = self.vectordb.search(diseases_name , top_k= 3)
-
-                context_parts = []
-                references = []
-                seen_pages = set() 
-
-                for result in results:
-                    confidence = result['confidence']
-                    if confidence > 60:
-                        context_parts.append(f"Content: {result['content']}")
-                        page = result['page']
-                        if page not in seen_pages:
-                            references.append(f"Source: {result['source']}, Page: {page}")
-                            seen_pages.add(page)
-                        attach_image = True 
-
-                context = "\n".join(context_parts)
-                
-                if not context or len(context) < 10:
-                    context = "There is no context found unfortunately please do not answer anything and ignore previous information or recommendations that were mentioned earlier in the context."
-
-                if env_recommendations and personalized_recommendations:
-                    prompt = ENVIRONMENTAL_PERSONALIZED_PROMPT.format(
-                        user_name=name,
-                        user_age=age,
-                        user_details=self.chat_session.get_personalized_recommendation(),
-                        environmental_condition=self.environment_data.get_environmental_data(),
-                        previous_history="",
-                        context=context,
-                        current_query=query
-                    )
-                elif personalized_recommendations:
-                    prompt = PERSONALIZED_PROMPT.format(
-                        user_name=name,
-                        user_age=age,
-                        user_details=self.chat_session.get_personalized_recommendation(),
-                        previous_history="",
-                        context=context,
-                        current_query=query
-                    )
-                elif env_recommendations:
-                    prompt = ENVIRONMENTAL_PROMPT.format(
-                        user_name=name,
-                        user_age=age,
-                        environmental_condition=self.environment_data.get_environmental_data(),
-                        previous_history=history,
-                        context=context,
-                        current_query=query
-                    )
-                else:
-                    prompt = DEFAULT_PROMPT.format(
-                        previous_history="",
-                        context=context,
-                        current_query=query
-                    )
-
-                prompt = prompt + f"\the query is related to {diseases_name}" + language_prompt
-
-                llm_response = Model().llm(prompt, query)
-
-                response = response5.format(
-                    diseases_name=diseases_name,
-                    diseases_detection_confidence=diseases_detection_confidence,
-                    response=llm_response
-                )
-
-                keywords = ""
-
-                if keywords_permission:
-                    keywords = self.extract_keywords_yake(response, language=language)
-                if not reference_permission:
-                    references = ""
-                if not attach_image:
-                    image_results = ""
-                    keywords = ""
-
-                chat_data = {
-                    "query": query,
-                    "response": response,
-                    "references": references,
-                    "page_no": filename,
-                    "keywords": keywords,
-                    "images": image_results,
-                    "context": context,
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
-                    "session_id": self.chat_session.session_id
-                }
-                
-                if not self.chat_session.save_chat(chat_data):
-                    raise ValueError("Failed to save chat message")
-                return chat_data
-            
-        except Exception as e:
-            return {
-                "error": str(e),
-                "query": query,
-                "response": "Sorry, there was an error processing your request.",
-                "timestamp": datetime.now(timezone.utc).isoformat()
-            }
-
-    def web_search(self, query: str) -> Dict[str, Any]:
-        if self.session_id and len(self.session_id) > 5:
-            return self.process_chat(query=query)
-        else:
-            return self.process_chat(query=query)

app/services/tools.py

@@ -1,8 +1,11 @@
-import logging
+import io
+import logging
 import os
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
+from PIL import Image
+
 from app.services.vector_database_search import VectorDatabaseSearch
 from app.services.websearch import WebSearch
 from app.services.MagicConvert import (
@@ -10,6 +13,21 @@ from app.services.MagicConvert import (
     FileConversionException,
     UnsupportedFormatException,
 )
+from app.services.llm_model import Model
+from app.services.prompts import (
+    SKIN_NON_SKIN_PROMPT,
+    ADVICE_REPORT_SUGGESTION,
+    URDU_ADVICE_REPORT_SUGGESTION,
+)
+from app.services.image_classification_vit import SkinDiseaseClassifier
+
+try:
+    from pillow_heif import register_heif_opener
+
+    register_heif_opener()
+    _HEIF_SUPPORTED = True
+except Exception:
+    _HEIF_SUPPORTED = False
 
 logger = logging.getLogger(__name__)
 
@@ -27,6 +45,8 @@ _UPLOADS_ROOT = Path(
 
 
 _magic_converter = MagicConvert()
+_skin_classifier: Optional[SkinDiseaseClassifier] = None
+_skin_classifier_error: Optional[str] = None
 
 
 def get_web_search(query: str, num_results: int = 4) -> Dict[str, Any]:
@@ -160,6 +180,230 @@ def get_image_search(query: str, max_images: int = 3) -> Dict[str, Any]:
         }
 
 
+def _get_classifier() -> SkinDiseaseClassifier:
+    global _skin_classifier, _skin_classifier_error
+    if _skin_classifier is not None:
+        return _skin_classifier
+    if _skin_classifier_error:
+        raise RuntimeError(_skin_classifier_error)
+    try:
+        _skin_classifier = SkinDiseaseClassifier()
+        return _skin_classifier
+    except Exception as exc:
+        _skin_classifier_error = str(exc)
+        raise
+
+
+def analyze_skin_image(
+    file_path: str,
+    language: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Assess an uploaded image for dermatology analysis.
+
+    The tool verifies the file exists in the uploads directory, determines whether
+    the picture focuses on skin, and if so runs the skin disease classifier. When
+    confidence is below the 50% threshold it reports the uncertainty instead of a
+    diagnosis and nudges the user toward alternative options.
+    """
+
+    if not file_path or not str(file_path).strip():
+        return {"status": "error", "error_message": "file_path is required."}
+
+    try:
+        candidate = Path(file_path)
+        if not candidate.is_absolute():
+            candidate = (_UPLOADS_ROOT / candidate).resolve()
+        else:
+            candidate = candidate.resolve()
+
+        uploads_root = _UPLOADS_ROOT
+        uploads_root.mkdir(parents=True, exist_ok=True)
+        uploads_root = uploads_root.resolve()
+
+        if uploads_root not in candidate.parents and candidate != uploads_root:
+            return {
+                "status": "error",
+                "error_message": "Access to the requested file path is not permitted.",
+            }
+
+        if not candidate.exists() or not candidate.is_file():
+            return {
+                "status": "error",
+                "error_message": f"Image not found at '{candidate}'.",
+            }
+
+        try:
+            with candidate.open("rb") as fh:
+                image_bytes = fh.read()
+
+            image_stream = io.BytesIO(image_bytes)
+            pil_image = Image.open(image_stream)
+            pil_image.load()
+            pil_image = pil_image.convert("RGB")
+        except Exception as exc:
+            logger.exception("Unable to open image for analysis: %s", exc)
+
+            signature = image_bytes[:12] if 'image_bytes' in locals() else b''
+            looks_like_heif = signature.startswith(b"\x00\x00\x00\x20ftyp") and any(
+                codec in signature for codec in (b"heic", b"heix", b"hevc", b"avif")
+            )
+
+            if looks_like_heif and not _HEIF_SUPPORTED:
+                return {
+                    "status": "error",
+                    "error_message": (
+                        "The uploaded image appears to be in HEIC/AVIF format, which is not supported. "
+                        "Please convert the photo to JPG or PNG and try again."
+                    ),
+                }
+
+            return {
+                "status": "error",
+                "error_message": f"Unable to open the image: {exc}",
+            }
+
+        user_language = (language or "english").strip().lower()
+
+        # Determine whether the photo is actually about skin.
+        skin_prompt_output = ""
+        try:
+            model = Model()
+            skin_prompt_output = model.llm_image(
+                text=SKIN_NON_SKIN_PROMPT,
+                image=pil_image,
+            )
+        except Exception as exc:
+            logger.exception("Vision model failed to classify skin-vs-non-skin: %s", exc)
+
+        skin_prompt_lower = skin_prompt_output.lower().strip()
+        is_skin_photo = not any(
+            marker in skin_prompt_lower for marker in ("<no>", " no", "not skin")
+        )
+        looks_like_document = "document" in skin_prompt_lower or "report" in skin_prompt_lower
+
+        if not is_skin_photo:
+            if user_language == "urdu":
+                message = (
+                    "براہ کرم جلد کا واضح قریبی فوٹو فراہم کریں۔ اگر یہ میڈیکل رپورٹ ہے "
+                    "تو اسے دستاویز اپ لوڈ ٹول کے ذریعے شیئر کریں تاکہ میں اس کا تجزیہ کر سکوں۔"
+                )
+            else:
+                message = (
+                    "Please upload a close, well-lit photo of the affected skin area. "
+                    "If this image is a document — such as a medical report — "
+                    "use the document conversion tool so I can read and analyse it."
+                )
+
+            return {
+                "status": "success",
+                "is_skin": False,
+                "looks_like_document": looks_like_document,
+                "message": message,
+                "advice": ADVICE_REPORT_SUGGESTION if user_language != "urdu" else URDU_ADVICE_REPORT_SUGGESTION,
+                "raw_assessment": skin_prompt_output,
+                "image_path": str(candidate.relative_to(uploads_root)).replace("\\", "/"),
+            }
+
+        try:
+            classifier = _get_classifier()
+        except Exception as exc:
+            logger.error("Skin classifier unavailable: %s", exc)
+            return {
+                "status": "error",
+                "error_message": (
+                    "Skin analysis is temporarily unavailable. "
+                    "Ensure the classifier weights are accessible (set SKIN_CLASSIFIER_WEIGHTS to a local file "
+                    "or configure HUGGINGFACE_TOKEN with network access) and try again."
+                ),
+                "details": str(exc),
+            }
+
+        disease_name, confidence = classifier.predict(pil_image, 5)
+
+        confidence_value = float(confidence)
+        below_threshold = confidence_value < 50.0
+
+        if user_language == "urdu":
+            unable_message = (
+                "معذرت، میں اس وقت جلد کی بیماری کی درست شناخت نہیں کر پا رہا۔ "
+                "براہ کرم بہتر روشنی میں ایک قریب کی تصویر اپ لوڈ کریں یا اپنی تشخیص کے لیے ڈاکٹر سے رجوع کریں۔"
+            )
+            diagnosis_message = (
+                f"مجھے لگتا ہے کہ یہ {disease_name} ہے اور میری اعتماد کی سطح {confidence_value:.2f}% ہے۔ "
+                "براہ کرم حتمی تشخیص کے لیے ماہر ڈرماٹولوجسٹ سے مشورہ کریں۔"
+            )
+        else:
+            unable_message = (
+                "I’m not confident enough to identify a condition from this photo. "
+                "Please upload a clearer close-up image with good lighting, or consult a dermatologist for an in-person diagnosis."
+            )
+            diagnosis_message = (
+                f"I suspect this may be {disease_name} with a confidence of {confidence_value:.2f}%. "
+                "Please consult a dermatologist for a professional evaluation and treatment plan."
+            )
+
+        message = unable_message if below_threshold else diagnosis_message
+
+        if user_language == "urdu":
+            advice_lines = ["## تصویری تجزیہ کی بنیاد پر"]
+            if not below_threshold:
+                advice_lines.append(
+                    f"- مشتبہ بیماری: {disease_name} (اعتماد {confidence_value:.2f}%)."
+                )
+                advice_lines.append(
+                    "- یہ نتیجہ تخمینی ہے، حتمی تشخیص کے لئے ماہر امراض جلد سے رجوع کریں۔"
+                )
+            else:
+                advice_lines.append(
+                    "- ماڈل کا اعتماد 50٪ سے کم ہے، اس لئے قابل اعتماد تشخیص ممکن نہیں۔"
+                )
+            advice_lines.append(
+                "- متاثرہ جلد کی واضح اور روشنی میں تصویر لیں اور فلٹرز سے پرہیز کریں۔"
+            )
+            advice_lines.append(
+                "- اگر علامات بگڑتی یا پھیلتی ہیں تو فوری طبی معائنہ کروائیں۔"
+            )
+        else:
+            advice_lines = ["## Based on the Image Analysis"]
+            if not below_threshold:
+                advice_lines.append(
+                    f"- Suspected condition: {disease_name} (confidence {confidence_value:.2f}%)."
+                )
+                advice_lines.append(
+                    "- This prediction is probabilistic; please obtain confirmation from a dermatologist."
+                )
+            else:
+                advice_lines.append(
+                    "- The model's confidence is below 50%, so no reliable diagnosis is available."
+                )
+            advice_lines.append(
+                "- Capture well-lit close-up photos of the affected area and avoid heavy filters."
+            )
+            advice_lines.append(
+                "- Seek urgent in-person care if symptoms worsen or spread rapidly."
+            )
+
+        advice = "\n".join(advice_lines)
+
+        return {
+            "status": "success",
+            "is_skin": True,
+            "diagnosis": None if below_threshold else disease_name,
+            "confidence": confidence_value,
+            "confidence_below_threshold": below_threshold,
+            "message": message,
+            "advice": advice,
+            "raw_assessment": skin_prompt_output,
+            "image_path": str(candidate.relative_to(uploads_root)).replace("\\", "/"),
+        }
+    except Exception as exc:
+        logger.exception("Unexpected error during image analysis: %s", exc)
+        return {
+            "status": "error",
+            "error_message": f"Unexpected error: {exc}",
+        }
+
+
 def convert_document_to_markdown(
     file_path: str,
     file_extension: Optional[str] = None,

pyproject.toml

@@ -6,43 +6,186 @@ authors = [
     { name = "Muhammad Noman", email = "muhammadnoman76@gmail.com" }
 ]
 dependencies = [
+    "absolufy-imports==0.3.1",
+    "aiohappyeyeballs==2.6.1",
+    "aiohttp==3.12.15",
+    "aiosignal==1.4.0",
+    "alembic==1.16.5",
+    "annotated-types==0.7.0",
+    "anyio==4.10.0",
+    "attrs==25.3.0",
+    "Authlib==1.6.3",
     "beautifulsoup4==4.13.4",
+    "Brotli==1.1.0",
+    "cachetools==5.5.2",
+    "certifi==2025.8.3",
+    "cffi==2.0.0",
+    "charset-normalizer==3.4.1",
+    "click==8.2.1",
+    "cloudpickle==3.1.1",
+    "cobble==0.1.4",
+    "colorama==0.4.6",
+    "cryptography==45.0.7",
+    "dataclasses-json==0.6.7",
+    "dnspython==2.8.0",
+    "docstring_parser==0.17.0",
+    "email-validator==2.3.0",
     "fastapi==0.115.12",
+    "filelock==3.19.1",
+    "filetype==1.2.0",
+    "frozenlist==1.7.0",
+    "fsspec==2025.9.0",
+    "g4f==0.5.2.1",
+    "google-adk==1.14.0",
+    "google-ai-generativelanguage==0.6.18",
+    "google-api-core==2.25.1",
+    "google-api-python-client==2.181.0",
+    "google-auth==2.40.3",
+    "google-auth-httplib2==0.2.0",
+    "google-cloud-aiplatform==1.113.0",
+    "google-cloud-appengine-logging==1.6.2",
+    "google-cloud-audit-log==0.3.2",
+    "google-cloud-bigquery==3.37.0",
+    "google-cloud-bigtable==2.32.0",
+    "google-cloud-core==2.4.3",
+    "google-cloud-logging==3.12.1",
+    "google-cloud-resource-manager==1.14.2",
+    "google-cloud-secret-manager==2.24.0",
+    "google-cloud-spanner==3.57.0",
+    "google-cloud-speech==2.33.0",
+    "google-cloud-storage==2.19.0",
+    "google-cloud-trace==1.16.2",
+    "google-crc32c==1.7.1",
     "google-genai==1.36.0",
-    "huggingface_hub==0.30.2",
-    "langchain_community==0.3.23",
-    "langchain_google_genai==2.1.4",
-    "langchain_qdrant==0.2.0",
-    "langchain_text_splitters==0.3.8",
+    "google-resumable-media==2.7.2",
+    "googleapis-common-protos==1.70.0",
+    "graphviz==0.21",
+    "greenlet==3.2.4",
+    "grpc-google-iam-v1==0.14.2",
+    "grpc-interceptor==0.15.4",
+    "grpcio==1.74.0",
+    "grpcio-status==1.74.0",
+    "h11==0.16.0",
+    "h2==4.3.0",
+    "hpack==4.1.0",
+    "httpcore==1.0.9",
+    "httplib2==0.31.0",
+    "httpx==0.28.1",
+    "httpx-sse==0.4.1",
+    "huggingface-hub==0.30.2",
+    "hyperframe==6.1.0",
+    "idna==3.10",
+    "importlib_metadata==8.7.0",
+    "jellyfish==1.2.0",
+    "Jinja2==3.1.6",
+    "joblib==1.5.2",
+    "jsonpatch==1.33",
+    "jsonpointer==3.0.0",
+    "jsonschema==4.25.1",
+    "jsonschema-specifications==2025.9.1",
+    "langchain==0.3.26",
+    "langchain-community==0.3.23",
+    "langchain-core==0.3.76",
+    "langchain-google-genai==2.1.4",
+    "langchain-qdrant==0.2.0",
+    "langchain-text-splitters==0.3.8",
+    "langsmith==0.3.45",
+    "lxml==6.0.1",
+    "Mako==1.3.10",
+    "mammoth==1.9.0",
+    "markdownify==1.1.0",
+    "MarkupSafe==3.0.2",
+    "marshmallow==3.26.1",
+    "mcp==1.14.0",
+    "mpmath==1.3.0",
+    "multidict==6.6.4",
+    "mypy_extensions==1.1.0",
+    "nest-asyncio==1.6.0",
+    "networkx==3.5",
     "nltk==3.9.1",
     "numpy==2.2.4",
+    "opentelemetry-api==1.37.0",
+    "opentelemetry-exporter-gcp-trace==1.9.0",
+    "opentelemetry-resourcedetector-gcp==1.9.0a0",
+    "opentelemetry-sdk==1.37.0",
+    "opentelemetry-semantic-conventions==0.58b0",
+    "orjson==3.11.3",
+    "packaging==25.0",
+    "pandas==2.2.3",
+    "pdfminer.six==20250416",
     "pillow==11.2.1",
-    "pydantic[email]==2.11.3",
+    "portalocker==2.10.1",
+    "propcache==0.3.2",
+    "proto-plus==1.26.1",
+    "protobuf==6.32.1",
+    "puremagic==1.28",
+    "pyasn1==0.6.1",
+    "pyasn1_modules==0.4.2",
+    "pycparser==2.23",
+    "pycryptodome==3.23.0",
+    "pydantic==2.11.3",
+    "pydantic_core==2.33.1",
+    "pydantic-settings==2.10.1",
+    "PyJWT==1.7.1",
     "pymongo==4.12.1",
+    "pyparsing==3.2.4",
     "pypdf==5.4.0",
-    "PyJWT==1.7.1",
+    "pytesseract==0.3.13",
+    "python-dateutil==2.9.0.post0",
     "python-dotenv==1.1.0",
-    "qdrant_client==1.14.2",
-    "requests==2.32.3",
+    "python-http-client==3.3.7",
+    "python-multipart==0.0.20",
+    "python-pptx==1.0.2",
+    "pytz==2025.2",
+    "pywin32==311",
+    "PyYAML==6.0.2",
+    "qdrant-client==1.14.2",
+    "referencing==0.36.2",
+    "regex==2025.9.1",
+    "requests==2.32.5",
+    "requests-toolbelt==1.0.0",
+    "rpds-py==0.27.1",
+    "rsa==4.9.1",
+    "safetensors==0.6.2",
     "scikit-learn==1.6.1",
+    "scipy==1.16.2",
+    "segtok==1.5.11",
     "sendgrid==6.11.0",
+    "shapely==2.1.1",
+    "six==1.17.0",
+    "sniffio==1.3.1",
+    "soupsieve==2.8",
+    "SQLAlchemy==2.0.43",
+    "sqlalchemy-spanner==1.16.0",
+    "sqlparse==0.5.3",
+    "sse-starlette==3.0.2",
+    "starkbank-ecdsa==2.2.0",
+    "starlette==0.46.2",
+    "sympy==1.13.1",
+    "tabulate==0.9.0",
+    "tenacity==8.5.0",
+    "threadpoolctl==3.6.0",
+    "tokenizers==0.21.4",
     "torch==2.5.1",
     "torchvision==0.20.1",
+    "tqdm==4.67.1",
     "transformers==4.51.3",
-    "werkzeug==3.1.3",
-    "yake==0.4.8",
+    "typing_extensions==4.15.0",
+    "typing-inspect==0.9.0",
+    "typing-inspection==0.4.1",
+    "tzdata==2025.2",
+    "tzlocal==5.3.1",
+    "uritemplate==4.2.0",
+    "urllib3==2.5.0",
     "uvicorn==0.34.1",
-    "python-multipart==0.0.20",
-    "g4f==0.5.2.1",
-    "mammoth==1.9.0",
-    "markdownify==1.1.0",
-    "pandas==2.2.3",
-    "pdfminer.six==20250416",
-    "python-pptx==1.0.2",
-    "puremagic==1.28",
-    "charset-normalizer==3.4.1",
-    "pytesseract==0.3.13",
-    "langchain-google-genai"
+    "watchdog==6.0.0",
+    "websockets==15.0.1",
+    "Werkzeug==3.1.3",
+    "xlsxwriter==3.2.8",
+    "yake==0.4.8",
+    "yarl==1.20.1",
+    "zipp==3.23.0",
+    "zstandard==0.23.0"
 ]
 
 [build-system]