update

.gitignore

@@ -1,14 +1,12 @@
-# Flask specific
-instance/*
-!instance/.gitignore
-.webassets-cache
-.env
-
-# Python related
+# Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
 *$py.class
+
+# C extensions
 *.so
+
+# Distribution / packaging
 .Python
 build/
 develop-eggs/
@@ -22,23 +20,140 @@ parts/
 sdist/
 var/
 wheels/
+share/python-wheels/
 *.egg-info/
 .installed.cfg
 *.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
 
-# Virtual Environment
-.venv/
+# pipenv
+Pipfile.lock
+
+# poetry
+poetry.lock
+
+# pdm
+.pdm.toml
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
 venv/
 ENV/
+env.bak/
+venv.bak/
 
-# IDE specific (common ones)
-.idea/
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# IDEs
 .vscode/
+.idea/
 *.swp
 *.swo
+*~
 .DS_Store
 
-# Local development
-*.log
-.env.local
-.env.*.local
+# Project specific
+temp/
+uploads/
+*.pth
+*.pkl
+*.h5
+*.model
+logs/
+backups/
+nltk_data/
+
+# Keep .gitkeep files
+!.gitkeep
+!app/config/temp/.gitkeep

Makefile

@@ -0,0 +1,27 @@
+# Makefile for Windows (PowerShell or Git Bash)
+
+VENV_DIR = .venv
+PYTHON = python
+
+.PHONY: venv install run clean clean-all
+
+# Create virtual environment
+venv:
+	$(PYTHON) -m venv $(VENV_DIR)
+
+# Install dependencies from pyproject.toml
+install: venv
+	$(VENV_DIR)/Scripts/python -m pip install --upgrade pip setuptools wheel
+	$(VENV_DIR)/Scripts/pip install -e .
+
+# Run the app
+run:
+	$(VENV_DIR)/Scripts/python app.py
+
+# Remove virtual environment
+clean:
+	if exist $(VENV_DIR) rmdir /s /q $(VENV_DIR)
+
+# Clean caches (__pycache__, .pytest_cache, *.pyc, *.pyo, build artifacts) - preserve .venv
+clean-all:
+	- powershell -Command "Get-ChildItem -Recurse -Force -Include __pycache__,*.pyc,*.pyo,.pytest_cache,build,dist | Remove-Item -Recurse -Force"

app/main.py

@@ -6,7 +6,7 @@ import os
 from dotenv import load_dotenv
 from app.config.config import Config
 from app.routers import admin, auth, chat, location, preferences, profile, questionnaire, language, chat_session
-
+from app.routers import agent_chat
 load_dotenv()
 
 app = FastAPI(title="Skin AI API")
@@ -34,6 +34,8 @@ app.include_router(profile.router, prefix="/api", tags=["profile"])
 app.include_router(questionnaire.router, prefix="/api", tags=["questionnaire"])
 app.include_router(language.router, prefix="/api", tags=["language"])
 app.include_router(chat_session.router, prefix="/api", tags=["chat_session"])
+app.include_router(agent_chat.router, prefix="/api", tags=["agent_chat"])
+
 
 @app.get("/")
 async def root():

app/routers/agent_chat.py

@@ -0,0 +1,115 @@
+from typing import Optional
+import asyncio
+import json
+import logging
+
+from fastapi import APIRouter, Depends, Header, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from app.middleware.auth import get_current_user
+from app.services.google_agent_service import (
+    DEFAULT_MODEL_NAME,
+    GoogleAgentService,
+)
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+
+class AgentChatRequest(BaseModel):
+    session_id: Optional[str] = None
+    query: str
+
+
+async def stream_agent_response(agent_service: GoogleAgentService, query: str):
+    try:
+        async for event in agent_service.process_message_async(query):
+            event_type = event.get("type")
+
+            if event_type == "chunk":
+                payload = {"type": "chunk", "content": event.get("content", "")}
+            elif event_type == "tool_call":
+                payload = {
+                    "type": "tool_call",
+                    "tool_name": event.get("tool_name"),
+                    "arguments": event.get("arguments", {}),
+                }
+            elif event_type == "tool_result":
+                payload = {
+                    "type": "tool_result",
+                    "tool_name": event.get("tool_name"),
+                    "result": event.get("result", {}),
+                }
+            elif event_type == "completed":
+                payload = {
+                    "type": "completed",
+                    "saved": event.get("saved"),
+                    "session_id": event.get("session_id"),
+                    "response": event.get("response", ""),
+                    "keywords": event.get("keywords", []),
+                    "references": event.get("references", []),
+                    "images": event.get("images", []),
+                }
+            elif event_type == "error":
+                payload = {"type": "error", "message": event.get("content", "")}
+            else:
+                payload = {"type": event_type or "unknown", "data": event}
+
+            yield f"data: {json.dumps(payload)}\n\n"
+            await asyncio.sleep(0.001)
+
+        yield "data: {\"type\": \"done\"}\n\n"
+    except Exception as exc:
+        logger.error("Streaming error: %s", exc, exc_info=True)
+        yield f"data: {json.dumps({'type': 'error', 'message': str(exc)})}\n\n"
+
+
+@router.post("/agent-chat")
+async def agent_chat(
+    request: AgentChatRequest,
+    authorization: str = Header(None),
+    username: str = Depends(get_current_user),
+):
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Invalid authorization header")
+
+    token = authorization.split(" ", 1)[1]
+
+    try:
+        agent_service = GoogleAgentService(token=token, session_id=request.session_id)
+    except Exception as exc:
+        logger.error("Failed to initialise agent service: %s", exc, exc_info=True)
+        raise HTTPException(status_code=500, detail="Unable to initialise agent")
+
+    return StreamingResponse(
+        stream_agent_response(agent_service, request.query),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "Content-Type": "text/event-stream",
+            "X-Accel-Buffering": "no",
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Headers": "*",
+        },
+    )
+
+
+@router.get("/agent-status")
+async def agent_status(username: str = Depends(get_current_user)):
+    try:
+        return {
+            "status": "available",
+            "model": DEFAULT_MODEL_NAME,
+            "features": [
+                "web_search",
+                "vector_search",
+                "image_search",
+                "streaming",
+                "tool_calls",
+            ],
+        }
+    except Exception as exc:
+        logger.error("Agent status error: %s", exc, exc_info=True)
+        return {"status": "error", "message": str(exc)}

app/services/agent_service.py

@@ -0,0 +1,412 @@
+# import asyncio
+# import os
+# import sys
+# from typing import Dict, Any, Optional, AsyncGenerator
+# from datetime import datetime, timezone
+# from google.adk.agents import Agent
+# from google.adk.runners import InMemoryRunner
+# from app.services.tools import get_web_search, get_vector_search, get_image_search
+# from app.services.chathistory import ChatSession
+# from app.services.environmental_condition import EnvironmentalData
+# from app.services.agentic_prompt import get_web_search_prompt, get_vector_search_prompt
+# from app.database.database_query import DatabaseQuery
+# import logging
+# import json
+
+# if sys.platform.startswith('win'):
+#     asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
+
+# # Set up logging
+# logging.basicConfig(
+#     level=logging.INFO,
+#     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+# )
+# logger = logging.getLogger(__name__)
+
+# # Set Google API key
+# GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY") or os.getenv("GEMINI_API_KEY")
+# os.environ['GOOGLE_API_KEY'] = GOOGLE_API_KEY
+
+# class GoogleAgentService:
+#     def __init__(self, token: str, session_id: Optional[str] = None):
+#         logger.info(f"Initializing GoogleAgentService with session: {session_id}")
+#         self.token = token
+#         self.session_id = session_id
+#         self.chat_session = ChatSession(token, session_id)
+#         self.query_db = DatabaseQuery()
+#         self.user_profile = self._get_user_profile()
+#         self.user_preferences = self._get_user_preferences()
+#         self.user_city = self.chat_session.get_city()
+#         self.environment_data = self._get_environmental_data()
+#         self.language = self.chat_session.get_language()
+#         self.agent = None
+#         self.runner = None
+#         self.agent_session = None
+#         self.tool_calls = []  
+#         self.images_found = []  
+        
+#         logger.info(f"User preferences: {self.user_preferences}")
+#         logger.info(f"User city: {self.user_city}")
+#         logger.info(f"Language: {self.language}")
+        
+#         # Initialize the appropriate agent
+#         self._initialize_agent()
+    
+#     def _get_user_profile(self) -> Dict[str, Any]:
+#         """Get user profile information"""
+#         try:
+#             profile = self.chat_session.get_name_and_age()
+#             logger.info(f"Retrieved user profile: {profile}")
+#             return {
+#                 'name': profile.get('name', 'Patient'),
+#                 'age': profile.get('age', 'Unknown')
+#             }
+#         except Exception as e:
+#             logger.error(f"Error getting user profile: {e}")
+#             return {'name': 'Patient', 'age': 'Unknown'}
+    
+#     def _get_user_preferences(self) -> Dict[str, Any]:
+#         """Get user preferences from database"""
+#         try:
+#             preferences = self.chat_session.get_user_preferences()
+#             logger.info(f"Retrieved user preferences: {preferences}")
+#             return preferences
+#         except Exception as e:
+#             logger.error(f"Error getting user preferences: {e}")
+#             return {
+#                 'websearch': False,
+#                 'keywords': True,
+#                 'references': True,
+#                 'environmental_recommendations': False,
+#                 'personalized_recommendations': False
+#             }
+    
+#     def _get_environmental_data(self) -> str:
+#         """Get environmental data if user has provided location"""
+#         try:
+#             if self.user_city:
+#                 env_data = EnvironmentalData(self.user_city)
+#                 data = str(env_data.get_environmental_data())
+#                 logger.info(f"Retrieved environmental data for {self.user_city}: {data[:100]}...")
+#                 return data
+#             logger.info("No user city provided, skipping environmental data")
+#             return ""
+#         except Exception as e:
+#             logger.error(f"Error getting environmental data: {e}")
+#             return ""
+    
+#     def _get_personalized_data(self) -> str:
+#         """Get personalized recommendations data"""
+#         try:
+#             data = self.chat_session.get_personalized_recommendation() or ""
+#             if data:
+#                 logger.info(f"Retrieved personalized data: {data[:100]}...")
+#             return data
+#         except Exception as e:
+#             logger.error(f"Error getting personalized data: {e}")
+#             return ""
+    
+#     def _prepare_user_data(self) -> Dict[str, Any]:
+#         """Prepare all user data for prompt generation"""
+#         user_data = {
+#             'name': self.user_profile.get('name'),
+#             'age': self.user_profile.get('age'),
+#             'language': self.language,
+#             'personalized_recommendations': self.user_preferences.get('personalized_recommendations'),
+#             'environmental_recommendations': self.user_preferences.get('environmental_recommendations'),
+#             'personalized_data': self._get_personalized_data() if self.user_preferences.get('personalized_recommendations') else "",
+#             'environmental_data': self.environment_data if self.user_preferences.get('environmental_recommendations') else ""
+#         }
+#         logger.info(f"Prepared user data: {user_data}")
+#         return user_data
+    
+#     def _initialize_agent(self):
+#         """Initialize the appropriate agent based on user preferences"""
+#         user_data = self._prepare_user_data()
+        
+#         # Pass functions directly as tools - NO FunctionTool wrapper needed!
+#         if self.user_preferences.get('websearch', False):
+#             # Create web search agent
+#             logger.info("Initializing web search agent with tools")
+            
+#             self.agent = Agent(
+#                 name="web_search_agent",
+#                 model="gemini-2.0-flash-exp",
+#                 description="Expert dermatologist assistant using web search",
+#                 instruction=get_web_search_prompt(user_data),
+#                 tools=[get_web_search, get_image_search],  # Pass functions directly!
+#             )
+#             logger.info(f"Web search agent initialized with tools: get_web_search, get_image_search")
+#         else:
+#             # Create vector search agent
+#             logger.info("Initializing vector search agent with tools")
+            
+#             self.agent = Agent(
+#                 name="vector_search_agent",
+#                 model="gemini-2.0-flash-exp",
+#                 description="Expert dermatologist assistant using medical knowledge base",
+#                 instruction=get_vector_search_prompt(user_data),
+#                 tools=[get_vector_search, get_image_search],  # Pass functions directly!
+#             )
+#             logger.info(f"Vector search agent initialized with tools: get_vector_search, get_image_search")
+        
+#         # Initialize runner with the agent object (not string!)
+#         self.runner = InMemoryRunner(
+#             agent=self.agent,  # Pass the agent object
+#             app_name='dermai_chat_app',
+#         )
+#         logger.info(f"Agent and runner initialized successfully")
+    
+#     async def create_session(self) -> Optional[Any]:
+#         """Create a new agent session"""
+#         try:
+#             logger.info(f"Creating new agent session for user: {self.chat_session.identity}")
+#             session = await self.runner.session_service.create_session(
+#                 app_name='dermai_chat_app',
+#                 user_id=self.chat_session.identity
+#             )
+#             self.agent_session = session
+#             logger.info(f"Agent session created with ID: {session.id}")
+#             return session
+#         except Exception as e:
+#             logger.error(f"Error creating session: {e}", exc_info=True)
+#             return None
+    
+#     def _create_message_content(self, text: str) -> Dict[str, Any]:
+#         """Create a message content dictionary compatible with the runner"""
+#         # Create a simple content structure that the runner can understand
+#         return {
+#             'role': 'user',
+#             'parts': [{'text': text}]
+#         }
+    
+#     async def process_message_async(self, query: str) -> AsyncGenerator[Dict[str, Any], None]:
+#         """Process message and yield streaming responses"""
+#         try:
+#             logger.info(f"Processing message: {query[:100]}...")
+            
+#             # Reset tracking variables
+#             self.tool_calls = []
+#             self.images_found = []
+            
+#             # Ensure session is created
+#             if not self.agent_session:
+#                 logger.info("Creating new agent session...")
+#                 await self.create_session()
+            
+#             if not self.agent_session:
+#                 logger.error("Failed to create agent session")
+#                 yield {
+#                     "type": "error",
+#                     "content": "Failed to create agent session"
+#                 }
+#                 return
+            
+#             # Create message content as a simple string
+#             # The runner will handle the conversion internally
+            
+#             # Track response for final processing
+#             full_response = ""
+#             current_text = ""
+            
+#             logger.info("Starting agent execution...")
+#             logger.info(f"Agent tools: {[tool.__name__ for tool in self.agent.tools] if self.agent.tools else 'No tools'}")
+            
+#             # Use run_async for streaming
+#             try:
+#                 events = self.runner.run_async(
+#                     user_id=self.chat_session.identity,
+#                     session_id=self.agent_session.id,
+#                     new_message=query,  # Pass query directly as string
+#                 )
+                
+#                 async for event in events:
+#                     # Debug logging
+#                     logger.debug(f"Event type: {type(event).__name__}")
+                    
+#                     # Handle text responses with streaming
+#                     if hasattr(event, 'content') and event.content:
+#                         if hasattr(event.content, 'parts') and event.content.parts:
+#                             for part in event.content.parts:
+#                                 # Handle text parts
+#                                 if hasattr(part, 'text') and part.text:
+#                                     text_content = part.text
+                                    
+#                                     # Check if this is a partial/streaming response
+#                                     if hasattr(event, 'partial') and event.partial:
+#                                         # Stream only the new chunk
+#                                         new_chunk = text_content[len(current_text):]
+#                                         if new_chunk:
+#                                             logger.debug(f"Streaming chunk: {new_chunk[:50]}...")
+#                                             yield {
+#                                                 "type": "chunk",
+#                                                 "content": new_chunk
+#                                             }
+#                                         current_text = text_content
+#                                     elif text_content != current_text:
+#                                         # Complete text or new text segment
+#                                         new_chunk = text_content[len(current_text):] if current_text else text_content
+#                                         if new_chunk:
+#                                             yield {
+#                                                 "type": "chunk",
+#                                                 "content": new_chunk
+#                                             }
+#                                         current_text = text_content
+#                                     full_response = text_content
+                                
+#                                 # Handle function calls
+#                                 if hasattr(part, 'function_call'):
+#                                     func_call = part.function_call
+#                                     logger.info(f"Function call detected: {func_call.name if hasattr(func_call, 'name') else 'unknown'}")
+                                    
+#                                     # Parse arguments
+#                                     args = {}
+#                                     if hasattr(func_call, 'args'):
+#                                         args = dict(func_call.args) if func_call.args else {}
+                                    
+#                                     tool_call_info = {
+#                                         'tool_name': func_call.name if hasattr(func_call, 'name') else 'unknown',
+#                                         'arguments': args
+#                                     }
+#                                     self.tool_calls.append(tool_call_info)
+                                    
+#                                     yield {
+#                                         "type": "tool_call",
+#                                         "tool_name": tool_call_info['tool_name'],
+#                                         "arguments": tool_call_info['arguments']
+#                                     }
+                                
+#                                 # Handle function responses  
+#                                 if hasattr(part, 'function_response'):
+#                                     func_response = part.function_response
+#                                     logger.info(f"Function response for: {func_response.name if hasattr(func_response, 'name') else 'unknown'}")
+                                    
+#                                     # Parse the response
+#                                     response_data = func_response.response if hasattr(func_response, 'response') else {}
+                                    
+#                                     # Check for images in the response
+#                                     if isinstance(response_data, dict):
+#                                         if 'images' in response_data:
+#                                             images = response_data.get('images', [])
+#                                             if images:
+#                                                 self.images_found.extend(images)
+#                                                 logger.info(f"Found {len(images)} images from {func_response.name if hasattr(func_response, 'name') else 'tool'}")
+                                        
+#                                         yield {
+#                                             "type": "tool_result",
+#                                             "tool_name": func_response.name if hasattr(func_response, 'name') else 'unknown',
+#                                             "result": response_data
+#                                         }
+                            
+#             except Exception as async_error:
+#                 logger.warning(f"Async streaming failed, trying synchronous: {async_error}")
+#                 # Fallback to synchronous execution
+                
+#                 for event in self.runner.run(
+#                     user_id=self.chat_session.identity,
+#                     session_id=self.agent_session.id,
+#                     new_message=query,  # Pass query directly as string
+#                 ):
+#                     if hasattr(event, 'content') and event.content:
+#                         if hasattr(event.content, 'parts') and event.content.parts:
+#                             for part in event.content.parts:
+#                                 if hasattr(part, 'text') and part.text:
+#                                     text_content = part.text
+#                                     if text_content != current_text:
+#                                         new_chunk = text_content[len(current_text):] if current_text else text_content
+#                                         if new_chunk:
+#                                             yield {
+#                                                 "type": "chunk",
+#                                                 "content": new_chunk
+#                                             }
+#                                         current_text = text_content
+#                                     full_response = text_content
+            
+#             logger.info(f"Agent execution completed.")
+#             logger.info(f"Full response length: {len(full_response)}")
+#             logger.info(f"Tool calls made: {len(self.tool_calls)}")
+#             logger.info(f"Images found: {len(self.images_found)}")
+            
+#             # Process the final response
+#             if full_response:
+#                 # Try to parse as JSON
+#                 response_text = full_response
+#                 keywords = []
+#                 response_images = []
+                
+#                 try:
+#                     # Attempt JSON parsing
+#                     json_response = json.loads(full_response)
+#                     response_text = json_response.get('response', full_response)
+#                     keywords = json_response.get('keywords', [])
+#                     response_images = json_response.get('images', [])
+#                 except json.JSONDecodeError:
+#                     # Not JSON format, use as plain text
+#                     pass
+                
+#                 # Merge all found images
+#                 all_images = list(set(self.images_found + response_images))
+                
+#                 # Save to chat history
+#                 session_id = self._ensure_valid_session(query)
+#                 chat_data = {
+#                     "query": query,
+#                     "response": response_text,
+#                     "references": [],
+#                     "keywords": keywords,
+#                     "images": all_images,
+#                     "context": "",
+#                     "timestamp": datetime.now(timezone.utc).isoformat(),
+#                     "session_id": session_id,
+#                     "tool_calls": self.tool_calls
+#                 }
+                
+#                 saved = self.chat_session.save_chat(chat_data)
+                
+#                 # Send completion signal
+#                 yield {
+#                     "type": "completed",
+#                     "saved": saved,
+#                     "session_id": session_id,
+#                     "keywords": keywords,
+#                     "images": all_images
+#                 }
+                
+#                 logger.info(f"Chat saved successfully: {saved}")
+#             else:
+#                 logger.warning("No response received from agent")
+#                 yield {
+#                     "type": "error",
+#                     "content": "No response generated"
+#                 }
+            
+#         except Exception as e:
+#             logger.error(f"Error processing message: {e}", exc_info=True)
+#             yield {
+#                 "type": "error",
+#                 "content": f"Error processing message: {str(e)}"
+#             }
+    
+#     def _ensure_valid_session(self, title: str = None) -> str:
+#         """Ensure valid chat session exists"""
+#         try:
+#             if not self.session_id or not self.session_id.strip():
+#                 logger.info("Creating new session (no session ID provided)")
+#                 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):
+#                         logger.info(f"Session {self.session_id} invalid, creating new session")
+#                         self.chat_session.create_new_session(title=title)
+#                         self.session_id = self.chat_session.session_id
+#                 except ValueError:
+#                     logger.info(f"Session {self.session_id} validation failed, creating new session")
+#                     self.chat_session.create_new_session(title=title)
+#                     self.session_id = self.chat_session.session_id
+            
+#             logger.info(f"Using session ID: {self.session_id}")
+#             return self.session_id
+#         except Exception as e:
+#             logger.error(f"Error ensuring valid session: {e}", exc_info=True)
+#             raise

app/services/agentic_prompt.py

@@ -0,0 +1,148 @@
+from typing import Dict
+
+
+
+
+
+def _append_personalization(prompt: str, user_data: Dict) -> str:
+    personalized_tool = user_data.get('personalized_tool_name')
+    if user_data.get('has_personalized_data') and personalized_tool:
+        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."
+        )
+    else:
+        prompt += (
+            "\n\nNo personalization data is available; omit the `## Personalization Recommendation` section and do not fabricate patient-specific advice."
+        )
+
+    environmental_tool = user_data.get('environmental_tool_name')
+    if user_data.get('has_environmental_data') and environmental_tool:
+        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."
+        )
+    else:
+        prompt += (
+            "\n\nEnvironmental conditions are unavailable; omit the `## Environmental Condition` section instead of speculating."
+        )
+
+    if user_data.get('language', 'english').lower() != 'english':
+        prompt += (
+            f"\n\nRespond in {user_data.get('language')} while keeping the JSON structure intact."
+        )
+    return prompt
+
+
+def _format_json_guidance(user_data: Dict) -> str:
+    references_instruction = (
+        "Populate the `references` array with source links mapped from your tool calls."
+        if user_data.get('include_references', True)
+        else "Set `references` to an empty array because the user disabled references."
+    )
+    keywords_instruction = (
+        "Provide 4-6 concise medical keywords in the `keywords` array."
+        if user_data.get('include_keywords', True)
+        else "Set `keywords` to an empty array because the user disabled keywords."
+    )
+    images_instruction = (
+        "Include up to three image URLs in the `images` array when medically relevant."
+        if user_data.get('include_images', True)
+        else "Set `images` to an empty array because the user disabled images."
+    )
+
+    has_personalization = user_data.get('has_personalized_data')
+    has_environmental = user_data.get('has_environmental_data')
+    personalized_tool = user_data.get('personalized_tool_name', 'get_personalized_context')
+    environmental_tool = user_data.get('environmental_tool_name', 'get_environmental_context')
+
+    personalization_instruction = (
+        f"Include a `## Personalization Recommendation` section that faithfully reflects the data returned by `{personalized_tool}`."
+        if has_personalization
+        else "Omit the `## Personalization Recommendation` section because no personalization tool data is available."
+    )
+    environmental_instruction = (
+        f"Include a `## Environmental Condition` section only when `{environmental_tool}` returns data; otherwise omit the section instead of speculating."
+        if has_environmental
+        else "Omit the `## Environmental Condition` section because environmental data is unavailable."
+    )
+    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."
+    )
+    return (
+        "\nYour final response MUST be valid JSON with this shape:\n"
+        "{\n"
+        "    \"response\": \"Always start with `## Response from References`. Add `## Personalization Recommendation` only after ingesting personalization tool data, and add `## Environmental Condition` only after ingesting environmental tool data. Under each heading, report only evidence-backed details with inline citations like [1], [2].\",\n"
+        "    \"keywords\": [\"keyword1\", \"keyword2\", ...],\n"
+        "    \"references\": [\"url_or_source_1\", ...],\n"
+        "    \"images\": [\"image_url_1\", ...]\n"
+        "}\n"
+        f"{references_instruction}\n"
+        f"{keywords_instruction}\n"
+        f"{images_instruction}\n"
+        f"{personalization_instruction}\n"
+        f"{environmental_instruction}\n"
+        f"{safety_instruction}\n"
+        "Return only JSON (no prose outside the JSON object).\n"
+        "Do NOT hallucinate or invent facts.\n"
+    )
+
+
+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.
+"""
+    recent_history = user_data.get('recent_history')
+    if recent_history:
+        prompt += (
+            "\n\n## Recent Conversation Context (most recent first)\n"
+            f"{recent_history}\n"
+            "Use this context to maintain continuity before answering the new query."
+        )
+    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.
+"""
+    recent_history = user_data.get('recent_history')
+    if recent_history:
+        prompt += (
+            "\n\n## Recent Conversation Context (most recent first)\n"
+            f"{recent_history}\n"
+            "Use this context to maintain continuity before answering the new query."
+        )
+    prompt += _format_json_guidance(user_data)
+    prompt = _append_personalization(prompt, user_data)
+    return prompt.strip()

app/services/google_agent_service.py

@@ -0,0 +1,485 @@
+import asyncio
+import json
+import logging
+import os
+import re
+from datetime import datetime, timezone
+from typing import Any, AsyncGenerator, Callable, Dict, List, Optional, Tuple
+
+from google.adk.agents import Agent
+from google.adk.agents.run_config import RunConfig, StreamingMode
+from google.adk.runners import InMemoryRunner
+from google.adk.tools import FunctionTool
+from google.genai import types
+
+from app.services.agentic_prompt import (
+    get_vector_search_prompt,
+    get_web_search_prompt,
+)
+from app.services.chathistory import ChatSession
+from app.services.environmental_condition import EnvironmentalData
+from app.services.tools import (
+    get_image_search,
+    get_vector_search,
+    get_web_search,
+)
+
+logger = logging.getLogger(__name__)
+
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY") or os.getenv("GEMINI_API_KEY")
+DEFAULT_MODEL_NAME = os.getenv("GEMINI_MODEL", "gemini-2.0-flash-exp")
+
+PERSONALIZED_TOOL_NAME = "get_personalized_context"
+ENVIRONMENT_TOOL_NAME = "get_environmental_context"
+
+if not os.getenv("GOOGLE_API_KEY") and GOOGLE_API_KEY:
+    os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
+
+if os.name == "nt":
+    try:
+        asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
+    except Exception:  # pragma: no cover
+        pass
+
+
+class GoogleAgentService:
+    """Chat orchestrator that streams responses from a Google ADK agent."""
+
+    def __init__(self, token: str, session_id: Optional[str] = None) -> None:
+        self.token = token
+        self.session_id = session_id
+        self.chat_session = ChatSession(token, session_id)
+
+        self.user_preferences = self._load_user_preferences()
+        self.language = self.chat_session.get_language() or "english"
+        self.user_profile = self._load_user_profile()
+        self.user_city = self.chat_session.get_city()
+        self.environment_data = self._load_environmental_data()
+
+    async def process_message_async(
+        self, query: str
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        if not GOOGLE_API_KEY:
+            error = "Google API key is not configured."
+            logger.error(error)
+            yield {"type": "error", "content": error}
+            return
+
+        try:
+            session_id = self._ensure_valid_session(query)
+            agent_mode = "web" if self.user_preferences.get("websearch") else "vector"
+            user_data = self._prepare_user_data()
+            agent = self._build_agent(agent_mode, user_data)
+            runner = InMemoryRunner(agent=agent)
+
+            await runner.session_service.create_session(
+                app_name=runner.app_name,
+                user_id=self.chat_session.identity,
+                session_id=session_id,
+            )
+
+            user_message = types.Content(
+                role="user",
+                parts=[types.Part(text=query)],
+            )
+
+            run_config = RunConfig(streaming_mode=StreamingMode.SSE)
+
+            tool_calls: List[Dict[str, Any]] = []
+            tool_call_map: Dict[str, Dict[str, Any]] = {}
+            collected_images: List[str] = []
+            collected_references: List[str] = []
+            streamed_text = ""
+            final_text = ""
+            pending_token_buffer = ""
+
+            def emit_word_chunks(delta: str, *, final: bool = False) -> List[str]:
+                nonlocal pending_token_buffer
+
+                pending_token_buffer += delta
+                chunks: List[str] = []
+
+                while pending_token_buffer:
+                    match = re.search(r'\s', pending_token_buffer)
+                    if not match:
+                        break
+                    idx = match.end()
+                    token = pending_token_buffer[:idx]
+                    pending_token_buffer = pending_token_buffer[idx:]
+                    if token:
+                        chunks.append(token)
+
+                if final and pending_token_buffer:
+                    chunks.append(pending_token_buffer)
+                    pending_token_buffer = ""
+
+                return chunks
+
+            async for event in runner.run_async(
+                user_id=self.chat_session.identity,
+                session_id=session_id,
+                new_message=user_message,
+                run_config=run_config,
+            ):
+                if event.error_message:
+                    logger.error("Agent error: %s", event.error_message)
+                    yield {"type": "error", "content": event.error_message}
+                    return
+
+                for function_call in event.get_function_calls():
+                    call_entry = {
+                        "id": function_call.id,
+                        "tool_name": function_call.name,
+                        "arguments": function_call.args or {},
+                    }
+                    tool_call_map[function_call.id] = call_entry
+                    tool_calls.append(call_entry)
+                    yield {
+                        "type": "tool_call",
+                        "id": function_call.id,
+                        "tool_name": function_call.name,
+                        "arguments": function_call.args or {},
+                    }
+
+                for function_response in event.get_function_responses():
+                    response_payload = function_response.response or {}
+                    call_entry = tool_call_map.get(function_response.id)
+                    if call_entry is not None:
+                        call_entry["result"] = response_payload
+                    if isinstance(response_payload, dict):
+                        if function_response.name == "get_image_search":
+                            collected_images.extend(response_payload.get("images", []))
+                        if response_payload.get("references"):
+                            collected_references.extend(response_payload["references"])
+                    yield {
+                        "type": "tool_result",
+                        "id": function_response.id,
+                        "tool_name": function_response.name,
+                        "result": response_payload,
+                    }
+
+                text_segment = self._extract_text(event)
+                if not text_segment:
+                    continue
+
+                if event.partial:
+                    streamed_text += text_segment
+                    for token in emit_word_chunks(text_segment):
+                        yield {"type": "chunk", "content": token}
+                else:
+                    final_text = text_segment
+                    if streamed_text and text_segment.startswith(streamed_text):
+                        delta = text_segment[len(streamed_text) :]
+                    else:
+                        delta = text_segment
+                    if text_segment:
+                        streamed_text = text_segment
+                    for token in emit_word_chunks(delta, final=True):
+                        yield {"type": "chunk", "content": token}
+
+            for leftover in emit_word_chunks("", final=True):
+                if leftover:
+                    yield {"type": "chunk", "content": leftover}
+
+
+            parsed_response = self._parse_agent_response(final_text or streamed_text)
+            response_text, keywords, response_images, response_refs = parsed_response
+
+            merged_images = self._dedupe_list(collected_images + response_images)
+            merged_references = self._dedupe_list(collected_references + response_refs)
+
+            chat_payload = {
+                "query": query,
+                "response": response_text,
+                "references": merged_references,
+                "keywords": keywords,
+                "images": merged_images,
+                "context": "",
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "session_id": session_id,
+                "tool_calls": tool_calls,
+            }
+            saved = self.chat_session.save_chat(chat_payload)
+
+            yield {
+                "type": "completed",
+                "saved": saved,
+                "session_id": session_id,
+                "response": response_text,
+                "keywords": keywords,
+                "references": merged_references,
+                "images": merged_images,
+            }
+        except Exception as exc:
+            logger.error("Agent streaming failure: %s", exc, exc_info=True)
+            yield {"type": "error", "content": f"Generation failed: {exc}"}
+
+
+    def _build_agent(self, mode: str, user_data: Dict[str, Any]) -> Agent:
+        prompt = (
+            get_web_search_prompt(user_data)
+            if mode == "web"
+            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),
+        ]
+
+        if user_data.get("has_personalized_data"):
+            personalized_tool = self._create_personalized_data_tool(
+                user_data.get("personalized_data", "")
+            )
+            tools.append(FunctionTool(personalized_tool))
+
+        if user_data.get("has_environmental_data"):
+            environmental_tool = self._create_environmental_data_tool(
+                user_data.get("environmental_payload") or {}
+            )
+            tools.append(FunctionTool(environmental_tool))
+
+        agent = Agent(
+            name="DermAI",
+            model=DEFAULT_MODEL_NAME,
+            instruction=prompt,
+            tools=tools,
+        )
+        return agent
+
+    def _create_personalized_data_tool(self, data: str) -> Callable[[], Dict[str, Any]]:
+        sanitized = (data or "").strip()
+
+        def personalized_tool() -> Dict[str, Any]:
+            return {
+                "status": "success",
+                "generated_at": datetime.now(timezone.utc).isoformat(),
+                "personalized_data": sanitized,
+            }
+
+        personalized_tool.__name__ = PERSONALIZED_TOOL_NAME
+        personalized_tool.__doc__ = (
+            "Return questionnaire-derived personalization details for the current user."
+        )
+        return personalized_tool
+
+    def _create_environmental_data_tool(
+        self, data: Dict[str, Any]
+    ) -> Callable[[], Dict[str, Any]]:
+        snapshot = dict(data) if isinstance(data, dict) else {}
+        city = self.user_city
+
+        def environmental_tool() -> Dict[str, Any]:
+            return {
+                "status": "success",
+                "city": city,
+                "retrieved_at": datetime.now(timezone.utc).isoformat(),
+                "environmental_data": snapshot,
+            }
+
+        environmental_tool.__name__ = ENVIRONMENT_TOOL_NAME
+        environmental_tool.__doc__ = (
+            "Return the cached environmental conditions for the user's location."
+        )
+        return environmental_tool
+
+    def _load_user_preferences(self) -> Dict[str, Any]:
+        try:
+            return self.chat_session.get_user_preferences()
+        except Exception as exc:
+            logger.warning("Failed to load user preferences: %s", exc)
+            return {
+                "websearch": False,
+                "keywords": True,
+                "references": True,
+                "personalized_recommendations": False,
+                "environmental_recommendations": False,
+            }
+
+    def _load_user_profile(self) -> Dict[str, Any]:
+        try:
+            profile = self.chat_session.get_name_and_age() or {}
+            return {
+                "name": profile.get("name", "Patient"),
+                "age": profile.get("age", "Unknown"),
+            }
+        except Exception as exc:
+            logger.warning("Failed to load profile: %s", exc)
+            return {"name": "Patient", "age": "Unknown"}
+
+
+    def _load_environmental_data(self) -> Optional[Dict[str, Any]]:
+        try:
+            if (
+                self.user_preferences.get("environmental_recommendations")
+                and self.user_city
+            ):
+                data = EnvironmentalData(self.user_city).get_environmental_data()
+                if data:
+                    return data
+        except Exception as exc:
+            logger.warning("Failed to load environmental data: %s", exc)
+        return None
+
+    def _load_personalized_data(self) -> str:
+        try:
+            if self.user_preferences.get("personalized_recommendations"):
+                data = self.chat_session.get_personalized_recommendation()
+                return data or ""
+        except Exception as exc:
+            logger.warning("Failed to load personalized data: %s", exc)
+        return ""
+
+
+    def _prepare_user_data(self) -> Dict[str, Any]:
+        personalized_data = self._load_personalized_data()
+        environmental_payload = (
+            dict(self.environment_data)
+            if isinstance(self.environment_data, dict)
+            else {}
+        )
+        has_personalized_data = bool(personalized_data)
+        has_environmental_data = bool(environmental_payload)
+
+        return {
+            "name": self.user_profile.get("name"),
+            "age": self.user_profile.get("age"),
+            "language": self.language,
+            "personalized_recommendations": self.user_preferences.get(
+                "personalized_recommendations"
+            ),
+            "environmental_recommendations": self.user_preferences.get(
+                "environmental_recommendations"
+            ),
+            "personalized_data": personalized_data,
+            "environmental_data": json.dumps(environmental_payload)
+            if has_environmental_data
+            else "",
+            "has_personalized_data": has_personalized_data,
+            "has_environmental_data": has_environmental_data,
+            "personalized_tool_name": PERSONALIZED_TOOL_NAME
+            if has_personalized_data
+            else None,
+            "environmental_tool_name": ENVIRONMENT_TOOL_NAME
+            if has_environmental_data
+            else None,
+            "environmental_payload": environmental_payload,
+            "include_keywords": self.user_preferences.get("keywords", True),
+            "include_references": self.user_preferences.get("references", True),
+            "include_images": True,
+            "recent_history": self._get_recent_history(),
+        }
+
+    def _get_recent_history(self, limit: int = 10) -> str:
+        try:
+            if not self.session_id:
+                return ""
+            self.chat_session.load_chat_history()
+            history_items = self.chat_session.get_chat_history() or []
+            if not history_items:
+                return ""
+            recent = history_items[-limit:]
+            formatted = []
+            for entry in recent:
+                user_q = entry.get("query") or ""
+                bot_a = entry.get("response") or ""
+                if user_q:
+                    formatted.append(f"User: {user_q}")
+                if bot_a:
+                    formatted.append(f"Dr DermAI: {bot_a}")
+            return "\n".join(formatted[-limit * 2:])
+        except Exception as exc:
+            logger.warning("Failed to load recent history: %s", exc)
+            return ""
+
+    def _ensure_valid_session(self, title: Optional[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 Exception:
+                self.chat_session.create_new_session(title=title)
+                self.session_id = self.chat_session.session_id
+        return self.session_id
+
+    @staticmethod
+    def _extract_text(event) -> str:
+        if not event.content or not event.content.parts:
+            return ""
+        parts: List[str] = []
+        for part in event.content.parts:
+            if part.text:
+                parts.append(part.text)
+        return "".join(parts)
+
+    @staticmethod
+    def _strip_code_fence(text: str) -> str:
+        stripped = text.strip()
+        if stripped.startswith("```") and stripped.endswith("```"):
+            body = stripped.strip("`")
+            if body.lower().startswith("json"):
+                body = body[4:]
+            stripped = body
+        return stripped.strip()
+
+    def _parse_agent_response(self, text: str) -> Tuple[str, List[str], List[str], List[str]]:
+        cleaned = self._strip_code_fence(text)
+        if not cleaned:
+            return "", [], [], []
+        try:
+            payload = json.loads(cleaned)
+        except json.JSONDecodeError:
+            logger.warning("Unable to parse agent JSON response; returning raw text.")
+            return cleaned, [], [], []
+        if not isinstance(payload, dict):
+            return cleaned, [], [], []
+
+        response_text = payload.get("response") or cleaned
+
+        raw_keywords = payload.get("keywords", [])
+        if isinstance(raw_keywords, list):
+            keywords = [str(item).strip() for item in raw_keywords if str(item).strip()]
+        elif raw_keywords:
+            keywords = [str(raw_keywords).strip()]
+        else:
+            keywords = []
+
+        raw_images = payload.get("images", [])
+        if isinstance(raw_images, list):
+            images = [str(item).strip() for item in raw_images if str(item).strip()]
+        elif raw_images:
+            images = [str(raw_images).strip()]
+        else:
+            images = []
+
+        raw_refs = payload.get("references", [])
+        if isinstance(raw_refs, list):
+            references = [str(item).strip() for item in raw_refs if str(item).strip()]
+        elif raw_refs:
+            references = [str(raw_refs).strip()]
+        else:
+            references = []
+
+        return response_text, keywords, images, references
+
+    @staticmethod
+    def _dedupe_list(items: List[str]) -> List[str]:
+        seen = set()
+        deduped: List[str] = []
+        for item in items:
+            if not item:
+                continue
+            if item in seen:
+                continue
+            seen.add(item)
+            deduped.append(item)
+        return deduped
+
+
+
+
+

app/services/llm_model.py

@@ -1,12 +1,12 @@
 import json
-from google import genai
+# from google import genai
 from dotenv import load_dotenv
 import os
-from google import genai
-from google.genai import types
+# from google import genai
+# from google.genai import types
 import re
 from g4f.client import Client
-from google.genai.types import GenerateContentConfig, HttpOptions
+# from google.genai.types import GenerateContentConfig, HttpOptions
 
 load_dotenv()
 

app/services/tools.py

@@ -0,0 +1,142 @@
+import logging
+from typing import Any, Dict, List
+
+from app.services.vector_database_search import VectorDatabaseSearch
+from app.services.websearch import WebSearch
+
+logger = logging.getLogger(__name__)
+
+
+def _clean_query(query: str) -> str:
+    return (query or '').strip()
+
+
+def get_web_search(query: str, num_results: int = 4) -> Dict[str, Any]:
+    """Return up-to-date dermatology information from the public web."""
+    query = _clean_query(query)
+    if not query:
+        return {"status": "error", "error_message": "Query is required."}
+
+    try:
+        web = WebSearch(num_results=max(1, min(num_results or 4, 8)))
+        raw_results = web.search(query) or []
+
+        formatted: List[Dict[str, Any]] = []
+        references: List[str] = []
+        for idx, item in enumerate(raw_results, start=1):
+            link = item.get('link') or item.get('url') or ''
+            snippet = item.get('text') or item.get('snippet') or ''
+            title = item.get('title') or ''
+            entry = {
+                "source_number": idx,
+                "title": title,
+                "link": link,
+                "snippet": snippet,
+            }
+            formatted.append(entry)
+            if link:
+                references.append(link)
+
+        if not formatted:
+            return {
+                "status": "error",
+                "error_message": f"No web results found for '{query}'.",
+            }
+
+        return {
+            "status": "success",
+            "results": formatted,
+            "references": references,
+        }
+    except Exception as exc:
+        logger.exception("Web search failed: %s", exc)
+        return {
+            "status": "error",
+            "error_message": f"Web search failed: {exc}",
+        }
+
+
+def get_vector_search(query: str, top_k: int = 5) -> Dict[str, Any]:
+    """Return dermatology knowledge from the curated vector database."""
+    query = _clean_query(query)
+    if not query:
+        return {"status": "error", "error_message": "Query is required."}
+
+    try:
+        vector = VectorDatabaseSearch()
+        if not vector.is_available():
+            return {
+                "status": "error",
+                "error_message": "Vector database is not available.",
+            }
+
+        raw_results = vector.search(query, top_k=max(1, min(top_k or 5, 10)))
+        if not raw_results:
+            return {
+                "status": "error",
+                "error_message": f"No vector results found for '{query}'.",
+            }
+
+        formatted: List[Dict[str, Any]] = []
+        references: List[str] = []
+        for idx, item in enumerate(raw_results, start=1):
+            source = item.get('source') or 'Unknown'
+            page = item.get('page') or 0
+            content = item.get('content') or ''
+            confidence = item.get('confidence')
+            formatted.append(
+                {
+                    "source_number": idx,
+                    "source": source,
+                    "page": page,
+                    "content": content,
+                    "confidence": confidence,
+                }
+            )
+            ref_label = f"{source} (page {page})" if page else source
+            references.append(ref_label)
+
+        return {
+            "status": "success",
+            "results": formatted,
+            "references": references,
+        }
+    except Exception as exc:
+        logger.exception("Vector search failed: %s", exc)
+        return {
+            "status": "error",
+            "error_message": f"Vector search failed: {exc}",
+        }
+
+
+def get_image_search(query: str, max_images: int = 3) -> Dict[str, Any]:
+    """Return dermatology-relevant image URLs for the given query."""
+    query = _clean_query(query)
+    if not query:
+        return {"status": "error", "error_message": "Query is required."}
+
+    try:
+        searcher = WebSearch(max_images=max(1, min(max_images or 3, 8)))
+        images = searcher.search_images(query) or []
+        unique_images = []
+        seen = set()
+        for url in images:
+            if url and url not in seen:
+                seen.add(url)
+                unique_images.append(url)
+            if len(unique_images) >= max_images:
+                break
+
+        if not unique_images:
+            return {
+                "status": "error",
+                "error_message": f"No images found for '{query}'.",
+            }
+
+        return {"status": "success", "images": unique_images}
+    except Exception as exc:
+        logger.exception("Image search failed: %s", exc)
+        return {
+            "status": "error",
+            "error_message": f"Image search failed: {exc}",
+        }

document_code.py

@@ -0,0 +1,146 @@
+import os
+from pathlib import Path
+
+def generate_tree(path, prefix=""):
+    """Generate tree structure"""
+    items = []
+    try:
+        entries = sorted(path.iterdir(), key=lambda x: (x.is_file(), x.name))
+        # Filter out ignored entries first
+        filtered_entries = [e for e in entries if not should_ignore(e)]
+        
+        for i, entry in enumerate(filtered_entries):
+            is_last = i == len(filtered_entries) - 1
+            current_prefix = "└── " if is_last else "├── "
+            
+            items.append(f"{prefix}{current_prefix}{entry.name}")
+            
+            if entry.is_dir():
+                next_prefix = prefix + ("    " if is_last else "│   ")
+                items.extend(generate_tree(entry, next_prefix))
+    except PermissionError:
+        pass
+    return items
+
+def should_ignore(path):
+    """Check if file/folder should be ignored"""
+    # Explicitly check for virtual environments and common ignored folders
+    if path.name in {'.venv', 'venv', '__pycache__', '.git', 'node_modules', '.idea', '.vscode'}:
+        return True
+    
+    # Check if file is inside .venv or venv folder
+    if '.venv' in path.parts or 'venv' in path.parts:
+        return True
+        
+    # Ignore all hidden files/folders (starting with .)
+    if path.name.startswith('.'):
+        return True
+    
+    # Ignore specific files
+    ignore_files = {
+        'CODE_DOCUMENTATION.md', 'CODE_DOCUMENTATION.ipynb',
+        'CODE_DOCUMENTATION.html', 'CODE_DOCUMENTATION.pdf',
+        'CODE_DOCUMENTATION.docx', 'CODE_DOCUMENTATION.txt',
+        'CODE_DOCUMENTATION.csv', 'CODE_DOCUMENTATION.xlsx',
+        'CODE_DOCUMENTATION.pptx', 'CODE_DOCUMENTATION.ods',
+        'CODE_DOCUMENTATION.odp', 'CODE_DOCUMENTATION.odt',
+        'uv.lock', 'poetry.lock', 'Pipfile.lock',
+        '.DS_Store'
+    }
+    
+    # Ignore by file extension
+    ignore_extensions = {'.pyc', '.pyo', '.pyd', '.so', '.egg-info'}
+    
+    return (path.name in ignore_files or 
+            path.suffix in ignore_extensions or
+            path.name.endswith('.egg-info'))
+
+def get_code_files(directory):
+    """Get all relevant code files"""
+    code_extensions = {'.py', '.js', '.ts', '.html', '.css', '.sql', '.yaml', '.yml', '.json', '.toml', '.cfg', '.ini'}
+    code_files = []
+    
+    for file_path in directory.rglob("*"):
+        # Skip if it's a directory
+        if file_path.is_dir():
+            continue
+            
+        # Skip ignored files/folders
+        if should_ignore(file_path):
+            continue
+            
+        # Only include files with relevant extensions
+        if file_path.suffix.lower() in code_extensions:
+            code_files.append(file_path)
+    
+    return sorted(code_files)
+
+def main():
+    current_dir = Path.cwd()
+    output_file = current_dir / "CODE_DOCUMENTATION.md"
+    
+    # Generate markdown
+    markdown = f"# {current_dir.name}\n\n"
+    markdown += f"Generated on: {Path.cwd()}\n\n"
+    
+    # Add tree structure
+    markdown += "## Project Structure\n\n```\n"
+    markdown += f"{current_dir.name}/\n"
+    tree_items = generate_tree(current_dir)
+    for item in tree_items:
+        markdown += f"{item}\n"
+    markdown += "```\n\n"
+    
+    # Get all code files
+    code_files = get_code_files(current_dir)
+    
+    if code_files:
+        markdown += "## Source Code\n\n"
+        
+        for file_path in code_files:
+            try:
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+                
+                rel_path = file_path.relative_to(current_dir)
+                file_extension = file_path.suffix.lstrip('.')
+                
+                # Use appropriate syntax highlighting
+                if file_extension == 'py':
+                    lang = 'python'
+                elif file_extension in ['js', 'ts']:
+                    lang = 'javascript'
+                elif file_extension in ['html']:
+                    lang = 'html'
+                elif file_extension in ['css']:
+                    lang = 'css'
+                elif file_extension in ['sql']:
+                    lang = 'sql'
+                elif file_extension in ['yaml', 'yml']:
+                    lang = 'yaml'
+                elif file_extension in ['json']:
+                    lang = 'json'
+                else:
+                    lang = file_extension
+                
+                markdown += f"### {rel_path}\n\n"
+                markdown += f"```{lang}\n{content}\n```\n\n"
+                
+            except Exception as e:
+                markdown += f"### {rel_path}\n\n"
+                markdown += f"*Could not read file: {str(e)}*\n\n"
+                continue
+    else:
+        markdown += "## Source Code\n\n*No code files found.*\n\n"
+    
+    # Write output
+    try:
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write(markdown)
+        print(f"✅ Documentation generated successfully: {output_file}")
+        print(f"📁 Total files documented: {len(code_files)}")
+    except Exception as e:
+        print(f"❌ Error writing documentation: {str(e)}")
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -8,7 +8,7 @@ authors = [
 dependencies = [
     "beautifulsoup4==4.13.4",
     "fastapi==0.115.12",
-    "google-genai==1.13.0",
+    "google-genai==1.36.0",
     "huggingface_hub==0.30.2",
     "langchain_community==0.3.23",
     "langchain_google_genai==2.1.4",
@@ -41,7 +41,8 @@ dependencies = [
     "python-pptx==1.0.2",
     "puremagic==1.28",
     "charset-normalizer==3.4.1",
-    "pytesseract==0.3.13"
+    "pytesseract==0.3.13",
+    "langchain-google-genai"
 ]
 
 [build-system]