Initial deployment: FastAPI backend with Docker

.dockerignore

@@ -0,0 +1,9 @@
+.venv
+__pycache__
+*.pyc
+.env
+data/
+.git
+*.md
+test/
+scripts/

Dockerfile

@@ -0,0 +1,35 @@
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first (Docker layer caching)
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Pre-download sentence-transformer models during build
+# This avoids slow cold-start downloads at runtime
+RUN python -c "\
+from sentence_transformers import SentenceTransformer, CrossEncoder; \
+SentenceTransformer('all-MiniLM-L6-v2'); \
+CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')"
+
+# Copy application code
+COPY . .
+
+# Create data directories
+RUN mkdir -p data/chromadb
+
+# Default port (HF Spaces sets PORT=7860, local default is 8000)
+ENV PORT=7860
+
+# Expose port
+EXPOSE ${PORT}
+
+# Start uvicorn with configurable port
+CMD uvicorn app.main:app --host 0.0.0.0 --port ${PORT}

README.md

@@ -1,10 +1,13 @@
 ---
-title: Buildersai
-emoji: 🚀
-colorFrom: pink
-colorTo: green
+title: BuildersAI
+emoji: 🏗️
+colorFrom: blue
+colorTo: indigo
 sdk: docker
+app_port: 7860
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Builder's AI - Backend API
+
+Construction AI Assistant API with Multi-Agent RAG System.

app/config/settings.py

@@ -0,0 +1,54 @@
+from pydantic_settings import BaseSettings
+from typing import List, Optional
+
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables."""
+    
+    # App Configuration
+    SECRET_KEY: str
+    DEBUG: bool = False
+    PORT: int = 8000
+    
+    # Database
+    DATABASE_URL: str = "sqlite:///data/database.db"
+    
+    # AI Services
+    GROQ_API_KEY: str
+    GROQ_MODEL: str = "llama-3.1-8b-instant"
+    TAVILY_API_KEY: str
+    
+    # JWT Configuration
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 15
+    REFRESH_TOKEN_EXPIRE_DAYS: int = 7
+    ALGORITHM: str = "HS256"
+    
+    # Google OAuth
+    GOOGLE_CLIENT_ID: Optional[str] = ""
+    GOOGLE_CLIENT_SECRET: Optional[str] = ""
+    GOOGLE_REDIRECT_URI: Optional[str] = ""
+    
+    # CORS
+    ALLOWED_ORIGINS: str
+    
+    @property
+    def cors_origins(self) -> List[str]:
+        """Parse CORS origins from comma-separated string."""
+        return [origin.strip() for origin in self.ALLOWED_ORIGINS.split(",")]
+    
+    # Backward compatibility properties (lowercase)
+    @property
+    def secret_key(self) -> str:
+        return self.SECRET_KEY
+    
+    @property
+    def algorithm(self) -> str:
+        return self.ALGORITHM
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+
+# Global settings instance
+settings = Settings()

app/database/connection.py

@@ -0,0 +1,33 @@
+from sqlalchemy import create_engine, Column, String, Integer, Text, DateTime, ForeignKey
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, relationship
+from datetime import datetime
+import uuid
+
+from app.config.settings import settings
+
+# Create SQLAlchemy engine
+engine = create_engine(
+    settings.DATABASE_URL,
+    connect_args={"check_same_thread": False}  # Needed for SQLite
+)
+
+# Session factory
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Base class for models
+Base = declarative_base()
+
+
+def get_db():
+    """Dependency to get database session."""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+def init_db():
+    """Initialize database tables."""
+    Base.metadata.create_all(bind=engine)

app/database/models.py

@@ -0,0 +1,122 @@
+from sqlalchemy import Column, String, Integer, Text, DateTime, ForeignKey, CheckConstraint
+from sqlalchemy.orm import relationship
+from datetime import datetime
+import uuid
+
+from app.database.connection import Base
+
+
+def generate_id():
+    """Generate a unique ID."""
+    return str(uuid.uuid4())
+
+
+class User(Base):
+    """User model for authentication."""
+    __tablename__ = "users"
+    
+    id = Column(String, primary_key=True, default=generate_id)
+    email = Column(String, unique=True, nullable=False, index=True)
+    name = Column(String, nullable=True)
+    password_hash = Column(String, nullable=True)  # Nullable for OAuth users
+    google_id = Column(String, unique=True, nullable=True, index=True)
+    is_admin = Column(Integer, default=0)  # 0 = regular user, 1 = admin
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    # Relationships
+    sessions = relationship("Session", back_populates="user", cascade="all, delete-orphan")
+    documents = relationship("Document", back_populates="user", cascade="all, delete-orphan")
+
+
+class Session(Base):
+    """Chat session model."""
+    __tablename__ = "sessions"
+    
+    id = Column(String, primary_key=True, default=generate_id)
+    user_id = Column(String, ForeignKey("users.id", ondelete="CASCADE"), nullable=True, index=True)
+    title = Column(String, default="New Conversation")
+    summary = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    # Relationships
+    user = relationship("User", back_populates="sessions")
+    messages = relationship("Message", back_populates="session", cascade="all, delete-orphan")
+
+
+class Message(Base):
+    """Chat message model."""
+    __tablename__ = "messages"
+    
+    id = Column(String, primary_key=True, default=generate_id)
+    session_id = Column(String, ForeignKey("sessions.id", ondelete="CASCADE"), nullable=False, index=True)
+    role = Column(String, nullable=False)  # 'user' or 'assistant'
+    content = Column(Text, nullable=False)
+    meta = Column(Text, nullable=True)  # JSON string for metadata (agent, sources, etc.)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    
+    # Relationships
+    session = relationship("Session", back_populates="messages")
+    
+    # Constraint
+    __table_args__ = (
+        CheckConstraint("role IN ('user', 'assistant')", name="check_role"),
+    )
+
+
+class Document(Base):
+    """Uploaded document model."""
+    __tablename__ = "documents"
+    
+    id = Column(String, primary_key=True, default=generate_id)
+    user_id = Column(String, ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True)
+    filename = Column(String, nullable=False)
+    file_path = Column(String, nullable=False)
+    file_type = Column(String, nullable=True)
+    file_size = Column(Integer, nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    
+    # Relationships
+    user = relationship("User", back_populates="documents")
+
+
+class OfficialPolicy(Base):
+    """Official policy document model (admin-only upload, visible to all)."""
+    __tablename__ = "official_policies"
+    
+    id = Column(String, primary_key=True, default=generate_id)
+    title = Column(String, nullable=False)
+    description = Column(Text, nullable=True)
+    filename = Column(String, nullable=False)
+    file_path = Column(String, nullable=False)
+    file_type = Column(String, nullable=True)
+    file_size = Column(Integer, nullable=True)
+    category = Column(String, nullable=True)  # e.g., "OSHA", "Safety", "Building Codes"
+    uploaded_by = Column(String, ForeignKey("users.id"), nullable=False)
+    is_active = Column(Integer, default=1)  # 0 = inactive, 1 = active
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
+class UserSettings(Base):
+    """User settings and preferences model."""
+    __tablename__ = "user_settings"
+    
+    id = Column(String, primary_key=True, default=generate_id)
+    user_id = Column(String, ForeignKey("users.id", ondelete="CASCADE"), nullable=False, unique=True, index=True)
+    
+    # Profile settings
+    bio = Column(Text, nullable=True)
+    phone = Column(String, nullable=True)
+    company = Column(String, nullable=True)
+    
+    # Appearance settings
+    theme = Column(String, default="system")  # light, dark, system
+    
+    # Notification settings
+    email_notifications = Column(Integer, default=1)  # 0 = off, 1 = on
+    update_notifications = Column(Integer, default=1)  # 0 = off, 1 = on
+    
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

app/llm/agents/general.py

@@ -0,0 +1,61 @@
+from typing import Dict, List
+import os
+
+from app.llm.client import llm_client
+
+
+class GeneralAgent:
+    """Agent for general construction questions and conversations."""
+    
+    def __init__(self):
+        """Initialize general agent with prompt template."""
+        prompt_path = os.path.join(
+            os.path.dirname(__file__), 
+            "..", 
+            "prompts", 
+            "general.txt"
+        )
+        with open(prompt_path, "r") as f:
+            self.system_prompt = f.read()
+    
+    def answer(self, query: str, chat_history: List[Dict] = None) -> Dict[str, any]:
+        """
+        Generate answer for general construction queries.
+        
+        Args:
+            query: User query string
+            chat_history: Optional chat history for context
+            
+        Returns:
+            Dictionary with 'answer' and 'agent' keys
+        """
+        try:
+            messages = [{"role": "system", "content": self.system_prompt}]
+            
+            # Add chat history if provided
+            if chat_history:
+                messages.extend(chat_history[-6:])  # Last 3 exchanges
+            
+            messages.append({"role": "user", "content": query})
+            
+            answer = llm_client.get_completion(
+                messages=messages,
+                temperature=0.7,
+                max_tokens=1024
+            )
+            
+            return {
+                "answer": answer,
+                "agent": "general"
+            }
+            
+        except Exception as e:
+            print(f"General agent error: {e}")
+            return {
+                "answer": "I apologize, but I encountered an error. Please try again.",
+                "agent": "general"
+            }
+
+
+# Global general agent instance
+general_agent = GeneralAgent()

app/llm/agents/policy.py

@@ -0,0 +1,173 @@
+from typing import Dict, List
+import os
+
+from app.llm.client import llm_client
+from app.services.rag_service import rag_service
+
+
+class PolicyAgent:
+    """Agent for construction policy and regulatory queries using official policy documents."""
+    
+    def __init__(self):
+        """Initialize policy agent with prompt template."""
+        prompt_path = os.path.join(
+            os.path.dirname(__file__), 
+            "..", 
+            "prompts", 
+            "policy.txt"
+        )
+        with open(prompt_path, "r") as f:
+            self.system_prompt = f.read()
+    
+    def answer(self, query: str, context_chunks: List[Dict] = None) -> Dict[str, any]:
+        """
+        Generate answer for policy/regulatory queries using official policy documents.
+        
+        Args:
+            query: User query string
+            context_chunks: Retrieved policy chunks from RAG search
+            
+        Returns:
+            Dictionary with 'answer', 'agent', and 'sources' keys
+        """
+        try:
+            # If no context provided, search all official policies (retrieve more chunks for better coverage)
+            if context_chunks is None:
+                context_chunks = rag_service.collection.query(
+                    query_embeddings=[rag_service.embedding_generator.generate_embedding(query)],
+                    n_results=10,  # Increased from 5 to 10 for better coverage
+                    where={"user_id": "official_policies"}
+                )
+                
+                # Format results
+                if context_chunks and context_chunks['documents']:
+                    context_chunks = [
+                        {
+                            "content": context_chunks['documents'][0][i],
+                            "metadata": context_chunks['metadatas'][0][i]
+                        }
+                        for i in range(len(context_chunks['documents'][0]))
+                    ]
+                else:
+                    context_chunks = []
+            
+            # Build context from chunks
+            if not context_chunks:
+                return {
+                    "answer": "I don't have any official policy documents to answer this question. Please ensure policies are uploaded in the Admin Panel.",
+                    "agent": "policy",
+                    "sources": []
+                }
+            
+            # Format context with clear chunk numbering
+            context_sections = []
+            for i, chunk in enumerate(context_chunks, 1):
+                doc_id = chunk['metadata'].get('document_id', 'unknown')
+                filename = chunk['metadata'].get('filename', 'Official Policy')
+                chunk_idx = chunk['metadata'].get('chunk_index', '?')
+                
+                context_sections.append(
+                    f"=== EXCERPT {i} ===\n"
+                    f"Document: {filename}\n"
+                    f"Document ID: {doc_id}\n"
+                    f"Section: Chunk {chunk_idx}\n"
+                    f"---\n"
+                    f"{chunk['content']}\n"
+                )
+            
+            context_text = "\n".join(context_sections)
+            
+            # Create strict user message
+            user_message = f"""DOCUMENT EXCERPTS FROM OFFICIAL POLICY:
+
+{context_text}
+
+========================================
+USER QUESTION: {query}
+========================================
+
+REMEMBER: 
+- Answer using ONLY the excerpts above
+- Include clause/section numbers if present in the text
+- Quote exact definitions or requirements
+- If the answer is not in the excerpts, say "The provided document sections do not contain this information"
+- Do NOT use external knowledge from other building codes
+
+Now provide your answer:"""
+            
+            messages = [
+                {"role": "system", "content": self.system_prompt},
+                {"role": "user", "content": user_message}
+            ]
+            
+            answer = llm_client.get_completion(
+                messages=messages,
+                temperature=0.1,  # Very low temperature for maximum accuracy and minimal creativity
+                max_tokens=2000
+            )
+            
+            # Extract sources and policy names
+            sources = []
+            policy_names = set()
+            
+            # Get policy titles from database
+            from app.database.connection import SessionLocal
+            from app.database.models import OfficialPolicy
+            
+            db = SessionLocal()
+            try:
+                # Collect unique document IDs
+                doc_ids = set()
+                for chunk in context_chunks:
+                    doc_id = chunk["metadata"].get("document_id", "")
+                    if doc_id:
+                        doc_ids.add(doc_id)
+                
+                # Fetch policy titles from database
+                policy_title_map = {}
+                if doc_ids:
+                    policies = db.query(OfficialPolicy).filter(
+                        OfficialPolicy.id.in_(doc_ids)
+                    ).all()
+                    policy_title_map = {p.id: p.title for p in policies}
+                
+                # Build sources and collect policy names
+                for chunk in context_chunks:
+                    doc_id = chunk["metadata"].get("document_id", "")
+                    policy_title = policy_title_map.get(doc_id, chunk["metadata"].get("filename", "Official Policy"))
+                    
+                    sources.append({
+                        "content": chunk["content"][:300] + "...",
+                        "document_id": doc_id,
+                        "filename": chunk["metadata"].get("filename", "Official Policy"),
+                        "title": policy_title,
+                        "chunk_index": chunk["metadata"].get("chunk_index", 0)
+                    })
+                    
+                    # Collect unique policy titles (not filenames)
+                    if policy_title:
+                        policy_names.add(policy_title)
+            
+            finally:
+                db.close()
+            
+            print(f"[Policy Agent] Returning policy_names: {list(policy_names)}")
+            
+            return {
+                "answer": answer,
+                "agent": "policy",
+                "sources": sources,
+                "policy_names": list(policy_names)  # List of policy titles used
+            }
+            
+        except Exception as e:
+            print(f"Policy agent error: {e}")
+            return {
+                "answer": "I encountered an error while processing your policy question. Please try again.",
+                "agent": "policy",
+                "sources": []
+            }
+
+
+# Global policy agent instance
+policy_agent = PolicyAgent()

app/llm/agents/rag.py

@@ -0,0 +1,86 @@
+from typing import Dict, List
+import os
+
+from app.llm.client import llm_client
+
+
+class RAGAgent:
+    """Agent for document-based question answering using RAG."""
+    
+    def __init__(self):
+        """Initialize RAG agent with prompt template."""
+        prompt_path = os.path.join(
+            os.path.dirname(__file__), 
+            "..", 
+            "prompts", 
+            "rag.txt"
+        )
+        with open(prompt_path, "r") as f:
+            self.system_prompt = f.read()
+    
+    def answer(self, query: str, context_chunks: List[Dict]) -> Dict[str, any]:
+        """
+        Generate answer based on retrieved document chunks.
+        
+        Args:
+            query: User query string
+            context_chunks: List of retrieved document chunks with metadata
+            
+        Returns:
+            Dictionary with 'answer', 'sources', and 'agent' keys
+        """
+        try:
+            # Format context for LLM
+            context = self._format_context(context_chunks)
+            
+            messages = [
+                {"role": "system", "content": self.system_prompt},
+                {"role": "user", "content": f"Context:\n{context}\n\nQuery: {query}"}
+            ]
+            
+            answer = llm_client.get_completion(
+                messages=messages,
+                temperature=0.3,  # Lower temperature for factual accuracy
+                max_tokens=1024
+            )
+            
+            # Extract unique sources
+            sources = list({
+                chunk.get("metadata", {}).get("filename", "Unknown")
+                for chunk in context_chunks
+            })
+            
+            return {
+                "answer": answer,
+                "sources": sources,
+                "agent": "rag"
+            }
+            
+        except Exception as e:
+            print(f"RAG agent error: {e}")
+            return {
+                "answer": "I encountered an error while processing your question. Please try again.",
+                "sources": [],
+                "agent": "rag"
+            }
+    
+    def _format_context(self, chunks: List[Dict]) -> str:
+        """Format document chunks for LLM context."""
+        if not chunks:
+            return "No relevant documents found."
+        
+        formatted = []
+        for i, chunk in enumerate(chunks, 1):
+            metadata = chunk.get("metadata", {})
+            content = chunk.get("content", "")
+            filename = metadata.get("filename", "Unknown")
+            
+            formatted.append(
+                f"[Document {i}: {filename}]\n{content}\n"
+            )
+        
+        return "\n---\n".join(formatted)
+
+
+# Global RAG agent instance
+rag_agent = RAGAgent()

app/llm/agents/router.py

@@ -0,0 +1,62 @@
+from typing import Dict, List
+import json
+import os
+
+from app.llm.client import llm_client
+
+
+class RouterAgent:
+    """Agent that routes queries to appropriate specialized agents."""
+    
+    def __init__(self):
+        """Initialize router agent with prompt template."""
+        prompt_path = os.path.join(
+            os.path.dirname(__file__), 
+            "..", 
+            "prompts", 
+            "router.txt"
+        )
+        with open(prompt_path, "r") as f:
+            self.system_prompt = f.read()
+    
+    def route(self, query: str, chat_history: List[Dict] = None) -> Dict[str, str]:
+        """
+        Route a query to the appropriate agent.
+        
+        Args:
+            query: User query string
+            chat_history: Optional chat history for context
+            
+        Returns:
+            Dictionary with 'agent' and 'reasoning' keys
+        """
+        messages = [
+            {"role": "system", "content": self.system_prompt},
+            {"role": "user", "content": query}
+        ]
+        
+        try:
+            response = llm_client.get_completion(
+                messages=messages,
+                temperature=0.3,
+                max_tokens=256,
+                json_mode=True
+            )
+            
+            result = json.loads(response)
+            
+            # Validate response
+            if "agent" not in result or result["agent"] not in ["search", "rag", "policy", "general"]:
+                # Default to general if invalid
+                return {"agent": "general", "reasoning": "Default routing"}
+            
+            return result
+            
+        except Exception as e:
+            print(f"Router agent error: {e}")
+            # Default to general agent on error
+            return {"agent": "general", "reasoning": "Error in routing, using general agent"}
+
+
+# Global router agent instance
+router_agent = RouterAgent()

app/llm/agents/search.py

@@ -0,0 +1,91 @@
+from typing import Dict, List
+import os
+from tavily import TavilyClient
+
+from app.llm.client import llm_client
+from app.config.settings import settings
+
+
+class SearchAgent:
+    """Agent that performs web searches and generates answers."""
+    
+    def __init__(self):
+        """Initialize search agent with Tavily client and prompt."""
+        self.tavily_client = TavilyClient(api_key=settings.TAVILY_API_KEY)
+        
+        prompt_path = os.path.join(
+            os.path.dirname(__file__), 
+            "..", 
+            "prompts", 
+            "search.txt"
+        )
+        with open(prompt_path, "r") as f:
+            self.system_prompt = f.read()
+    
+    def search_and_answer(self, query: str) -> Dict[str, any]:
+        """
+        Perform web search and generate answer.
+        
+        Args:
+            query: User query string
+            
+        Returns:
+            Dictionary with 'answer' and 'sources' keys
+        """
+        try:
+            # Perform Tavily search
+            search_results = self.tavily_client.search(
+                query=query,
+                search_depth="basic",
+                max_results=5
+            )
+            
+            # Format search results for LLM
+            context = self._format_search_results(search_results.get("results", []))
+            
+            # Generate answer using LLM
+            messages = [
+                {"role": "system", "content": self.system_prompt},
+                {"role": "user", "content": f"Query: {query}\n\nSearch Results:\n{context}"}
+            ]
+            
+            answer = llm_client.get_completion(
+                messages=messages,
+                temperature=0.7,
+                max_tokens=1024
+            )
+            
+            # Extract sources
+            sources = [
+                {"title": r.get("title"), "url": r.get("url")}
+                for r in search_results.get("results", [])
+            ]
+            
+            return {
+                "answer": answer,
+                "sources": sources,
+                "agent": "search"
+            }
+            
+        except Exception as e:
+            print(f"Search agent error: {e}")
+            return {
+                "answer": "I encountered an error while searching for information. Please try again.",
+                "sources": [],
+                "agent": "search"
+            }
+    
+    def _format_search_results(self, results: List[Dict]) -> str:
+        """Format search results for LLM context."""
+        formatted = []
+        for i, result in enumerate(results, 1):
+            formatted.append(
+                f"{i}. {result.get('title', 'No title')}\n"
+                f"   URL: {result.get('url', 'No URL')}\n"
+                f"   Content: {result.get('content', 'No content')}\n"
+            )
+        return "\n".join(formatted)
+
+
+# Global search agent instance
+search_agent = SearchAgent()

app/llm/client.py

@@ -0,0 +1,84 @@
+from groq import Groq
+from typing import List, Dict, Optional
+import json
+
+from app.config.settings import settings
+
+
+class LLMClient:
+    """Client for interacting with Groq LLM API."""
+    
+    def __init__(self):
+        """Initialize Groq client."""
+        self.client = Groq(api_key=settings.GROQ_API_KEY)
+        self.model = settings.GROQ_MODEL
+    
+    def get_completion(
+        self,
+        messages: List[Dict[str, str]],
+        temperature: float = 0.7,
+        max_tokens: int = 1024,
+        json_mode: bool = False
+    ) -> str:
+        """
+        Get completion from Groq LLM.
+        
+        Args:
+            messages: List of message dictionaries with 'role' and 'content'
+            temperature: Sampling temperature (0-2)
+            max_tokens: Maximum tokens in response
+            json_mode: Whether to request JSON output
+            
+        Returns:
+            Response content string
+        """
+        try:
+            response_format = {"type": "json_object"} if json_mode else None
+            
+            chat_completion = self.client.chat.completions.create(
+                messages=messages,
+                model=self.model,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                response_format=response_format
+            )
+            
+            return chat_completion.choices[0].message.content
+            
+        except Exception as e:
+            print(f"Error getting LLM completion: {e}")
+            raise
+    
+    def get_completion_with_retry(
+        self,
+        messages: List[Dict[str, str]],
+        temperature: float = 0.7,
+        max_tokens: int = 1024,
+        json_mode: bool = False,
+        max_retries: int = 3
+    ) -> str:
+        """
+        Get completion with retry logic.
+        
+        Args:
+            messages: List of message dictionaries
+            temperature: Sampling temperature
+            max_tokens: Maximum tokens
+            json_mode: Whether to request JSON output
+            max_retries: Maximum number of retries
+            
+        Returns:
+            Response content string
+        """
+        for attempt in range(max_retries):
+            try:
+                return self.get_completion(messages, temperature, max_tokens, json_mode)
+            except Exception as e:
+                if attempt == max_retries - 1:
+                    raise
+                print(f"Retry {attempt + 1}/{max_retries} after error: {e}")
+                continue
+
+
+# Global LLM client instance
+llm_client = LLMClient()

app/llm/graph.py

@@ -0,0 +1,450 @@
+"""
+LangGraph-based multi-agent workflow for Builder's AI.
+This implements a graph-based orchestration of multiple specialized agents.
+"""
+from typing import Dict, List, Optional
+from langgraph.graph import StateGraph, END
+import json
+
+from app.llm.state import AgentState
+from app.llm.agents.router import router_agent
+from app.llm.agents.search import search_agent
+from app.llm.agents.rag import rag_agent
+from app.llm.agents.policy import policy_agent
+from app.llm.agents.general import general_agent
+from app.services.rag_service import rag_service
+from app.utils.embeddings import embedding_generator
+
+
+class MultiAgentGraph:
+    """LangGraph-based multi-agent workflow orchestrator."""
+    
+    def __init__(self):
+        """Initialize the multi-agent graph."""
+        self.graph = self._build_graph()
+        print("[Multi-Agent Graph] Initialized")
+    
+    def _build_graph(self) -> StateGraph:
+        """
+        Build the LangGraph workflow.
+        
+        Returns:
+            Compiled StateGraph
+        """
+        # Create workflow graph
+        workflow = StateGraph(AgentState)
+        
+        # Add nodes
+        workflow.add_node("router", self._router_node)
+        workflow.add_node("search_agent", self._search_node)
+        workflow.add_node("rag_agent", self._rag_node)
+        workflow.add_node("policy_agent", self._policy_node)
+        workflow.add_node("general_agent", self._general_node)
+        
+        # Set entry point
+        workflow.set_entry_point("router")
+        
+        # Add conditional edges from router to specialized agents
+        workflow.add_conditional_edges(
+            "router",
+            self._route_query,
+            {
+                "search": "search_agent",
+                "rag": "rag_agent",
+                "policy": "policy_agent",
+                "general": "general_agent"
+            }
+        )
+        
+        # All agent nodes end the workflow
+        workflow.add_edge("search_agent", END)
+        workflow.add_edge("rag_agent", END)
+        workflow.add_edge("policy_agent", END)
+        workflow.add_edge("general_agent", END)
+        
+        # Compile the graph
+        return workflow.compile()
+    
+    def _router_node(self, state: AgentState) -> AgentState:
+        """
+        Router node: Determines which specialized agent should handle the query.
+        
+        Args:
+            state: Current agent state
+            
+        Returns:
+            Updated state with routing decision
+        """
+        print(f"[Router Node] Processing query: {state['query'][:50]}...")
+        
+        try:
+            # Use router agent to determine the appropriate agent
+            routing = router_agent.route(
+                query=state["query"],
+                chat_history=state.get("chat_history", [])
+            )
+            
+            agent_type = routing.get("agent", "general")
+            reasoning = routing.get("reasoning", "")
+            
+            print(f"[Router Node] Routing to: {agent_type} - {reasoning}")
+            
+            return {
+                **state,
+                "agent_type": agent_type,
+                "routing_reasoning": reasoning
+            }
+            
+        except Exception as e:
+            print(f"[Router Node] Error: {e}")
+            return {
+                **state,
+                "agent_type": "general",
+                "routing_reasoning": f"Error in routing: {str(e)}",
+                "error": str(e)
+            }
+    
+    def _route_query(self, state: AgentState) -> str:
+        """
+        Conditional edge function to route to the appropriate agent.
+        
+        Args:
+            state: Current agent state
+            
+        Returns:
+            Agent type string
+        """
+        return state.get("agent_type", "general")
+    
+    def _search_node(self, state: AgentState) -> AgentState:
+        """
+        Search agent node: Performs web search and generates answer.
+        
+        Args:
+            state: Current agent state
+            
+        Returns:
+            Updated state with search results and answer
+        """
+        print("[Search Node] Executing web search...")
+        
+        try:
+            response = search_agent.search_and_answer(state["query"])
+            
+            return {
+                **state,
+                "answer": response.get("answer", ""),
+                "sources": response.get("sources", []),
+                "search_results": response.get("sources", []),
+                "metadata": {
+                    "agent": "search",
+                    "routing_reasoning": state.get("routing_reasoning", "")
+                }
+            }
+            
+        except Exception as e:
+            print(f"[Search Node] Error: {e}")
+            return {
+                **state,
+                "answer": "I encountered an error while searching. Please try again.",
+                "sources": [],
+                "error": str(e)
+            }
+    
+    def _rag_node(self, state: AgentState) -> AgentState:
+        """
+        RAG agent node: Retrieves relevant documents and generates answer.
+        
+        Args:
+            state: Current agent state
+            
+        Returns:
+            Updated state with RAG context and answer
+        """
+        print("[RAG Node] Performing semantic search...")
+        
+        try:
+            # Check if policy IDs are provided
+            policy_ids = state.get("policy_ids")
+            
+            if policy_ids:
+                # Search within selected policies
+                print(f"[RAG Node] Searching within {len(policy_ids)} selected policies")
+                print(f"[RAG Node] Policy IDs: {policy_ids}")
+                
+                context_chunks = rag_service.search_policies(
+                    query=state["query"],
+                    policy_ids=policy_ids,
+                    top_k=10  # Increased for better coverage
+                )
+                
+                print(f"[RAG Node] Found {len(context_chunks)} chunks from policies")
+            else:
+                # Regular document search
+                print(f"[RAG Node] Searching user documents for user_id: {state.get('user_id')}")
+                context_chunks = rag_service.semantic_search(
+                    query=state["query"],
+                    user_id=state.get("user_id"),
+                    top_k=10  # Increased for better coverage
+                )
+                print(f"[RAG Node] Found {len(context_chunks)} chunks from user docs")
+            
+            if not context_chunks:
+                print("[RAG Node] No relevant documents found")
+                no_doc_message = (
+                    "I don't have any content in the selected policies to answer this question."
+                    if policy_ids
+                    else "I don't have any uploaded documents to answer this question. Please upload construction documents or ask a general question."
+                )
+                return {
+                    **state,
+                    "answer": no_doc_message,
+                    "sources": [],
+                    "context_chunks": [],
+                    "metadata": {
+                        "agent": "rag",
+                        "note": "No documents available",
+                        "policy_mode": bool(policy_ids)
+                    }
+                }
+            
+            # Generate answer using RAG agent
+            response = rag_agent.answer(state["query"], context_chunks)
+            
+            # Determine agent label: "policy" if searching official policies, "rag" if user docs
+            agent_label = "policy" if policy_ids else "rag"
+            
+            return {
+                **state,
+                "answer": response.get("answer", ""),
+                "sources": response.get("sources", []),
+                "context_chunks": context_chunks,
+                "metadata": {
+                    "agent": agent_label,  # "policy" or "rag"
+                    "chunks_retrieved": len(context_chunks),
+                    "routing_reasoning": state.get("routing_reasoning", ""),
+                    "policy_mode": bool(policy_ids),
+                    "policy_count": len(policy_ids) if policy_ids else 0
+                }
+            }
+            
+        except Exception as e:
+            print(f"[RAG Node] Error: {e}")
+            return {
+                **state,
+                "answer": "I encountered an error while processing your document query. Please try again.",
+                "sources": [],
+                "error": str(e)
+            }
+    
+    def _policy_node(self, state: AgentState) -> AgentState:
+        """
+        Policy agent node: Handles regulatory and compliance queries using official policy documents.
+        
+        Args:
+            state: Current agent state
+            
+        Returns:
+            Updated state with policy answer
+        """
+        print("[Policy Node] Processing policy query...")
+        
+        try:
+            # Check if policies are selected
+            policy_ids = state.get("policy_ids", [])
+            
+            if not policy_ids:
+                print("[Policy Node] No policies selected, redirecting to RAG agent")
+                return {
+                    **state,
+                    "answer": "Please select at least one policy document from the sidebar to get policy-specific answers.",
+                    "sources": [],
+                    "metadata": {
+                        "agent": "policy",
+                        "note": "No policies selected",
+                        "routing_reasoning": state.get("routing_reasoning", "")
+                    }
+                }
+            
+            # Search selected official policies for relevant information
+            policy_filter = {
+                "$and": [
+                    {"user_id": {"$eq": "official_policies"}},
+                    {"document_id": {"$in": policy_ids}}
+                ]
+            }
+            
+            context_chunks = rag_service.collection.query(
+                query_embeddings=[embedding_generator.generate_embedding(state["query"])],
+                n_results=10,
+                where=policy_filter
+            )
+            
+            # Format chunks
+            if context_chunks and context_chunks['documents']:
+                formatted_chunks = [
+                    {
+                        "content": context_chunks['documents'][0][i],
+                        "metadata": context_chunks['metadatas'][0][i]
+                    }
+                    for i in range(len(context_chunks['documents'][0]))
+                ]
+            else:
+                formatted_chunks = []
+            
+            if not formatted_chunks:
+                return {
+                    **state,
+                    "answer": "I couldn't find relevant information in the selected policy documents. Please try rephrasing your question or selecting different policies.",
+                    "sources": [],
+                    "metadata": {
+                        "agent": "policy",
+                        "note": "No relevant content found in selected policies"
+                    }
+                }
+            
+            # Use policy agent with context
+            response = policy_agent.answer(state["query"], formatted_chunks)
+            
+            print(f"[Policy Node] Response policy_names: {response.get('policy_names', [])}")
+            
+            return {
+                **state,
+                "answer": response.get("answer", ""),
+                "sources": response.get("sources", []),
+                "policy_names": response.get("policy_names", []),  # Pass policy names through
+                "metadata": {
+                    "agent": "policy",
+                    "routing_reasoning": state.get("routing_reasoning", ""),
+                    "chunks_retrieved": len(formatted_chunks),
+                    "policy_names": response.get("policy_names", [])  # Include in metadata too
+                }
+            }
+            
+        except Exception as e:
+            print(f"[Policy Node] Error: {e}")
+            return {
+                **state,
+                "answer": "I encountered an error while processing your policy question. Please try again.",
+                "sources": [],
+                "error": str(e)
+            }
+    
+    def _general_node(self, state: AgentState) -> AgentState:
+        """
+        General agent node: Handles general construction questions and conversations.
+        
+        Args:
+            state: Current agent state
+            
+        Returns:
+            Updated state with general answer
+        """
+        print("[General Node] Processing general query...")
+        
+        try:
+            # Format chat history for the agent
+            chat_history = state.get("chat_history", [])
+            
+            response = general_agent.answer(
+                query=state["query"],
+                chat_history=chat_history
+            )
+            
+            return {
+                **state,
+                "answer": response.get("answer", ""),
+                "sources": [],
+                "metadata": {
+                    "agent": "general",
+                    "routing_reasoning": state.get("routing_reasoning", "")
+                }
+            }
+            
+        except Exception as e:
+            print(f"[General Node] Error: {e}")
+            return {
+                **state,
+                "answer": "I apologize, but I encountered an error. Please try again.",
+                "sources": [],
+                "error": str(e)
+            }
+    
+    def process_query(
+        self,
+        query: str,
+        user_id: Optional[str] = None,
+        chat_history: Optional[List[Dict]] = None,
+        policy_ids: Optional[List[str]] = None
+    ) -> Dict:
+        """
+        Process a user query through the multi-agent graph.
+        
+        Args:
+            query: User query string
+            user_id: Optional user ID
+            chat_history: Optional chat history
+            policy_ids: Optional list of policy document IDs to search
+            
+        Returns:
+            Dictionary with answer, agent, sources, and metadata
+        """
+        print(f"\n{'='*60}")
+        print(f"[Multi-Agent Graph] Processing query: {query[:50]}...")
+        if policy_ids:
+            print(f"[Multi-Agent Graph] With {len(policy_ids)} selected policies")
+        print(f"{'='*60}\n")
+        
+        try:
+            # Initialize state
+            initial_state: AgentState = {
+                "query": query,
+                "user_id": user_id,
+                "chat_history": chat_history or [],
+                "policy_ids": policy_ids,
+                "agent_type": None,
+                "routing_reasoning": None,
+                "context_chunks": None,
+                "search_results": None,
+                "answer": None,
+                "sources": None,
+                "policy_names": None,  # Initialize policy_names
+                "metadata": None,
+                "error": None
+            }
+            
+            # Execute the graph
+            final_state = self.graph.invoke(initial_state)
+            
+            # Debug: print what's in final_state
+            print(f"[Multi-Agent Graph] Final state keys: {final_state.keys()}")
+            print(f"[Multi-Agent Graph] Final state policy_names: {final_state.get('policy_names', 'KEY NOT FOUND')}")
+            
+            # Extract response
+            result = {
+                "answer": final_state.get("answer", "I couldn't generate a response."),
+                "agent": final_state.get("metadata", {}).get("agent", "unknown"),
+                "sources": final_state.get("sources", []),
+                "routing_reasoning": final_state.get("routing_reasoning", ""),
+                "metadata": final_state.get("metadata", {}),
+                "policy_names": final_state.get("policy_names", [])  # Add policy_names!
+            }
+            
+            print(f"[Multi-Agent Graph] Returning policy_names: {result.get('policy_names', [])}")
+            print(f"\n[Multi-Agent Graph] Completed - Agent: {result['agent']}\n")
+            
+            return result
+            
+        except Exception as e:
+            print(f"[Multi-Agent Graph] Error: {e}")
+            return {
+                "answer": "I apologize, but I encountered an error processing your request. Please try again.",
+                "agent": "error",
+                "sources": [],
+                "routing_reasoning": f"Error: {str(e)}",
+                "metadata": {"error": str(e)}
+            }
+
+
+# Global multi-agent graph instance
+multi_agent_graph = MultiAgentGraph()

app/llm/prompts/general.txt

@@ -0,0 +1,26 @@
+You are a General Construction Assistant, a friendly and knowledgeable AI helper for construction professionals.
+
+Your role is to:
+- Answer general construction questions using your knowledge base
+- Provide helpful, conversational responses
+- Explain construction concepts clearly
+- Assist with planning, problem-solving, and best practices
+- Be friendly and professional
+
+Guidelines:
+- Use clear, accessible language
+- Provide practical, actionable advice
+- Acknowledge when you're uncertain
+- Suggest when users might need specialized help (e.g., "For specific regulatory requirements, consult local building codes")
+- Be conversational but professional
+- Focus on construction industry topics
+
+You have broad knowledge of:
+- Construction methods and materials
+- Project management
+- Safety practices
+- Tools and equipment
+- Building techniques
+- Industry terminology
+
+Respond in a helpful, friendly manner while maintaining professional expertise.

app/llm/prompts/policy.txt

@@ -0,0 +1,78 @@
+You are a Policy Document Assistant. Your ONLY job is to extract and present information from the provided policy documents. You are NOT allowed to use any external knowledge.
+
+========================================
+CRITICAL RULES (YOU MUST FOLLOW THESE)
+========================================
+
+1. **USE ONLY THE PROVIDED CONTEXT**
+   - Answer ONLY using the exact text from the documents shown below
+   - Do NOT add information from NFPA, OSHA, IBC, or any other external codes
+   - Do NOT use your general knowledge about construction or building codes
+   - If the context doesn't contain the answer, say so explicitly
+
+2. **EXTRACT, DON'T INTERPRET**
+   - Quote directly from the document when possible
+   - Include clause numbers, section numbers, or reference codes if present
+   - Use the exact terminology from the document
+   - Do NOT paraphrase unless necessary for clarity
+
+3. **BE HONEST ABOUT LIMITATIONS**
+   - If the document doesn't contain the answer: "The provided document does not contain information about [topic]."
+   - If the context is unclear: "The retrieved sections do not clearly define [term]."
+   - Do NOT fill gaps with external knowledge or assumptions
+
+4. **STRUCTURE YOUR RESPONSE**
+   When answering, use this format:
+
+   **Answer:** [Direct answer from document]
+   
+   **Source:** [Clause/Section number if available]
+   
+   **Exact Quote:** "[Verbatim text from document]"
+   
+   **Additional Context:** [Any related information from the same document section]
+
+========================================
+EXAMPLES OF CORRECT BEHAVIOR
+========================================
+
+GOOD RESPONSE (Answer found):
+```
+**Answer:** A basement is defined as a storey of a building below the ground floor.
+
+**Source:** Clause 3.2 - Definitions
+
+**Exact Quote:** "Basement — A storey of a building below the ground floor."
+
+**Additional Context:** The definition is provided in the terminology section of the National Building Code of India.
+```
+
+GOOD RESPONSE (Answer not found):
+```
+I could not find a definition for "Basement" in the provided sections of the document. The retrieved content discusses fire safety requirements but does not include the definitions section where building terminology would typically be located.
+
+To find this information, please check the definitions or terminology section of the complete document.
+```
+
+BAD RESPONSE (NEVER DO THIS):
+```
+A basement is typically defined as any level below ground. According to OSHA standards...
+[This is BAD because it uses external knowledge instead of the document]
+```
+
+========================================
+HOW TO PROCESS THE QUERY
+========================================
+
+1. READ the provided document excerpts carefully
+2. SEARCH for the specific information requested
+3. CHECK if the answer is explicitly stated
+4. EXTRACT the relevant text with section numbers
+5. FORMAT your response according to the structure above
+6. VERIFY you didn't add any external information
+
+========================================
+DOCUMENT CONTEXT WILL BE PROVIDED BELOW
+========================================
+
+You will receive excerpts from the official policy document. Use ONLY this information to answer.

app/llm/prompts/rag.txt

@@ -0,0 +1,60 @@
+You are a RAG (Retrieval-Augmented Generation) Agent. You answer questions using ONLY the provided document excerpts.
+
+========================================
+STRICT RULES
+========================================
+
+1. **USE ONLY PROVIDED CONTEXT**
+   - Answer using ONLY the document chunks provided below
+   - Do NOT use external knowledge or general information
+   - Do NOT add details not present in the context
+
+2. **EXTRACT EXACT INFORMATION**
+   - Quote directly from the documents
+   - Include page numbers, sections, or clause numbers if available
+   - Preserve technical terminology exactly as written
+
+3. **BE HONEST ABOUT GAPS**
+   - If context doesn't answer the question: "The uploaded documents do not contain this information."
+   - If context is partial: "Based on the available sections, [partial answer]. However, complete information may be in other parts of the document."
+   - NEVER guess or fill gaps with external knowledge
+
+========================================
+RESPONSE FORMAT
+========================================
+
+**Answer:** [Direct answer from documents]
+
+**Source:** [Document name, section/page if available]
+
+**Quote:** "[Exact text from document]"
+
+**Note:** [Any limitations or clarifications]
+
+========================================
+EXAMPLES
+========================================
+
+GOOD (Answer found):
+```
+**Answer:** The minimum ceiling height for habitable rooms is 2.75 meters.
+
+**Source:** Construction Manual, Section 4.2 - Room Dimensions
+
+**Quote:** "All habitable rooms shall have a minimum ceiling height of 2.75m measured from finished floor to finished ceiling."
+```
+
+GOOD (Answer not found):
+```
+The uploaded documents do not contain information about fire escape requirements. The available sections cover structural specifications but not fire safety regulations.
+```
+
+BAD (NEVER do this):
+```
+Ceiling height is typically 2.4m to 3m according to standard practice...
+[This is BAD - uses external knowledge instead of document]
+```
+
+========================================
+
+Context from uploaded documents will be provided below. Use ONLY this information.

app/llm/prompts/router.txt

@@ -0,0 +1,32 @@
+You are a Router Agent responsible for analyzing user queries and routing them to the appropriate specialized agent.
+
+Your task is to determine the user's intent and route to one of these agents:
+1. **search** - For queries requiring latest information, news, or real-time data
+2. **rag** - For queries about uploaded documents or specific construction knowledge
+3. **policy** - For queries about construction policies, regulations, or compliance
+4. **general** - For general construction questions, conversational queries, or greetings
+
+Analyze the query and respond with JSON in this exact format:
+{
+  "agent": "search|rag|policy|general",
+  "reasoning": "Brief explanation of why this agent was chosen"
+}
+
+Examples:
+
+Query: "What are the latest construction industry trends?"
+Response: {"agent": "search", "reasoning": "Requires latest real-time information"}
+
+Query: "What does the uploaded safety manual say about scaffolding?"
+Response: {"agent": "rag", "reasoning": "Refers to uploaded document content"}
+
+Query: "What are OSHA requirements for fall protection?"
+Response: {"agent": "policy", "reasoning": "Asking about regulatory compliance"}
+
+Query: "Hello, how are you?"
+Response: {"agent": "general", "reasoning": "Conversational greeting"}
+
+Query: "What is concrete curing?"
+Response: {"agent": "general", "reasoning": "General construction knowledge question"}
+
+Now route this query:

app/llm/prompts/search.txt

@@ -0,0 +1,17 @@
+You are a Search Agent specialized in finding the latest construction industry information from the web.
+
+Your task is to analyze search results and provide accurate, well-cited answers to user queries.
+
+Guidelines:
+- Focus on recent, reliable information
+- Always cite your sources with URLs
+- Provide concise but comprehensive answers
+- If search results are insufficient, acknowledge limitations
+- Prioritize authoritative sources (industry publications, government sites, etc.)
+
+Format your response as follows:
+1. Direct answer to the query
+2. Supporting details from search results
+3. Citations in format: [Source Name](URL)
+
+Be professional, accurate, and helpful. Focus on construction-related information.

app/llm/state.py

@@ -0,0 +1,36 @@
+"""
+State definitions for the LangGraph multi-agent workflow.
+"""
+from typing import TypedDict, List, Dict, Optional, Annotated
+import operator
+
+
+class AgentState(TypedDict):
+    """State for the multi-agent RAG system."""
+    
+    # User input
+    query: str
+    user_id: Optional[str]
+    policy_ids: Optional[List[str]]  # NEW: Selected policy IDs
+    
+    # Chat history
+    chat_history: Annotated[List[Dict], operator.add]
+    
+    # Routing decision
+    agent_type: Optional[str]
+    routing_reasoning: Optional[str]
+    
+    # Retrieved context (for RAG)
+    context_chunks: Optional[List[Dict]]
+    
+    # Search results (for Search agent)
+    search_results: Optional[List[Dict]]
+    
+    # Final response
+    answer: Optional[str]
+    sources: Optional[List]
+    policy_names: Optional[List[str]]  # Policy document titles used in answer
+    
+    # Metadata
+    metadata: Optional[Dict]
+    error: Optional[str]

app/main.py

@@ -0,0 +1,81 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.exceptions import RequestValidationError
+from starlette.exceptions import HTTPException as StarletteHTTPException
+
+from app.config.settings import settings
+from app.database.connection import init_db
+from app.middleware.error_handler import (
+    http_exception_handler,
+    validation_exception_handler,
+    general_exception_handler
+)
+from app.routes import auth, chat, sessions, documents, news, admin_policies, reports
+from app.routes import settings as settings_router
+
+# Create FastAPI app
+app = FastAPI(
+    title="Builder's AI API",
+    description="Construction AI Assistant API with Multi-Agent RAG System",
+    version="1.0.0"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Exception handlers
+app.add_exception_handler(StarletteHTTPException, http_exception_handler)
+app.add_exception_handler(RequestValidationError, validation_exception_handler)
+app.add_exception_handler(Exception, general_exception_handler)
+
+# Include routers
+app.include_router(auth.router)
+app.include_router(chat.router)
+app.include_router(sessions.router)
+app.include_router(documents.router)
+app.include_router(news.router)
+app.include_router(admin_policies.router)
+app.include_router(reports.router)
+app.include_router(settings_router.router)
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize database on startup."""
+    print("Initializing database...")
+    init_db()
+    print("Database initialized successfully!")
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown."""
+    print("Shutting down...")
+
+
+@app.get("/")
+async def root():
+    """Root endpoint."""
+    return {
+        "message": "Welcome to Builder's AI API",
+        "version": "1.0.0",
+        "docs": "/docs"
+    }
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    return {"status": "healthy"}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    from app.config.settings import settings as app_settings
+    uvicorn.run(app, host="0.0.0.0", port=app_settings.PORT)

app/middleware/admin_auth.py

@@ -0,0 +1,28 @@
+"""
+Admin authentication middleware.
+"""
+from fastapi import Depends, HTTPException, status
+from app.middleware.auth import get_current_user
+from app.database.models import User
+
+
+def get_current_admin_user(current_user: User = Depends(get_current_user)) -> User:
+    """
+    Verify that the current user is an admin.
+    
+    Args:
+        current_user: Current authenticated user
+        
+    Returns:
+        User object if admin
+        
+    Raises:
+        HTTPException: If user is not an admin
+    """
+    if not current_user.is_admin:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Admin privileges required"
+        )
+    
+    return current_user

app/middleware/auth.py

@@ -0,0 +1,95 @@
+from typing import Optional
+from fastapi import Request, HTTPException, status, Depends
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from jose import JWTError, jwt
+
+from app.config.settings import settings
+from app.database.connection import get_db
+from app.database.models import User
+
+security = HTTPBearer()
+
+
+def get_current_user_optional(
+    credentials: Optional[HTTPAuthorizationCredentials] = Depends(HTTPBearer(auto_error=False))
+) -> Optional[User]:
+    """
+    Get current user from JWT token (optional - doesn't raise error if no token).
+    
+    Args:
+        credentials: Optional HTTP authorization credentials
+        
+    Returns:
+        User object if authenticated, None otherwise
+    """
+    if not credentials:
+        return None
+        
+    try:
+        token = credentials.credentials
+        payload = jwt.decode(
+            token,
+            settings.secret_key,
+            algorithms=[settings.algorithm]
+        )
+        user_id: str = payload.get("sub")
+        
+        if user_id is None:
+            return None
+            
+        # Get user from database
+        db = next(get_db())
+        user = db.query(User).filter(User.id == user_id).first()
+        return user
+        
+    except JWTError:
+        return None
+
+
+def get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(security)
+) -> User:
+    """
+    Get current user from JWT token (required - raises error if no valid token).
+    
+    Args:
+        credentials: HTTP authorization credentials
+        
+    Returns:
+        User object
+        
+    Raises:
+        HTTPException: If token is invalid or user not found
+    """
+    try:
+        token = credentials.credentials
+        payload = jwt.decode(
+            token,
+            settings.secret_key,
+            algorithms=[settings.algorithm]
+        )
+        user_id: str = payload.get("sub")
+        
+        if user_id is None:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Could not validate credentials"
+            )
+            
+        # Get user from database
+        db = next(get_db())
+        user = db.query(User).filter(User.id == user_id).first()
+        
+        if user is None:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="User not found"
+            )
+            
+        return user
+        
+    except JWTError:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Could not validate credentials"
+        )

app/middleware/error_handler.py

@@ -0,0 +1,29 @@
+from fastapi import Request, status
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import RequestValidationError
+from starlette.exceptions import HTTPException as StarletteHTTPException
+
+
+async def http_exception_handler(request: Request, exc: StarletteHTTPException):
+    """Handle HTTP exceptions."""
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={"detail": exc.detail}
+    )
+
+
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    """Handle validation exceptions."""
+    return JSONResponse(
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+        content={"detail": exc.errors(), "body": exc.body}
+    )
+
+
+async def general_exception_handler(request: Request, exc: Exception):
+    """Handle general exceptions."""
+    print(f"Unhandled exception: {exc}")
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={"detail": "Internal server error"}
+    )

app/routes/admin_policies.py

@@ -0,0 +1,188 @@
+"""
+Admin routes for official policy management.
+"""
+from fastapi import APIRouter, Depends, HTTPException, status, UploadFile, File, Form
+from sqlalchemy.orm import Session
+from typing import Optional
+
+from app.database.connection import get_db
+from app.database.models import User
+from app.schemas.policy import PolicyUploadResponse, PolicyListResponse, PolicyUpdateRequest
+from app.services.policy_service import PolicyService
+from app.middleware.admin_auth import get_current_admin_user
+
+router = APIRouter(prefix="/api/admin/policies", tags=["admin-policies"])
+
+
+@router.post("/upload", response_model=PolicyUploadResponse, status_code=status.HTTP_201_CREATED)
+async def upload_policy(
+    file: UploadFile = File(...),
+    title: str = Form(...),
+    description: Optional[str] = Form(None),
+    category: Optional[str] = Form(None),
+    db: Session = Depends(get_db),
+    admin_user: User = Depends(get_current_admin_user)
+):
+    """
+    Upload an official policy document (Admin only).
+    
+    Args:
+        file: Uploaded file
+        title: Policy title
+        description: Optional description
+        category: Optional category (e.g., "OSHA", "Safety")
+        db: Database session
+        admin_user: Current admin user
+        
+    Returns:
+        Created policy metadata
+    """
+    try:
+        # Upload policy
+        policy = PolicyService.upload_policy(
+            db=db,
+            file=file.file,
+            title=title,
+            filename=file.filename,
+            admin_user_id=admin_user.id,
+            description=description,
+            category=category
+        )
+        
+        # Extract and process text content
+        from app.utils.document_extractor import document_extractor
+        
+        try:
+            content = document_extractor.extract_text(
+                file_path=policy.file_path,
+                file_type=policy.file_type
+            )
+            
+            num_chunks = PolicyService.process_policy_content(
+                db, 
+                policy.id, 
+                content
+            )
+            
+            print(f"[Admin] Policy '{policy.title}' processed: {num_chunks} chunks created")
+            
+        except Exception as e:
+            print(f"[Admin] Error processing policy content: {e}")
+        
+        return PolicyUploadResponse.from_orm(policy)
+        
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        print(f"Error uploading policy: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error uploading policy"
+        )
+
+
+@router.get("", response_model=PolicyListResponse)
+async def get_all_policies(
+    active_only: bool = False,
+    db: Session = Depends(get_db),
+    admin_user: User = Depends(get_current_admin_user)
+):
+    """
+    Get all official policies (Admin only).
+    
+    Args:
+        active_only: Only return active policies
+        db: Database session
+        admin_user: Current admin user
+        
+    Returns:
+        List of policies
+    """
+    policies = PolicyService.get_all_policies(db, active_only=active_only)
+    
+    return PolicyListResponse(
+        policies=[PolicyUploadResponse.from_orm(p) for p in policies],
+        total=len(policies)
+    )
+
+
+@router.get("/public", response_model=PolicyListResponse)
+async def get_public_policies(db: Session = Depends(get_db)):
+    """
+    Get all active official policies (Public - no auth required).
+    
+    Args:
+        db: Database session
+        
+    Returns:
+        List of active policies
+    """
+    policies = PolicyService.get_all_policies(db, active_only=True)
+    
+    return PolicyListResponse(
+        policies=[PolicyUploadResponse.from_orm(p) for p in policies],
+        total=len(policies)
+    )
+
+
+@router.patch("/{policy_id}", response_model=PolicyUploadResponse)
+async def update_policy(
+    policy_id: str,
+    request: PolicyUpdateRequest,
+    db: Session = Depends(get_db),
+    admin_user: User = Depends(get_current_admin_user)
+):
+    """
+    Update policy metadata (Admin only).
+    
+    Args:
+        policy_id: Policy ID
+        request: Update request
+        db: Database session
+        admin_user: Current admin user
+        
+    Returns:
+        Updated policy
+    """
+    policy = PolicyService.update_policy(
+        db=db,
+        policy_id=policy_id,
+        title=request.title,
+        description=request.description,
+        category=request.category,
+        is_active=request.is_active
+    )
+    
+    if not policy:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Policy not found"
+        )
+    
+    return PolicyUploadResponse.from_orm(policy)
+
+
+@router.delete("/{policy_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_policy(
+    policy_id: str,
+    db: Session = Depends(get_db),
+    admin_user: User = Depends(get_current_admin_user)
+):
+    """
+    Delete a policy (Admin only).
+    
+    Args:
+        policy_id: Policy ID
+        db: Database session
+        admin_user: Current admin user
+    """
+    success = PolicyService.delete_policy(db, policy_id)
+    
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Policy not found"
+        )

app/routes/auth.py

@@ -0,0 +1,216 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from app.database.connection import get_db
+from app.schemas.auth import UserCreate, UserLogin, UserResponse, TokenResponse
+from app.services.auth_service import AuthService
+from app.middleware.auth import get_current_user
+from app.database.models import User
+from app.utils.validators import validate_email, validate_password
+
+router = APIRouter(prefix="/api", tags=["auth"])
+
+
+@router.post("/signup", response_model=TokenResponse, status_code=status.HTTP_201_CREATED)
+async def signup(user_data: UserCreate, db: Session = Depends(get_db)):
+    """
+    Create a new user account.
+    
+    Args:
+        user_data: User registration data
+        db: Database session
+        
+    Returns:
+        Access and refresh tokens with user info
+        
+    Raises:
+        HTTPException: If email is invalid or already registered
+    """
+    print(f"[SIGNUP] Received signup request for email: {user_data.email}")
+    
+    # Validate email
+    if not validate_email(user_data.email):
+        print(f"[SIGNUP] Invalid email format: {user_data.email}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid email format"
+        )
+    
+    # Validate password
+    is_valid, error_msg = validate_password(user_data.password)
+    if not is_valid:
+        print(f"[SIGNUP] Password validation failed: {error_msg}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=error_msg
+        )
+    
+    try:
+        # Create user
+        print(f"[SIGNUP] Creating user...")
+        user = AuthService.create_user(
+            db=db,
+            email=user_data.email,
+            password=user_data.password,
+            name=user_data.name
+        )
+        
+        print(f"[SIGNUP] User created successfully: {user.id}")
+        
+        # Generate tokens
+        tokens = AuthService.generate_tokens(user)
+        
+        print(f"[SIGNUP] Tokens generated successfully")
+        
+        return TokenResponse(
+            access_token=tokens["access_token"],
+            refresh_token=tokens["refresh_token"],
+            user=UserResponse.from_orm(user)
+        )
+        
+    except ValueError as e:
+        print(f"[SIGNUP] ValueError: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        print(f"[SIGNUP] Unexpected error: {type(e).__name__}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="An error occurred during signup"
+        )
+
+
+@router.post("/login", response_model=TokenResponse)
+async def login(credentials: UserLogin, db: Session = Depends(get_db)):
+    """
+    Authenticate user and return tokens.
+    
+    Args:
+        credentials: User login credentials
+        db: Database session
+        
+    Returns:
+        Access and refresh tokens with user info
+        
+    Raises:
+        HTTPException: If credentials are invalid
+    """
+    # Authenticate user
+    user = AuthService.authenticate_user(
+        db=db,
+        email=credentials.email,
+        password=credentials.password
+    )
+    
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password"
+        )
+    
+    # Generate tokens
+    tokens = AuthService.generate_tokens(user)
+    
+    return TokenResponse(
+        access_token=tokens["access_token"],
+        refresh_token=tokens["refresh_token"],
+        user=UserResponse.from_orm(user)
+    )
+
+
+@router.get("/check-auth", response_model=UserResponse)
+async def check_auth(current_user: User = Depends(get_current_user)):
+    """
+    Verify authentication token and return user info.
+    
+    Args:
+        current_user: Current authenticated user
+        
+    Returns:
+        User information
+        
+    Raises:
+        HTTPException: If token is invalid or expired
+    """
+    return UserResponse.from_orm(current_user)
+
+
+@router.post("/auth/google", response_model=TokenResponse)
+async def google_auth(
+    request: dict,
+    db: Session = Depends(get_db)
+):
+    """
+    Authenticate user with Google OAuth and return JWT tokens.
+    
+    Args:
+        request: Dictionary with 'credential' field (Google JWT token)
+        db: Database session
+        
+    Returns:
+        Access and refresh JWT tokens with user info
+        
+    Raises:
+        HTTPException: If Google token is invalid
+    """
+    from app.config.settings import settings
+    
+    print(f"[GOOGLE AUTH] Received Google OAuth request")
+    
+    try:
+        credential = request.get("credential")
+        if not credential:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Google credential is required"
+            )
+        
+        print(f"[GOOGLE AUTH] Verifying Google token...")
+        
+        # Verify Google token and get user info
+        google_data = await AuthService.verify_google_token(
+            credential=credential,
+            client_id=settings.GOOGLE_CLIENT_ID
+        )
+        
+        print(f"[GOOGLE AUTH] Token verified for email: {google_data['email']}")
+        
+        # Create or get user
+        user = AuthService.create_user_from_google(
+            db=db,
+            google_id=google_data["google_id"],
+            email=google_data["email"],
+            name=google_data.get("name")
+        )
+        
+        print(f"[GOOGLE AUTH] User created/retrieved: {user.id}")
+        
+        # Generate JWT tokens (same as email/password login)
+        tokens = AuthService.generate_tokens(user)
+        
+        print(f"[GOOGLE AUTH] JWT tokens generated successfully")
+        
+        return TokenResponse(
+            access_token=tokens["access_token"],
+            refresh_token=tokens["refresh_token"],
+            user=UserResponse.from_orm(user)
+        )
+        
+    except ValueError as e:
+        print(f"[GOOGLE AUTH] ValueError: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        print(f"[GOOGLE AUTH] Unexpected error: {type(e).__name__}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to authenticate with Google"
+        )

app/routes/chat.py

@@ -0,0 +1,101 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import Optional
+
+from app.database.connection import get_db
+from app.database.models import User
+from app.schemas.chat import ChatRequest, ChatResponse, MessageResponse
+from app.services.chat_service import ChatService
+from app.middleware.auth import get_current_user_optional
+
+router = APIRouter(prefix="/api/chat", tags=["chat"])
+
+
+@router.post("", response_model=ChatResponse)
+async def send_message(
+    request: ChatRequest,
+    db: Session = Depends(get_db),
+    current_user: Optional[User] = Depends(get_current_user_optional)
+):
+    """
+    Send a chat message and get response.
+    
+    Args:
+        request: Chat request with message and optional session_id
+        db: Database session
+        current_user: Optional current user (None for guests)
+        
+    Returns:
+        Chat response with message and metadata
+        
+    Raises:
+        HTTPException: If processing fails
+    """
+    user_id = current_user.id if current_user else None
+    
+    try:
+        result = ChatService.process_message(
+            db=db,
+            message=request.message,
+            session_id=request.session_id,
+            user_id=user_id,
+            policy_ids=request.policy_ids
+        )
+        
+        # Parse metadata
+        import json
+        meta = json.loads(result["message"].meta) if result["message"].meta else {}
+        
+        return ChatResponse(
+            message=MessageResponse(
+                id=result["message"].id,
+                session_id=result["message"].session_id,
+                role=result["message"].role,
+                content=result["message"].content,
+                meta=meta,
+                created_at=result["message"].created_at
+            ),
+            session_id=result["session_id"],
+            agent=result.get("agent")
+        )
+        
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        print(f"Error processing message: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error processing message"
+        )
+
+
+@router.get("/history/{session_id}")
+async def get_chat_history(
+    session_id: str,
+    db: Session = Depends(get_db),
+    current_user: Optional[User] = Depends(get_current_user_optional)
+):
+    """
+    Get chat history for a session.
+    
+    Args:
+        session_id: Session ID
+        db: Database session
+        current_user: Optional current user
+        
+    Returns:
+        List of messages
+    """
+    try:
+        messages = ChatService.get_chat_history(db, session_id)
+        return {"messages": messages}
+        
+    except Exception as e:
+        print(f"Error getting chat history: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error retrieving chat history"
+        )

app/routes/documents.py

@@ -0,0 +1,128 @@
+from fastapi import APIRouter, Depends, HTTPException, status, UploadFile, File
+from sqlalchemy.orm import Session
+from typing import List
+
+from app.database.connection import get_db
+from app.database.models import User
+from app.schemas.document import DocumentResponse, DocumentListResponse
+from app.services.document_service import DocumentService
+from app.middleware.auth import get_current_user
+
+router = APIRouter(prefix="/api/documents", tags=["documents"])
+
+
+@router.post("/upload", response_model=DocumentResponse, status_code=status.HTTP_201_CREATED)
+async def upload_document(
+    file: UploadFile = File(...),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Upload a document for processing.
+    
+    Args:
+        file: Uploaded file
+        db: Database session
+        current_user: Current authenticated user
+        
+    Returns:
+        Created document metadata
+        
+    Raises:
+        HTTPException: If file validation fails
+    """
+    try:
+        # Upload document
+        document = DocumentService.upload_document(
+            db=db,
+            file=file.file,
+            user_id=current_user.id,
+            filename=file.filename
+        )
+        
+        # Extract and process text content
+        from app.utils.document_extractor import document_extractor
+        
+        try:
+            # Extract text from the uploaded file
+            content = document_extractor.extract_text(
+                file_path=document.file_path,
+                file_type=document.file_type
+            )
+            
+            # Process with RAG service
+            num_chunks = DocumentService.process_document_content(
+                db, 
+                document.id, 
+                content
+            )
+            
+            print(f"Document {document.filename} processed: {num_chunks} chunks created")
+            
+        except Exception as e:
+            print(f"Error processing document content: {e}")
+            # Document is uploaded but not processed for RAG
+            # You might want to mark this in the database
+        
+        return DocumentResponse.from_orm(document)
+        
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        print(f"Error uploading document: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error uploading document"
+        )
+
+
+@router.get("", response_model=DocumentListResponse)
+async def get_user_documents(
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Get all documents for the current user.
+    
+    Args:
+        db: Database session
+        current_user: Current authenticated user
+        
+    Returns:
+        List of user documents
+    """
+    documents = DocumentService.get_user_documents(db, current_user.id)
+    
+    return DocumentListResponse(
+        documents=[DocumentResponse.from_orm(doc) for doc in documents],
+        total=len(documents)
+    )
+
+
+@router.delete("/{document_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_document(
+    document_id: str,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Delete a document and its vector embeddings.
+    
+    Args:
+        document_id: Document ID
+        db: Database session
+        current_user: Current authenticated user
+        
+    Raises:
+        HTTPException: If document not found
+    """
+    success = DocumentService.delete_document(db, document_id)
+    
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Document not found"
+        )

app/routes/news.py

@@ -0,0 +1,156 @@
+from fastapi import APIRouter, Depends, HTTPException, status, Query
+from sqlalchemy.orm import Session
+from typing import Optional
+import httpx
+from datetime import datetime
+
+from app.database.connection import get_db
+from app.middleware.auth import get_current_user_optional
+from app.database.models import User
+
+router = APIRouter(prefix="/api/news", tags=["news"])
+
+
+@router.get("/search")
+async def search_news(
+    query: str = Query(..., description="Search query for news articles"),
+    location: str = Query("India", description="Location to filter news"),
+    limit: int = Query(10, ge=1, le=50, description="Number of articles to return"),
+    current_user: Optional[User] = Depends(get_current_user_optional),
+    db: Session = Depends(get_db)
+):
+    """
+    Search for construction-related news articles with sentiment analysis.
+    
+    Args:
+        query: Search query (e.g., 'construction law', 'building permits')
+        location: Geographic location to filter news
+        limit: Maximum number of articles to return (1-50)
+        current_user: Optional authenticated user
+        db: Database session
+        
+    Returns:
+        List of news articles with sentiment analysis
+    """
+    
+    try:
+        from app.services.news_service import fetch_google_news
+        
+        print(f"[NEWS] Fetching news for query='{query}', location='{location}'")
+        
+        try:
+            # Try to fetch real news from Google
+            articles = fetch_google_news(query, location)
+            
+            if not articles:
+                print("[NEWS] No articles returned from Google, using fallback")
+                raise ValueError("No articles found")
+                
+        except Exception as scrape_error:
+            print(f"[NEWS] Scraping failed: {str(scrape_error)}, using fallback data")
+            # Fallback to mock data if scraping fails
+            articles = [
+                {
+                    "title": f"Construction Industry Update - {location}",
+                    "snippet": f"Latest developments in {query} sector show positive trends with new regulations and infrastructure projects.",
+                    "sentiment": "Positive",
+                    "published_date": datetime.now().isoformat(),
+                    "link": "https://example.com/fallback1",
+                    "source": "Construction News"
+                },
+                {
+                    "title": f"{query.title()} Regulations Updated",
+                    "snippet": "New guidelines introduced to streamline processes and improve safety standards in the construction industry.",
+                    "sentiment": "Neutral",
+                    "published_date": datetime.now().isoformat(),
+                    "link": "https://example.com/fallback2",
+                    "source": "Industry Watch"
+                }
+            ]
+        
+        # Limit results
+        articles = articles[:limit]
+        
+        print(f"[NEWS] Returning {len(articles)} articles")
+        
+        return {
+            "articles": articles,
+            "count": len(articles),
+            "query": query,
+            "location": location,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        print(f"[NEWS] Error: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to fetch news: {str(e)}"
+        )
+
+
+@router.get("/trending")
+async def get_trending_topics(
+    location: str = Query("India", description="Location for trending topics"),
+    current_user: Optional[User] = Depends(get_current_user_optional)
+):
+    """
+    Get trending construction-related topics.
+    
+    Args:
+        location: Geographic location
+        current_user: Optional authenticated user
+        
+    Returns:
+        List of trending topics with article counts
+    """
+    
+    # Mock trending topics
+    trending = [
+        {"topic": "Green Building", "count": 45, "sentiment": "Positive"},
+        {"topic": "Smart Cities", "count": 38, "sentiment": "Positive"},
+        {"topic": "Labor Shortage", "count": 32, "sentiment": "Negative"},
+        {"topic": "Building Permits", "count": 28, "sentiment": "Neutral"},
+        {"topic": "Infrastructure Investment", "count": 25, "sentiment": "Positive"},
+    ]
+    
+    return {
+        "trending": trending,
+        "location": location,
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+@router.get("/sentiment-summary")
+async def get_sentiment_summary(
+    query: str = Query(..., description="Search query"),
+    location: str = Query("India", description="Location"),
+    current_user: Optional[User] = Depends(get_current_user_optional)
+):
+    """
+    Get sentiment summary for a query.
+    
+    Args:
+        query: Search query
+        location: Geographic location
+        current_user: Optional authenticated user
+        
+    Returns:
+        Sentiment distribution and statistics
+    """
+    
+    # Mock sentiment data
+    return {
+        "query": query,
+        "location": location,
+        "sentiment_distribution": {
+            "positive": 45,
+            "neutral": 30,
+            "negative": 25
+        },
+        "total_articles": 100,
+        "average_sentiment_score": 0.65,
+        "timestamp": datetime.now().isoformat()
+    }

app/routes/reports.py

@@ -0,0 +1,58 @@
+"""
+API routes for report generation.
+"""
+from fastapi import APIRouter, HTTPException, Depends
+from sqlalchemy.orm import Session
+from typing import Optional, Dict
+from pydantic import BaseModel
+
+from app.database.connection import get_db
+from app.database.models import User
+from app.middleware.auth import get_current_user_optional
+from app.services.report_service import report_generation_service
+
+
+router = APIRouter(prefix="/api/reports", tags=["reports"])
+
+
+class GenerateContentRequest(BaseModel):
+    """Request schema for AI content generation."""
+    section_name: str
+    context: Dict[str, str] = {}
+
+
+@router.post("/generate-content")
+async def generate_section_content(
+    request: GenerateContentRequest,
+    db: Session = Depends(get_db),
+    current_user: Optional[User] = Depends(get_current_user_optional)
+):
+    """
+    Generate AI content for a report section.
+    
+    Args:
+        request: Generation request with section name and context
+        db: Database session
+        current_user: Optional current user
+        
+    Returns:
+        Generated content
+    """
+    try:
+        content = report_generation_service.generate_section_content(
+            section_name=request.section_name,
+            context=request.context
+        )
+        
+        return {
+            "success": True,
+            "content": content,
+            "section_name": request.section_name
+        }
+        
+    except Exception as e:
+        print(f"Error generating report content: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error generating content: {str(e)}"
+        )

app/routes/sessions.py

@@ -0,0 +1,140 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from app.database.connection import get_db
+from app.database.models import User
+from app.schemas.session import SessionCreate, SessionUpdate, SessionResponse, SessionListResponse
+from app.services.session_service import SessionService
+from app.middleware.auth import get_current_user
+
+router = APIRouter(prefix="/api/sessions", tags=["sessions"])
+
+
+@router.post("", response_model=SessionResponse, status_code=status.HTTP_201_CREATED)
+async def create_session(
+    session_data: SessionCreate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Create a new chat session.
+    
+    Args:
+        session_data: Session creation data
+        db: Database session
+        current_user: Current authenticated user
+        
+    Returns:
+        Created session
+    """
+    session = SessionService.create_session(
+        db=db,
+        user_id=current_user.id,
+        title=session_data.title or "New Conversation"
+    )
+    
+    return SessionResponse(
+        id=session.id,
+        user_id=session.user_id,
+        title=session.title,
+        summary=session.summary,
+        created_at=session.created_at,
+        updated_at=session.updated_at,
+        message_count=0
+    )
+
+
+@router.get("", response_model=SessionListResponse)
+async def get_user_sessions(
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Get all sessions for the current user.
+    
+    Args:
+        db: Database session
+        current_user: Current authenticated user
+        
+    Returns:
+        List of sessions with message counts
+    """
+    sessions = SessionService.get_user_sessions(db, current_user.id)
+    
+    return SessionListResponse(
+        sessions=[SessionResponse(**s) for s in sessions],
+        total=len(sessions)
+    )
+
+
+@router.put("/{session_id}/title", response_model=SessionResponse)
+async def update_session_title(
+    session_id: str,
+    session_data: SessionUpdate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Update session title.
+    
+    Args:
+        session_id: Session ID
+        session_data: Session update data
+        db: Database session
+        current_user: Current authenticated user
+        
+    Returns:
+        Updated session
+        
+    Raises:
+        HTTPException: If session not found
+    """
+    if not session_data.title:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Title is required"
+        )
+    
+    session = SessionService.update_session_title(db, session_id, session_data.title)
+    
+    if not session:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Session not found"
+        )
+    
+    return SessionResponse(
+        id=session.id,
+        user_id=session.user_id,
+        title=session.title,
+        summary=session.summary,
+        created_at=session.created_at,
+        updated_at=session.updated_at,
+        message_count=0
+    )
+
+
+@router.delete("/{session_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_session(
+    session_id: str,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Delete a session and all its messages.
+    
+    Args:
+        session_id: Session ID
+        db: Database session
+        current_user: Current authenticated user
+        
+    Raises:
+        HTTPException: If session not found
+    """
+    success = SessionService.delete_session(db, session_id)
+    
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Session not found"
+        )

app/routes/settings.py

@@ -0,0 +1,179 @@
+"""
+API routes for user settings.
+"""
+from fastapi import APIRouter, HTTPException, Depends
+from sqlalchemy.orm import Session
+from pydantic import BaseModel
+from typing import Optional
+
+from app.database.connection import get_db
+from app.database.models import User
+from app.middleware.auth import get_current_user
+from app.services.settings_service import settings_service
+
+
+router = APIRouter(prefix="/api/settings", tags=["settings"])
+
+
+class ProfileUpdateRequest(BaseModel):
+    """Request schema for profile updates."""
+    bio: Optional[str] = None
+    phone: Optional[str] = None
+    company: Optional[str] = None
+
+
+class AppearanceUpdateRequest(BaseModel):
+    """Request schema for appearance updates."""
+    theme: str  # light, dark, system
+
+
+class NotificationUpdateRequest(BaseModel):
+    """Request schema for notification updates."""
+    email_notifications: Optional[bool] = None
+    update_notifications: Optional[bool] = None
+
+
+@router.get("")
+async def get_settings(
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Get current user settings.
+    
+    Returns:
+        User settings including profile, appearance, and notifications
+    """
+    try:
+        settings = settings_service.get_or_create_settings(db, current_user.id)
+        
+        return {
+            "profile": {
+                "name": current_user.name,
+                "email": current_user.email,
+                "bio": settings.bio,
+                "phone": settings.phone,
+                "company": settings.company
+            },
+            "appearance": {
+                "theme": settings.theme
+            },
+            "notifications": {
+                "email_notifications": bool(settings.email_notifications),
+                "update_notifications": bool(settings.update_notifications)
+            }
+        }
+        
+    except Exception as e:
+        print(f"Error getting settings: {e}")
+        raise HTTPException(status_code=500, detail="Error retrieving settings")
+
+
+@router.patch("/profile")
+async def update_profile(
+    request: ProfileUpdateRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Update user profile settings.
+    
+    Args:
+        request: Profile update data
+        
+    Returns:
+        Updated profile settings
+    """
+    try:
+        settings = settings_service.update_profile(
+            db,
+            current_user.id,
+            bio=request.bio,
+            phone=request.phone,
+            company=request.company
+        )
+        
+        return {
+            "success": True,
+            "profile": {
+                "bio": settings.bio,
+                "phone": settings.phone,
+                "company": settings.company
+            }
+        }
+        
+    except Exception as e:
+        print(f"Error updating profile: {e}")
+        raise HTTPException(status_code=500, detail="Error updating profile")
+
+
+@router.patch("/appearance")
+async def update_appearance(
+    request: AppearanceUpdateRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Update appearance settings.
+    
+    Args:
+        request: Appearance update data
+        
+    Returns:
+        Updated appearance settings
+    """
+    try:
+        settings = settings_service.update_appearance(
+            db,
+            current_user.id,
+            theme=request.theme
+        )
+        
+        return {
+            "success": True,
+            "appearance": {
+                "theme": settings.theme
+            }
+        }
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        print(f"Error updating appearance: {e}")
+        raise HTTPException(status_code=500, detail="Error updating appearance")
+
+
+@router.patch("/notifications")
+async def update_notifications(
+    request: NotificationUpdateRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Update notification settings.
+    
+    Args:
+        request: Notification update data
+        
+    Returns:
+        Updated notification settings
+    """
+    try:
+        settings = settings_service.update_notifications(
+            db,
+            current_user.id,
+            email_notifications=request.email_notifications,
+            update_notifications=request.update_notifications
+        )
+        
+        return {
+            "success": True,
+            "notifications": {
+                "email_notifications": bool(settings.email_notifications),
+                "update_notifications": bool(settings.update_notifications)
+            }
+        }
+        
+    except Exception as e:
+        print(f"Error updating notifications: {e}")
+        raise HTTPException(status_code=500, detail="Error updating notifications")

app/schemas/auth.py

@@ -0,0 +1,41 @@
+from pydantic import BaseModel, EmailStr
+from typing import Optional
+from datetime import datetime
+
+
+class UserCreate(BaseModel):
+    """Schema for user registration."""
+    email: EmailStr
+    password: str
+    name: Optional[str] = None
+
+
+class UserLogin(BaseModel):
+    """Schema for user login."""
+    email: EmailStr
+    password: str
+
+
+class GoogleAuthRequest(BaseModel):
+    """Schema for Google OAuth."""
+    code: str
+
+
+class UserResponse(BaseModel):
+    """Schema for user response."""
+    id: str
+    email: str
+    name: Optional[str]
+    is_admin: bool = False
+    created_at: datetime
+    
+    class Config:
+        from_attributes = True
+
+
+class TokenResponse(BaseModel):
+    """Schema for authentication token response."""
+    access_token: str
+    refresh_token: str
+    token_type: str = "bearer"
+    user: UserResponse

app/schemas/chat.py

@@ -0,0 +1,36 @@
+from pydantic import BaseModel
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+
+
+class MessageCreate(BaseModel):
+    """Schema for creating a message."""
+    content: str
+    session_id: Optional[str] = None
+
+
+class MessageResponse(BaseModel):
+    """Schema for message response."""
+    id: str
+    session_id: str
+    role: str
+    content: str
+    meta: Optional[Dict[str, Any]] = None
+    created_at: datetime
+    
+    class Config:
+        from_attributes = True
+
+
+class ChatRequest(BaseModel):
+    """Schema for chat request."""
+    message: str
+    session_id: Optional[str] = None
+    policy_ids: Optional[List[str]] = None
+
+
+class ChatResponse(BaseModel):
+    """Schema for chat response."""
+    message: MessageResponse
+    session_id: str
+    agent: Optional[str] = None

app/schemas/document.py

@@ -0,0 +1,27 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+
+
+class DocumentUpload(BaseModel):
+    """Schema for document upload."""
+    filename: str
+
+
+class DocumentResponse(BaseModel):
+    """Schema for document response."""
+    id: str
+    user_id: str
+    filename: str
+    file_type: Optional[str]
+    file_size: Optional[int]
+    created_at: datetime
+    
+    class Config:
+        from_attributes = True
+
+
+class DocumentListResponse(BaseModel):
+    """Schema for document list response."""
+    documents: list[DocumentResponse]
+    total: int

app/schemas/policy.py

@@ -0,0 +1,51 @@
+"""
+Schemas for official policy management.
+"""
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+
+
+class PolicyUploadResponse(BaseModel):
+    """Response for policy upload."""
+    id: str
+    title: str
+    description: Optional[str]
+    filename: str
+    file_type: Optional[str]
+    file_size: Optional[int]
+    category: Optional[str]
+    is_active: bool
+    created_at: datetime
+    
+    class Config:
+        from_attributes = True
+        
+    @classmethod
+    def from_orm(cls, obj):
+        """Convert ORM object to Pydantic model."""
+        return cls(
+            id=obj.id,
+            title=obj.title,
+            description=obj.description,
+            filename=obj.filename,
+            file_type=obj.file_type,
+            file_size=obj.file_size,
+            category=obj.category,
+            is_active=bool(obj.is_active),
+            created_at=obj.created_at
+        )
+
+
+class PolicyListResponse(BaseModel):
+    """Response for policy list."""
+    policies: list[PolicyUploadResponse]
+    total: int
+
+
+class PolicyUpdateRequest(BaseModel):
+    """Request to update policy metadata."""
+    title: Optional[str] = None
+    description: Optional[str] = None
+    category: Optional[str] = None
+    is_active: Optional[bool] = None

app/schemas/session.py

@@ -0,0 +1,33 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+
+
+class SessionCreate(BaseModel):
+    """Schema for creating a session."""
+    title: Optional[str] = "New Conversation"
+
+
+class SessionUpdate(BaseModel):
+    """Schema for updating a session."""
+    title: Optional[str] = None
+
+
+class SessionResponse(BaseModel):
+    """Schema for session response."""
+    id: str
+    user_id: Optional[str]
+    title: str
+    summary: Optional[str]
+    created_at: datetime
+    updated_at: datetime
+    message_count: Optional[int] = 0
+    
+    class Config:
+        from_attributes = True
+
+
+class SessionListResponse(BaseModel):
+    """Schema for session list response."""
+    sessions: list[SessionResponse]
+    total: int

app/services/auth_service.py

@@ -0,0 +1,196 @@
+from sqlalchemy.orm import Session
+from typing import Optional
+import httpx
+
+from app.database.models import User
+from app.utils.password import hash_password, verify_password
+from app.utils.jwt import create_access_token, create_refresh_token
+from app.utils.helpers import generate_id
+
+
+class AuthService:
+    """Service for authentication operations."""
+    
+    @staticmethod
+    def create_user(db: Session, email: str, password: str, name: Optional[str] = None) -> User:
+        """
+        Create a new user with email and password.
+        
+        Args:
+            db: Database session
+            email: User email
+            password: Plain text password
+            name: Optional user name
+            
+        Returns:
+            Created User object
+            
+        Raises:
+            ValueError: If email already exists
+        """
+        # Check if user exists
+        existing_user = db.query(User).filter(User.email == email).first()
+        if existing_user:
+            raise ValueError("Email already registered")
+        
+        # Hash password
+        password_hash = hash_password(password)
+        
+        # Create user
+        user = User(
+            id=generate_id(),
+            email=email,
+            password_hash=password_hash,
+            name=name
+        )
+        
+        db.add(user)
+        db.commit()
+        db.refresh(user)
+        
+        return user
+    
+    @staticmethod
+    def authenticate_user(db: Session, email: str, password: str) -> Optional[User]:
+        """
+        Authenticate a user with email and password.
+        
+        Args:
+            db: Database session
+            email: User email
+            password: Plain text password
+            
+        Returns:
+            User object if authentication successful, None otherwise
+        """
+        user = db.query(User).filter(User.email == email).first()
+        
+        if not user or not user.password_hash:
+            return None
+        
+        if not verify_password(password, user.password_hash):
+            return None
+        
+        return user
+    
+    @staticmethod
+    async def verify_google_token(credential: str, client_id: str) -> dict:
+        """
+        Verify Google OAuth token and extract user info.
+        
+        Args:
+            credential: Google JWT token from frontend
+            client_id: Google OAuth client ID from settings
+            
+        Returns:
+            Dictionary with user info (email, name, google_id, picture)
+            
+        Raises:
+            ValueError: If token is invalid or verification fails
+        """
+        from google.oauth2 import id_token
+        from google.auth.transport import requests
+        
+        try:
+            # Verify the token with Google
+            idinfo = id_token.verify_oauth2_token(
+                credential, 
+                requests.Request(), 
+                client_id
+            )
+            
+            # Extract user information from the token
+            return {
+                "email": idinfo.get("email"),
+                "name": idinfo.get("name"),
+                "google_id": idinfo.get("sub"),  # 'sub' is the Google user ID
+                "picture": idinfo.get("picture")
+            }
+            
+        except Exception as e:
+            print(f"❌ Error verifying Google token: {e}")
+            raise ValueError(f"Invalid Google token: {str(e)}")
+    
+    @staticmethod
+    def create_user_from_google(
+        db: Session, 
+        google_id: str, 
+        email: str, 
+        name: Optional[str] = None
+    ) -> User:
+        """
+        Create or get user from Google OAuth.
+        
+        Args:
+            db: Database session
+            google_id: Google user ID
+            email: User email
+            name: Optional user name
+            
+        Returns:
+            User object
+        """
+        # Check if user exists with this Google ID
+        user = db.query(User).filter(User.google_id == google_id).first()
+        
+        if user:
+            return user
+        
+        # Check if user exists with this email
+        user = db.query(User).filter(User.email == email).first()
+        
+        if user:
+            # Link Google account
+            user.google_id = google_id
+            if name and not user.name:
+                user.name = name
+            db.commit()
+            db.refresh(user)
+            return user
+        
+        # Create new user
+        user = User(
+            id=generate_id(),
+            email=email,
+            google_id=google_id,
+            name=name
+        )
+        
+        db.add(user)
+        db.commit()
+        db.refresh(user)
+        
+        return user
+    
+    @staticmethod
+    def get_user_by_id(db: Session, user_id: str) -> Optional[User]:
+        """
+        Get user by ID.
+        
+        Args:
+            db: Database session
+            user_id: User ID
+            
+        Returns:
+            User object if found, None otherwise
+        """
+        return db.query(User).filter(User.id == user_id).first()
+    
+    @staticmethod
+    def generate_tokens(user: User) -> dict:
+        """
+        Generate access and refresh tokens for a user.
+        
+        Args:
+            user: User object
+            
+        Returns:
+            Dictionary with access_token and refresh_token
+        """
+        access_token = create_access_token(user.id)
+        refresh_token = create_refresh_token(user.id)
+        
+        return {
+            "access_token": access_token,
+            "refresh_token": refresh_token
+        }

app/services/chat_service.py

@@ -0,0 +1,212 @@
+from sqlalchemy.orm import Session
+from typing import List, Dict, Optional
+import json
+
+from app.database.models import Message, Session as ChatSession
+from app.services.session_service import SessionService
+from app.utils.helpers import generate_id
+
+
+class ChatService:
+    """Service for chat operations and agent orchestration."""
+    
+    @staticmethod
+    def process_message(
+        db: Session,
+        message: str,
+        session_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        policy_ids: Optional[List[str]] = None
+    ) -> Dict:
+        """
+        Process a user message and generate response using LangGraph workflow.
+        
+        Args:
+            db: Database session
+            message: User message content
+            session_id: Optional session ID
+            user_id: Optional user ID
+            policy_ids: Optional list of policy IDs to search within
+            
+        Returns:
+            Dictionary with response message and metadata
+        """
+        from app.llm.graph import multi_agent_graph
+        
+        # Create or get session
+        if not session_id:
+            chat_session = SessionService.create_session(db, user_id)
+            session_id = chat_session.id
+        else:
+            chat_session = SessionService.get_session_by_id(db, session_id)
+            if not chat_session:
+                raise ValueError("Session not found")
+        
+        # Save user message
+        user_message = Message(
+            id=generate_id(),
+            session_id=session_id,
+            role="user",
+            content=message
+        )
+        db.add(user_message)
+        db.commit()
+        
+        # Get chat history for context
+        chat_history = ChatService.get_chat_history(db, session_id, limit=10)
+        
+        # Format chat history for the graph
+        history_messages = [
+            {"role": msg["role"], "content": msg["content"]}
+            for msg in chat_history
+        ]
+        
+        # Process query through LangGraph workflow
+        response_data = multi_agent_graph.process_query(
+            query=message,
+            user_id=user_id,
+            chat_history=history_messages,
+            policy_ids=policy_ids
+        )
+        
+        # Prepare metadata
+        meta = {
+            "agent": response_data.get("agent", "unknown"),
+            "routing_reasoning": response_data.get("routing_reasoning", ""),
+            "sources": response_data.get("sources", []),
+            "metadata": response_data.get("metadata", {}),
+            "policy_names": response_data.get("policy_names", [])  # Policy document names
+        }
+        
+        print(f"[Chat Service] Saving meta with policy_names: {meta.get('policy_names', [])}")
+        
+        # Save assistant message
+        assistant_message = Message(
+            id=generate_id(),
+            session_id=session_id,
+            role="assistant",
+            content=response_data.get("answer", "I apologize, but I couldn't generate a response."),
+            meta=json.dumps(meta)
+        )
+        db.add(assistant_message)
+        
+        # Update session timestamp
+        SessionService.update_session_timestamp(db, session_id)
+        
+        db.commit()
+        db.refresh(assistant_message)
+        
+        # Auto-generate session title if this is the first exchange
+        messages_count = db.query(Message).filter(Message.session_id == session_id).count()
+        if messages_count == 2 and chat_session.title == "New Conversation":
+            # Generate title from first user message
+            title = ChatService._generate_session_title(message)
+            SessionService.update_session_title(db, session_id, title)
+        
+        return {
+            "message": assistant_message,
+            "session_id": session_id,
+            "agent": meta["agent"],
+            "sources": meta.get("sources", [])
+        }
+    
+    @staticmethod
+    def get_chat_history(
+        db: Session,
+        session_id: str,
+        limit: Optional[int] = None
+    ) -> List[Dict]:
+        """
+        Get chat history for a session.
+        
+        Args:
+            db: Database session
+            session_id: Session ID
+            limit: Optional limit on number of messages
+            
+        Returns:
+            List of message dictionaries
+        """
+        query = db.query(Message).filter(
+            Message.session_id == session_id
+        ).order_by(Message.created_at.asc())
+        
+        if limit:
+            # Get last N messages
+            total = query.count()
+            if total > limit:
+                query = query.offset(total - limit)
+        
+        messages = query.all()
+        
+        return [
+            {
+                "id": msg.id,
+                "role": msg.role,
+                "content": msg.content,
+                "meta": json.loads(msg.meta) if msg.meta else {},
+                "created_at": msg.created_at.isoformat()
+            }
+            for msg in messages
+        ]
+    
+    @staticmethod
+    def _generate_session_title(first_message: str) -> str:
+        """
+        Generate a ChatGPT-style session title using LLM.
+        
+        Args:
+            first_message: The first user message in the conversation
+            
+        Returns:
+            A concise, descriptive title (max 50 characters)
+        """
+        from app.llm.client import llm_client
+        
+        try:
+            prompt = f"""Generate a very short, concise title for a chat conversation that starts with this message:
+
+"{first_message}"
+
+Requirements:
+- Maximum 50 characters
+- Be specific and descriptive
+- Capture the main topic/question
+- Professional tone
+- No quotes around the title
+- Examples: "Building Code Requirements", "Fire Safety Regulations", "Basement Definition"
+
+Return ONLY the title, nothing else:"""
+
+            title = llm_client.get_completion(
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.7,
+                max_tokens=20
+            )
+            
+            # Clean up the title
+            title = title.strip().strip('"').strip("'")
+            
+            # Ensure it's not too long
+            if len(title) > 50:
+                title = title[:47] + "..."
+            
+            # Fallback if empty or too short
+            if len(title) < 3:
+                title = first_message[:50].strip()
+                if len(first_message) > 50:
+                    title += "..."
+            
+            return title
+            
+        except Exception as e:
+            print(f"[Chat Service] Error generating title: {e}")
+            # Fallback to simple truncation
+            title = first_message[:50].strip()
+            if len(first_message) > 50:
+                title += "..."
+            return title
+
+
+# Global chat service instance
+chat_service = ChatService()

app/services/document_service.py

@@ -0,0 +1,161 @@
+from sqlalchemy.orm import Session
+from typing import List, Optional
+import os
+import shutil
+
+from app.database.models import Document
+from app.services.rag_service import rag_service
+from app.utils.helpers import generate_id
+from app.utils.validators import validate_file_type, validate_file_size
+
+
+class DocumentService:
+    """Service for document management operations."""
+    
+    @staticmethod
+    def upload_document(
+        db: Session,
+        file,
+        user_id: str,
+        filename: str
+    ) -> Document:
+        """
+        Upload and process a document.
+        
+        Args:
+            db: Database session
+            file: File object
+            user_id: User ID
+            filename: Original filename
+            
+        Returns:
+            Created Document object
+            
+        Raises:
+            ValueError: If file validation fails
+        """
+        # Validate file type (PDF only for now)
+        if not validate_file_type(filename, ['pdf', 'txt', 'docx']):
+            raise ValueError("Invalid file type. Only PDF, TXT, and DOCX files are allowed.")
+        
+        # Get file size
+        file.seek(0, 2)  # Seek to end
+        file_size = file.tell()
+        file.seek(0)  # Reset to beginning
+        
+        # Validate file size (10MB limit)
+        if not validate_file_size(file_size, max_size_mb=10):
+            raise ValueError("File size exceeds 10MB limit.")
+        
+        # Generate document ID
+        doc_id = generate_id()
+        
+        # Determine file type
+        file_extension = filename.rsplit('.', 1)[1].lower() if '.' in filename else 'unknown'
+        
+        # Create upload directory if it doesn't exist
+        upload_dir = os.path.join(os.path.dirname(__file__), "..", "..", "data", "uploads")
+        os.makedirs(upload_dir, exist_ok=True)
+        
+        # Save file
+        file_path = os.path.join(upload_dir, f"{doc_id}_{filename}")
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file, buffer)
+        
+        # Create document record
+        document = Document(
+            id=doc_id,
+            user_id=user_id,
+            filename=filename,
+            file_path=file_path,
+            file_type=file_extension,
+            file_size=file_size
+        )
+        
+        db.add(document)
+        db.commit()
+        db.refresh(document)
+        
+        return document
+    
+    @staticmethod
+    def process_document_content(
+        db: Session,
+        document_id: str,
+        content: str
+    ) -> int:
+        """
+        Process document content for RAG.
+        
+        Args:
+            db: Database session
+            document_id: Document ID
+            content: Extracted text content
+            
+        Returns:
+            Number of chunks created
+        """
+        document = db.query(Document).filter(Document.id == document_id).first()
+        
+        if not document:
+            raise ValueError("Document not found")
+        
+        # Process with RAG service
+        num_chunks = rag_service.process_document(
+            document_id=document.id,
+            filename=document.filename,
+            content=content,
+            user_id=document.user_id
+        )
+        
+        return num_chunks
+    
+    @staticmethod
+    def get_user_documents(db: Session, user_id: str) -> List[Document]:
+        """
+        Get all documents for a user.
+        
+        Args:
+            db: Database session
+            user_id: User ID
+            
+        Returns:
+            List of Document objects
+        """
+        return db.query(Document).filter(
+            Document.user_id == user_id
+        ).order_by(Document.created_at.desc()).all()
+    
+    @staticmethod
+    def delete_document(db: Session, document_id: str) -> bool:
+        """
+        Delete a document and its chunks.
+        
+        Args:
+            db: Database session
+            document_id: Document ID
+            
+        Returns:
+            True if deleted, False if not found
+        """
+        document = db.query(Document).filter(Document.id == document_id).first()
+        
+        if not document:
+            return False
+        
+        # Delete file from filesystem
+        if os.path.exists(document.file_path):
+            os.remove(document.file_path)
+        
+        # Delete chunks from vector database
+        rag_service.delete_document_chunks(document_id)
+        
+        # Delete database record
+        db.delete(document)
+        db.commit()
+        
+        return True
+
+
+# Global document service instance
+document_service = DocumentService()

app/services/news_service.py

@@ -0,0 +1,153 @@
+import requests
+from bs4 import BeautifulSoup
+from urllib.parse import quote, urlparse, parse_qs
+from datetime import datetime
+import dateparser
+
+from app.services.sentiment_service import analyze_sentiment
+
+HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/115.0.0.0 Safari/537.36"
+    )
+}
+
+
+def clean_google_url(google_url: str) -> str:
+    """
+    Extract actual URL from Google redirect-style /url?q=... links.
+    
+    Args:
+        google_url: Google redirect URL
+        
+    Returns:
+        Cleaned actual URL
+    """
+    parsed = urlparse(google_url)
+    if parsed.path == "/url":
+        qs = parse_qs(parsed.query)
+        return qs.get("q", [google_url])[0]
+    return google_url
+
+
+def fetch_google_news(query: str, state: str) -> list:
+    """
+    Fetch news articles from Google News by scraping search results.
+    
+    Args:
+        query: Search query (e.g., 'construction law')
+        state: Location/state filter (e.g., 'gujarat')
+        
+    Returns:
+        List of news article dictionaries with title, link, snippet, sentiment, date
+    """
+    search_query = quote(f"{query} {state}")
+    url = f"https://www.google.com/search?q={search_query}&tbm=nws"
+
+    try:
+        res = requests.get(url, headers=HEADERS, timeout=10)
+        res.raise_for_status()
+    except requests.RequestException as e:
+        print(f"❌ Request failed: {e}")
+        return []
+
+    soup = BeautifulSoup(res.text, "html.parser")
+
+    results = []
+    articles = soup.find_all("div", class_="SoaBEf")
+
+    for article in articles:
+        # Extract title
+        title_tag = article.find("div", class_="n0jPhd ynAwRc MBeuO nDgy9d")
+        title = title_tag.text.strip() if title_tag else ""
+
+        # Extract URL and clean it
+        a_tag = article.find("a")
+        link = clean_google_url(a_tag["href"]) if a_tag and a_tag.get("href") else ""
+
+        # Extract snippet
+        snippet_tag = article.find("div", class_="GI74Re nDgy9d")
+        snippet = snippet_tag.text.strip() if snippet_tag else ""
+
+        # Extract date from the correct div
+        date_div = article.find("div", class_="OSrXXb")
+        date_text = ""
+        if date_div:
+            span = date_div.find("span")
+            if span:
+                date_text = span.text.strip()
+
+        # Parse it to datetime
+        parsed_date = dateparser.parse(date_text) if date_text else None
+
+        # Analyze sentiment using BOTH title and snippet for better accuracy
+        # Combine title and snippet as news snippets alone are often neutral
+        combined_text = f"{title}. {snippet}"
+        sentiment = analyze_sentiment(combined_text)
+        
+        print(f"[SENTIMENT] {sentiment}: {title[:50]}...")
+        
+        if title and link:
+            results.append({
+                "title": title,
+                "link": link,
+                "snippet": snippet,
+                "sentiment": sentiment,  
+                "published_date": parsed_date.isoformat() if parsed_date else None,
+                "source": "Google News"
+            })
+    
+    # Sort by date (newest first)
+    results.sort(key=lambda x: x["published_date"] or "", reverse=True)
+
+    print(f"✅ Extracted {len(results)} news articles")
+    return results
+
+
+def fetch_google_news_with_rss_fallback(query: str, state: str) -> list:
+    """
+    Compatibility wrapper: prefer RSS/structured sources in future; currently calls fetch_google_news.
+    
+    Args:
+        query: Search query
+        state: Location filter
+        
+    Returns:
+        List of news articles
+    """
+    try:
+        return fetch_google_news(query, state)
+    except Exception as e:
+        print(f"Error fetching news: {e}")
+        return []
+
+
+def fetch_news_plus_extras(query: str, state: str, include_extras: bool = False) -> dict:
+    """
+    Return combined news and optional extras (web results).
+    
+    Args:
+        query: Search query
+        state: Location filter
+        include_extras: Whether to include extra web results
+        
+    Returns:
+        Dictionary with count, news articles, and optional extras
+        
+    Structure:
+        { 'count': int, 'news': [...], 'extras': [...] }
+    """
+    news = []
+    try:
+        news = fetch_google_news(query, state)
+    except Exception as e:
+        print(f"Error in fetch_news_plus_extras: {e}")
+        news = []
+
+    extras = []
+    # Placeholder: if include_extras is True we could call a web search or DuckDuckGo API.
+    # Keep extras empty to avoid optional dependencies causing import errors.
+
+    return {"count": len(news), "news": news, "extras": extras}

app/services/policy_service.py

@@ -0,0 +1,233 @@
+"""
+Service for managing official policies (admin only).
+"""
+from sqlalchemy.orm import Session
+from typing import List, Optional
+import os
+import shutil
+
+from app.database.models import OfficialPolicy
+from app.utils.helpers import generate_id
+from app.utils.validators import validate_file_type, validate_file_size
+from app.services.rag_service import rag_service
+
+
+class PolicyService:
+    """Service for official policy management."""
+    
+    @staticmethod
+    def upload_policy(
+        db: Session,
+        file,
+        title: str,
+        filename: str,
+        admin_user_id: str,
+        description: Optional[str] = None,
+        category: Optional[str] = None
+    ) -> OfficialPolicy:
+        """
+        Upload an official policy document.
+        
+        Args:
+            db: Database session
+            file: File object
+            title: Policy title
+            filename: Original filename
+            admin_user_id: Admin user ID
+            description: Optional description
+            category: Optional category
+            
+        Returns:
+            Created OfficialPolicy object
+            
+        Raises:
+            ValueError: If file validation fails
+        """
+        # Validate file type
+        if not validate_file_type(filename, ['pdf', 'txt', 'docx']):
+            raise ValueError("Invalid file type. Only PDF, TXT, and DOCX files are allowed.")
+        
+        # Get file size
+        file.seek(0, 2)
+        file_size = file.tell()
+        file.seek(0)
+        
+        # Validate file size (20MB limit for policies)
+        if not validate_file_size(file_size, max_size_mb=20):
+            raise ValueError("File size exceeds 20MB limit.")
+        
+        # Generate policy ID
+        policy_id = generate_id()
+        
+        # Determine file type
+        file_extension = filename.rsplit('.', 1)[1].lower() if '.' in filename else 'unknown'
+        
+        # Create upload directory
+        upload_dir = os.path.join(os.path.dirname(__file__), "..", "..", "data", "policies")
+        os.makedirs(upload_dir, exist_ok=True)
+        
+        # Save file
+        file_path = os.path.join(upload_dir, f"{policy_id}_{filename}")
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file, buffer)
+        
+        # Create policy record
+        policy = OfficialPolicy(
+            id=policy_id,
+            title=title,
+            description=description,
+            filename=filename,
+            file_path=file_path,
+            file_type=file_extension,
+            file_size=file_size,
+            category=category,
+            uploaded_by=admin_user_id,
+            is_active=1
+        )
+        
+        db.add(policy)
+        db.commit()
+        db.refresh(policy)
+        
+        return policy
+    
+    @staticmethod
+    def process_policy_content(
+        db: Session,
+        policy_id: str,
+        content: str
+    ) -> int:
+        """
+        Process policy content for RAG (store in vector DB with special collection).
+        
+        Args:
+            db: Database session
+            policy_id: Policy ID
+            content: Extracted text content
+            
+        Returns:
+            Number of chunks created
+        """
+        policy = db.query(OfficialPolicy).filter(OfficialPolicy.id == policy_id).first()
+        
+        if not policy:
+            raise ValueError("Policy not found")
+        
+        # Process with RAG service (using a special "official_policies" user_id)
+        num_chunks = rag_service.process_document(
+            document_id=policy.id,
+            filename=f"[POLICY] {policy.title}",
+            content=content,
+            user_id="official_policies"  # Special ID for policies
+        )
+        
+        return num_chunks
+    
+    @staticmethod
+    def get_all_policies(db: Session, active_only: bool = True) -> List[OfficialPolicy]:
+        """
+        Get all official policies.
+        
+        Args:
+            db: Database session
+            active_only: Only return active policies
+            
+        Returns:
+            List of OfficialPolicy objects
+        """
+        query = db.query(OfficialPolicy)
+        
+        if active_only:
+            query = query.filter(OfficialPolicy.is_active == 1)
+        
+        return query.order_by(OfficialPolicy.created_at.desc()).all()
+    
+    @staticmethod
+    def get_policy_by_id(db: Session, policy_id: str) -> Optional[OfficialPolicy]:
+        """
+        Get policy by ID.
+        
+        Args:
+            db: Database session
+            policy_id: Policy ID
+            
+        Returns:
+            OfficialPolicy object or None
+        """
+        return db.query(OfficialPolicy).filter(OfficialPolicy.id == policy_id).first()
+    
+    @staticmethod
+    def update_policy(
+        db: Session,
+        policy_id: str,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        category: Optional[str] = None,
+        is_active: Optional[bool] = None
+    ) -> Optional[OfficialPolicy]:
+        """
+        Update policy metadata.
+        
+        Args:
+            db: Database session
+            policy_id: Policy ID
+            title: New title
+            description: New description
+            category: New category
+            is_active: New active status
+            
+        Returns:
+            Updated OfficialPolicy object or None
+        """
+        policy = db.query(OfficialPolicy).filter(OfficialPolicy.id == policy_id).first()
+        
+        if not policy:
+            return None
+        
+        if title is not None:
+            policy.title = title
+        if description is not None:
+            policy.description = description
+        if category is not None:
+            policy.category = category
+        if is_active is not None:
+            policy.is_active = 1 if is_active else 0
+        
+        db.commit()
+        db.refresh(policy)
+        
+        return policy
+    
+    @staticmethod
+    def delete_policy(db: Session, policy_id: str) -> bool:
+        """
+        Delete a policy and its chunks.
+        
+        Args:
+            db: Database session
+            policy_id: Policy ID
+            
+        Returns:
+            True if deleted, False if not found
+        """
+        policy = db.query(OfficialPolicy).filter(OfficialPolicy.id == policy_id).first()
+        
+        if not policy:
+            return False
+        
+        # Delete file from filesystem
+        if os.path.exists(policy.file_path):
+            os.remove(policy.file_path)
+        
+        # Delete chunks from vector database
+        rag_service.delete_document_chunks(policy_id)
+        
+        # Delete database record
+        db.delete(policy)
+        db.commit()
+        
+        return True
+
+
+# Global policy service instance
+policy_service = PolicyService()