Initial commit: AGROW Chatbot with Gemini LLM

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY app.py .
+COPY supabase_client.py .
+COPY prompts.py .
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "app.py"]

README.md

@@ -0,0 +1,42 @@
+---
+title: AGROW Chatbot
+emoji: 🌾
+colorFrom: green
+colorTo: yellow
+sdk: docker
+pinned: false
+license: mit
+---
+
+# AGROW Agricultural Chatbot
+
+AI-powered agricultural advisor using Gemini LLM with Supabase conversation storage.
+
+## Features
+- Gemini 1.5 Flash for intelligent responses
+- Agricultural expertise (crop health, soil, weather)
+- Conversation history persistence
+- Pipeline context integration
+
+## API Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/chat` | POST | Send message, get AI response |
+| `/session/new` | POST | Create new chat session |
+| `/session/{id}/history` | GET | Get conversation history |
+| `/sessions/{user_id}` | GET | List user's sessions |
+
+## Environment Variables
+
+- `GEMINI_API_KEY` - Google Gemini API key
+- `SUPABASE_URL` - Supabase project URL
+- `SUPABASE_KEY` - Supabase anon key
+
+## Example Request
+
+```bash
+curl -X POST https://YOUR-SPACE.hf.space/chat \
+  -H "Content-Type: application/json" \
+  -d '{"session_id": "abc123", "message": "What is my crop health status?"}'
+```

app.py

@@ -0,0 +1,312 @@
+"""
+AGROW Agricultural Chatbot Service
+===================================
+AI-powered agricultural advisor using Gemini LLM with:
+- Context from pipeline outputs (stress, NDVI, forecasts)
+- Supabase conversation storage
+- Session management
+"""
+
+import os
+import json
+import logging
+import uuid
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+import traceback
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import google.generativeai as genai
+
+from supabase_client import SupabaseClient
+from prompts import SYSTEM_PROMPT, build_context_prompt
+
+# ============================================================================
+# LOGGING
+# ============================================================================
+logging.basicConfig(
+    level=logging.INFO,
+    format='[%(asctime)s] %(levelname)s: %(message)s',
+    datefmt='%H:%M:%S'
+)
+logger = logging.getLogger("ChatbotService")
+
+# ============================================================================
+# GEMINI SETUP
+# ============================================================================
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+if GEMINI_API_KEY:
+    genai.configure(api_key=GEMINI_API_KEY)
+    model = genai.GenerativeModel('gemini-1.5-flash')
+    logger.info("Gemini API configured successfully")
+else:
+    model = None
+    logger.warning("GEMINI_API_KEY not set - chatbot will return mock responses")
+
+# Supabase client
+supabase = SupabaseClient()
+
+# ============================================================================
+# FASTAPI
+# ============================================================================
+app = FastAPI(
+    title="AGROW Chatbot Service",
+    description="AI agricultural advisor with conversation storage",
+    version="1.0.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ============================================================================
+# REQUEST/RESPONSE MODELS
+# ============================================================================
+class ChatRequest(BaseModel):
+    session_id: str
+    message: str
+    user_id: Optional[str] = None
+    field_context: Optional[Dict[str, Any]] = None  # Pipeline data
+
+class ChatResponse(BaseModel):
+    response: str
+    session_id: str
+    message_id: str
+    context_used: List[str]
+    timestamp: str
+
+class SessionRequest(BaseModel):
+    user_id: str
+    title: Optional[str] = None
+
+class SessionResponse(BaseModel):
+    session_id: str
+    title: str
+    created_at: str
+
+class MessageModel(BaseModel):
+    id: str
+    role: str
+    content: str
+    created_at: str
+
+class HistoryResponse(BaseModel):
+    session_id: str
+    messages: List[MessageModel]
+
+class SessionListItem(BaseModel):
+    id: str
+    title: str
+    created_at: str
+    updated_at: str
+    message_count: int
+
+# ============================================================================
+# HELPER FUNCTIONS
+# ============================================================================
+def generate_response(user_message: str, history: List[Dict], context: Optional[Dict] = None) -> tuple[str, List[str]]:
+    """Generate AI response using Gemini."""
+    context_used = []
+    
+    # Build conversation history for context
+    conversation = []
+    for msg in history[-10:]:  # Last 10 messages for context
+        role = "user" if msg.get("role") == "user" else "model"
+        conversation.append({"role": role, "parts": [msg.get("content", "")]})
+    
+    # Build context prompt if pipeline data available
+    context_prompt = ""
+    if context:
+        context_prompt = build_context_prompt(context)
+        context_used = list(context.keys())
+    
+    # Combine system prompt with context
+    full_system = SYSTEM_PROMPT
+    if context_prompt:
+        full_system += f"\n\n## Current Field Analysis:\n{context_prompt}"
+    
+    if model is None:
+        # Mock response if no API key
+        return f"I received your question: '{user_message}'. Please configure GEMINI_API_KEY for real responses.", []
+    
+    try:
+        # Create chat with system instruction
+        chat = model.start_chat(history=conversation)
+        
+        # Generate response
+        response = chat.send_message(
+            f"[System: {full_system}]\n\nUser: {user_message}",
+            generation_config=genai.types.GenerationConfig(
+                temperature=0.7,
+                max_output_tokens=1024,
+            )
+        )
+        
+        return response.text, context_used
+        
+    except Exception as e:
+        logger.error(f"Gemini error: {e}")
+        return f"I apologize, but I encountered an error. Please try again. Error: {str(e)}", []
+
+# ============================================================================
+# API ENDPOINTS
+# ============================================================================
+@app.get("/")
+async def root():
+    return {
+        "service": "AGROW Chatbot Service",
+        "version": "1.0.0",
+        "endpoints": {
+            "/chat": "POST - Send message, get AI response",
+            "/session/new": "POST - Create new chat session",
+            "/session/{id}/history": "GET - Get conversation history",
+            "/sessions/{user_id}": "GET - List user's sessions"
+        }
+    }
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "healthy",
+        "gemini_configured": model is not None,
+        "supabase_configured": supabase.is_configured()
+    }
+
+
+@app.post("/session/new", response_model=SessionResponse)
+async def create_session(request: SessionRequest):
+    """Create a new chat session."""
+    logger.info(f"Creating new session for user: {request.user_id}")
+    
+    try:
+        session = supabase.create_session(
+            user_id=request.user_id,
+            title=request.title or "New Conversation"
+        )
+        
+        return SessionResponse(
+            session_id=session["id"],
+            title=session["title"],
+            created_at=session["created_at"]
+        )
+    except Exception as e:
+        logger.error(f"Failed to create session: {e}")
+        raise HTTPException(500, str(e))
+
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest):
+    """Send a message and get AI response."""
+    logger.info(f"Chat request - Session: {request.session_id}, Message: {request.message[:50]}...")
+    
+    try:
+        # Load conversation history
+        history = supabase.get_messages(request.session_id)
+        
+        # Save user message
+        user_msg_id = supabase.add_message(
+            session_id=request.session_id,
+            role="user",
+            content=request.message
+        )
+        
+        # Generate AI response
+        response_text, context_used = generate_response(
+            request.message, 
+            history,
+            request.field_context
+        )
+        
+        # Save assistant response
+        assistant_msg_id = supabase.add_message(
+            session_id=request.session_id,
+            role="assistant",
+            content=response_text,
+            context_used=context_used
+        )
+        
+        # Update session timestamp
+        supabase.update_session_timestamp(request.session_id)
+        
+        logger.info(f"Response generated - {len(response_text)} chars")
+        
+        return ChatResponse(
+            response=response_text,
+            session_id=request.session_id,
+            message_id=assistant_msg_id,
+            context_used=context_used,
+            timestamp=datetime.now().isoformat()
+        )
+        
+    except Exception as e:
+        logger.error(f"Chat error: {e}")
+        logger.error(traceback.format_exc())
+        raise HTTPException(500, str(e))
+
+
+@app.get("/session/{session_id}/history", response_model=HistoryResponse)
+async def get_history(session_id: str):
+    """Get conversation history for a session."""
+    logger.info(f"Loading history for session: {session_id}")
+    
+    try:
+        messages = supabase.get_messages(session_id)
+        
+        return HistoryResponse(
+            session_id=session_id,
+            messages=[
+                MessageModel(
+                    id=msg.get("id", ""),
+                    role=msg.get("role", ""),
+                    content=msg.get("content", ""),
+                    created_at=msg.get("created_at", "")
+                )
+                for msg in messages
+            ]
+        )
+    except Exception as e:
+        logger.error(f"History error: {e}")
+        raise HTTPException(500, str(e))
+
+
+@app.get("/sessions/{user_id}")
+async def list_sessions(user_id: str):
+    """List all chat sessions for a user."""
+    logger.info(f"Listing sessions for user: {user_id}")
+    
+    try:
+        sessions = supabase.get_user_sessions(user_id)
+        
+        return {
+            "user_id": user_id,
+            "sessions": sessions,
+            "count": len(sessions)
+        }
+    except Exception as e:
+        logger.error(f"List sessions error: {e}")
+        raise HTTPException(500, str(e))
+
+
+@app.delete("/session/{session_id}")
+async def delete_session(session_id: str):
+    """Delete a chat session and its messages."""
+    logger.info(f"Deleting session: {session_id}")
+    
+    try:
+        supabase.delete_session(session_id)
+        return {"status": "deleted", "session_id": session_id}
+    except Exception as e:
+        logger.error(f"Delete error: {e}")
+        raise HTTPException(500, str(e))
+
+
+if __name__ == "__main__":
+    import uvicorn
+    logger.info("Starting AGROW Chatbot Service")
+    uvicorn.run(app, host="0.0.0.0", port=7860)

prompts.py

@@ -0,0 +1,109 @@
+"""
+LLM Prompts for Agricultural Advisor
+=====================================
+System prompts and context builders for Gemini.
+"""
+
+SYSTEM_PROMPT = """You are AGROW AI, an expert agricultural advisor for farmers in India. You help farmers understand their crop health, soil conditions, and provide actionable recommendations.
+
+## Your Expertise:
+- Crop stress analysis using satellite imagery
+- Soil health interpretation (N, P, K, moisture)
+- Vegetation indices (NDVI, NDWI, EVI, SAVI)
+- Weather impact on farming
+- Pest and disease identification
+- Irrigation recommendations
+- Fertilizer application timing
+- Harvest optimization
+
+## Communication Style:
+- Be warm, supportive, and encouraging
+- Use simple language (assume farmer may not know technical terms)
+- When using technical terms, explain them briefly
+- Give practical, actionable advice
+- Consider Indian farming context (seasons, crops, practices)
+- Be concise but thorough
+
+## Response Format:
+- Start with a direct answer to the question
+- Provide 2-3 specific recommendations when relevant
+- End with encouragement or a helpful tip
+- Use bullet points for lists
+
+## Safety:
+- Never recommend chemicals without proper precautions
+- Suggest consulting local agricultural officers for serious issues
+- Recommend soil testing before major fertilizer decisions
+"""
+
+
+def build_context_prompt(context: dict) -> str:
+    """Build context prompt from pipeline analysis data."""
+    parts = []
+    
+    # Stress Analysis
+    if "stress_score" in context:
+        score = context["stress_score"]
+        level = "low" if score < 0.3 else "moderate" if score < 0.6 else "high"
+        parts.append(f"• Crop Stress Level: {level} ({score:.2f}/1.0)")
+    
+    # Vegetation Indices
+    if "ndvi" in context:
+        ndvi = context["ndvi"]
+        health = "excellent" if ndvi > 0.7 else "good" if ndvi > 0.5 else "concerning" if ndvi > 0.3 else "poor"
+        parts.append(f"• NDVI (Plant Health): {ndvi:.3f} - {health}")
+    
+    if "ndwi" in context:
+        ndwi = context["ndwi"]
+        water = "adequate" if ndwi > 0 else "stressed"
+        parts.append(f"• NDWI (Water Content): {ndwi:.3f} - {water}")
+    
+    if "evi" in context:
+        parts.append(f"• EVI (Vegetation Vigor): {context['evi']:.3f}")
+    
+    # Soil Data
+    if "soil" in context:
+        soil = context["soil"]
+        parts.append(f"• Soil Moisture: {soil.get('moisture', 'N/A')}")
+        parts.append(f"• Soil NPK: N={soil.get('nitrogen', 'N/A')}, P={soil.get('phosphorus', 'N/A')}, K={soil.get('potassium', 'N/A')}")
+    
+    # Forecast
+    if "forecast" in context:
+        fc = context["forecast"]
+        parts.append(f"• 20-day Forecast: {fc.get('trend', 'stable')}")
+    
+    # Field Info
+    if "field_name" in context:
+        parts.append(f"• Field: {context['field_name']}")
+    
+    if "crop_type" in context:
+        parts.append(f"• Crop: {context['crop_type']}")
+    
+    if "area" in context:
+        parts.append(f"• Area: {context['area']} acres")
+    
+    # Clusters/Zones
+    if "zones" in context:
+        zones = context["zones"]
+        parts.append(f"• Field Zones: {len(zones)} distinct areas identified")
+        for i, zone in enumerate(zones[:3]):  # Max 3 zones
+            parts.append(f"  - Zone {i+1}: {zone.get('condition', 'N/A')}")
+    
+    # Weather
+    if "weather" in context:
+        w = context["weather"]
+        parts.append(f"• Current Weather: {w.get('condition', 'N/A')}, {w.get('temp', 'N/A')}°C")
+    
+    if not parts:
+        return ""
+    
+    return "\n".join(parts)
+
+
+# Quick response templates for common queries
+QUICK_RESPONSES = {
+    "stress": "Based on your field's stress analysis, ",
+    "water": "Looking at the water content indicators, ",
+    "fertilizer": "Considering your soil nutrient levels, ",
+    "harvest": "For optimal harvest timing, ",
+}

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+pydantic==2.5.2
+google-generativeai==0.3.2
+supabase==2.3.0
+python-dotenv==1.0.0

supabase_client.py

@@ -0,0 +1,232 @@
+"""
+Supabase Client for Chat Storage
+=================================
+Handles conversation persistence with:
+- Session management
+- Message CRUD
+- History retrieval
+"""
+
+import os
+import uuid
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+import json
+
+# Try to import supabase, fallback to in-memory storage
+try:
+    from supabase import create_client, Client
+    SUPABASE_AVAILABLE = True
+except ImportError:
+    SUPABASE_AVAILABLE = False
+    print("Warning: supabase-py not installed, using in-memory storage")
+
+
+class SupabaseClient:
+    """Client for Supabase chat storage operations."""
+    
+    def __init__(self):
+        self.client: Optional[Client] = None
+        self._memory_sessions: Dict[str, Dict] = {}
+        self._memory_messages: Dict[str, List[Dict]] = {}
+        
+        if SUPABASE_AVAILABLE:
+            url = os.environ.get("SUPABASE_URL")
+            key = os.environ.get("SUPABASE_KEY")
+            
+            if url and key:
+                try:
+                    self.client = create_client(url, key)
+                    print("Supabase client initialized successfully")
+                except Exception as e:
+                    print(f"Failed to initialize Supabase: {e}")
+                    self.client = None
+            else:
+                print("SUPABASE_URL or SUPABASE_KEY not set")
+    
+    def is_configured(self) -> bool:
+        """Check if Supabase is properly configured."""
+        return self.client is not None
+    
+    # =========================================================================
+    # SESSION OPERATIONS
+    # =========================================================================
+    def create_session(self, user_id: str, title: str = "New Conversation") -> Dict:
+        """Create a new chat session."""
+        session_id = str(uuid.uuid4())
+        now = datetime.now().isoformat()
+        
+        session_data = {
+            "id": session_id,
+            "user_id": user_id,
+            "title": title,
+            "created_at": now,
+            "updated_at": now
+        }
+        
+        if self.client:
+            try:
+                result = self.client.table("chat_sessions").insert(session_data).execute()
+                return result.data[0] if result.data else session_data
+            except Exception as e:
+                print(f"Supabase create session error: {e}")
+                # Fallback to memory
+        
+        # In-memory fallback
+        self._memory_sessions[session_id] = session_data
+        self._memory_messages[session_id] = []
+        return session_data
+    
+    def get_session(self, session_id: str) -> Optional[Dict]:
+        """Get session details."""
+        if self.client:
+            try:
+                result = self.client.table("chat_sessions").select("*").eq("id", session_id).execute()
+                return result.data[0] if result.data else None
+            except Exception as e:
+                print(f"Supabase get session error: {e}")
+        
+        return self._memory_sessions.get(session_id)
+    
+    def get_user_sessions(self, user_id: str) -> List[Dict]:
+        """Get all sessions for a user, ordered by most recent."""
+        if self.client:
+            try:
+                result = self.client.table("chat_sessions")\
+                    .select("*, chat_messages(count)")\
+                    .eq("user_id", user_id)\
+                    .order("updated_at", desc=True)\
+                    .execute()
+                
+                sessions = []
+                for session in result.data:
+                    msg_count = 0
+                    if session.get("chat_messages"):
+                        msg_count = session["chat_messages"][0].get("count", 0) if session["chat_messages"] else 0
+                    sessions.append({
+                        "id": session["id"],
+                        "title": session["title"],
+                        "created_at": session["created_at"],
+                        "updated_at": session["updated_at"],
+                        "message_count": msg_count
+                    })
+                return sessions
+            except Exception as e:
+                print(f"Supabase get sessions error: {e}")
+        
+        # In-memory fallback
+        return [
+            {**s, "message_count": len(self._memory_messages.get(s["id"], []))}
+            for s in self._memory_sessions.values()
+            if s.get("user_id") == user_id
+        ]
+    
+    def update_session_timestamp(self, session_id: str):
+        """Update session's updated_at timestamp."""
+        now = datetime.now().isoformat()
+        
+        if self.client:
+            try:
+                self.client.table("chat_sessions")\
+                    .update({"updated_at": now})\
+                    .eq("id", session_id)\
+                    .execute()
+            except Exception as e:
+                print(f"Supabase update timestamp error: {e}")
+        else:
+            if session_id in self._memory_sessions:
+                self._memory_sessions[session_id]["updated_at"] = now
+    
+    def update_session_title(self, session_id: str, title: str):
+        """Update session title."""
+        if self.client:
+            try:
+                self.client.table("chat_sessions")\
+                    .update({"title": title, "updated_at": datetime.now().isoformat()})\
+                    .eq("id", session_id)\
+                    .execute()
+            except Exception as e:
+                print(f"Supabase update title error: {e}")
+        else:
+            if session_id in self._memory_sessions:
+                self._memory_sessions[session_id]["title"] = title
+    
+    def delete_session(self, session_id: str):
+        """Delete session and all its messages."""
+        if self.client:
+            try:
+                # Delete messages first (foreign key constraint)
+                self.client.table("chat_messages").delete().eq("session_id", session_id).execute()
+                self.client.table("chat_sessions").delete().eq("id", session_id).execute()
+            except Exception as e:
+                print(f"Supabase delete session error: {e}")
+        else:
+            self._memory_sessions.pop(session_id, None)
+            self._memory_messages.pop(session_id, None)
+    
+    # =========================================================================
+    # MESSAGE OPERATIONS
+    # =========================================================================
+    def add_message(
+        self, 
+        session_id: str, 
+        role: str, 
+        content: str,
+        context_used: Optional[List[str]] = None
+    ) -> str:
+        """Add a message to a session."""
+        message_id = str(uuid.uuid4())
+        now = datetime.now().isoformat()
+        
+        message_data = {
+            "id": message_id,
+            "session_id": session_id,
+            "role": role,
+            "content": content,
+            "context_used": json.dumps(context_used) if context_used else None,
+            "created_at": now
+        }
+        
+        if self.client:
+            try:
+                self.client.table("chat_messages").insert(message_data).execute()
+                return message_id
+            except Exception as e:
+                print(f"Supabase add message error: {e}")
+        
+        # In-memory fallback
+        if session_id not in self._memory_messages:
+            self._memory_messages[session_id] = []
+        self._memory_messages[session_id].append(message_data)
+        return message_id
+    
+    def get_messages(self, session_id: str, limit: int = 100) -> List[Dict]:
+        """Get messages for a session, ordered by creation time."""
+        if self.client:
+            try:
+                result = self.client.table("chat_messages")\
+                    .select("*")\
+                    .eq("session_id", session_id)\
+                    .order("created_at")\
+                    .limit(limit)\
+                    .execute()
+                return result.data if result.data else []
+            except Exception as e:
+                print(f"Supabase get messages error: {e}")
+        
+        # In-memory fallback
+        messages = self._memory_messages.get(session_id, [])
+        return sorted(messages, key=lambda m: m.get("created_at", ""))[:limit]
+    
+    def delete_message(self, message_id: str):
+        """Delete a specific message."""
+        if self.client:
+            try:
+                self.client.table("chat_messages").delete().eq("id", message_id).execute()
+            except Exception as e:
+                print(f"Supabase delete message error: {e}")
+        else:
+            for session_id, messages in self._memory_messages.items():
+                self._memory_messages[session_id] = [
+                    m for m in messages if m.get("id") != message_id
+                ]

supabase_schema.sql

@@ -0,0 +1,96 @@
+-- =============================================================================
+-- AGROW Chatbot Tables
+-- Run this in Supabase SQL Editor
+-- =============================================================================
+
+-- Chat Sessions Table
+CREATE TABLE IF NOT EXISTS chat_sessions (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
+    title TEXT NOT NULL DEFAULT 'New Conversation',
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Chat Messages Table
+CREATE TABLE IF NOT EXISTS chat_messages (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    session_id UUID REFERENCES chat_sessions(id) ON DELETE CASCADE,
+    role TEXT NOT NULL CHECK (role IN ('user', 'assistant')),
+    content TEXT NOT NULL,
+    context_used JSONB,
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Indexes for performance
+CREATE INDEX IF NOT EXISTS idx_chat_sessions_user_id ON chat_sessions(user_id);
+CREATE INDEX IF NOT EXISTS idx_chat_sessions_updated ON chat_sessions(updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_chat_messages_session ON chat_messages(session_id);
+CREATE INDEX IF NOT EXISTS idx_chat_messages_created ON chat_messages(created_at);
+
+-- RLS (Row Level Security) Policies
+ALTER TABLE chat_sessions ENABLE ROW LEVEL SECURITY;
+ALTER TABLE chat_messages ENABLE ROW LEVEL SECURITY;
+
+-- Allow users to see only their own sessions
+CREATE POLICY "Users can view own sessions" ON chat_sessions
+    FOR SELECT USING (auth.uid() = user_id);
+
+CREATE POLICY "Users can insert own sessions" ON chat_sessions
+    FOR INSERT WITH CHECK (auth.uid() = user_id);
+
+CREATE POLICY "Users can update own sessions" ON chat_sessions
+    FOR UPDATE USING (auth.uid() = user_id);
+
+CREATE POLICY "Users can delete own sessions" ON chat_sessions
+    FOR DELETE USING (auth.uid() = user_id);
+
+-- Messages inherit permissions from sessions
+CREATE POLICY "Users can view messages in own sessions" ON chat_messages
+    FOR SELECT USING (
+        EXISTS (
+            SELECT 1 FROM chat_sessions 
+            WHERE chat_sessions.id = chat_messages.session_id 
+            AND chat_sessions.user_id = auth.uid()
+        )
+    );
+
+CREATE POLICY "Users can insert messages in own sessions" ON chat_messages
+    FOR INSERT WITH CHECK (
+        EXISTS (
+            SELECT 1 FROM chat_sessions 
+            WHERE chat_sessions.id = chat_messages.session_id 
+            AND chat_sessions.user_id = auth.uid()
+        )
+    );
+
+CREATE POLICY "Users can delete messages in own sessions" ON chat_messages
+    FOR DELETE USING (
+        EXISTS (
+            SELECT 1 FROM chat_sessions 
+            WHERE chat_sessions.id = chat_messages.session_id 
+            AND chat_sessions.user_id = auth.uid()
+        )
+    );
+
+-- Service role access (for HF Space backend)
+CREATE POLICY "Service can access all sessions" ON chat_sessions
+    FOR ALL USING (auth.role() = 'service_role');
+
+CREATE POLICY "Service can access all messages" ON chat_messages
+    FOR ALL USING (auth.role() = 'service_role');
+
+-- Auto-update updated_at timestamp
+CREATE OR REPLACE FUNCTION update_updated_at()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = NOW();
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS update_chat_sessions_updated_at ON chat_sessions;
+CREATE TRIGGER update_chat_sessions_updated_at
+    BEFORE UPDATE ON chat_sessions
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at();