supabase

README.md

@@ -1,11 +1,124 @@
----
-title: WhatsappChatBot
-emoji: 🌖
-colorFrom: yellow
-colorTo: red
-sdk: docker
-pinned: false
-short_description: WhatsApp chat bot for Rumas
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# PropAgent - WhatsApp AI Agent
+
+A WhatsApp chatbot powered by OpenAI GPT-4 and integrated with Supabase for user management.
+
+## Features
+
+- 🤖 AI-powered chat responses using OpenAI GPT-4
+- 📱 WhatsApp Business API integration
+- 👥 User management with Supabase database
+- 🔄 Conversation memory and context
+- 📊 User activity tracking
+- 🚀 RESTful API endpoints for user management
+
+## Setup
+
+### 1. Environment Variables
+
+Create a `.env` file with the following variables:
+
+```bash
+# WhatsApp Business API
+VERIFY_TOKEN=your_webhook_verify_token
+PHONE_NUMBER_ID=your_phone_number_id
+WHATSAPP_API_TOKEN=your_whatsapp_api_token
+
+# OpenAI
+OPENAI_API_KEY=your_openai_api_key
+
+# Supabase
+SUPABASE_URL=your_supabase_project_url
+SUPABASE_KEY=your_supabase_anon_key
+```
+
+### 2. Supabase Setup
+
+1. Create a new Supabase project at [supabase.com](https://supabase.com)
+2. Go to the SQL Editor in your Supabase dashboard
+3. Run the SQL script from `supabase_setup.sql` to create the users table
+4. Copy your project URL and anon key from Settings > API
+
+### 3. WhatsApp Business API Setup
+
+1. Create a Meta Developer account
+2. Set up a WhatsApp Business app
+3. Configure webhook URL: `https://your-domain.com/webhook`
+4. Set the verify token in your environment variables
+
+### 4. Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+### 5. Running the Application
+
+```bash
+uvicorn main:app --host 0.0.0.0 --port 8000
+```
+
+## API Endpoints
+
+### Webhook Endpoints
+- `GET /webhook` - WhatsApp webhook verification
+- `POST /webhook` - Receive WhatsApp messages
+
+### User Management
+- `GET /users/{wa_id}` - Get user by WhatsApp ID
+- `GET /users` - List all users (with pagination)
+- `PUT /users/{wa_id}` - Update user name
+
+### Health & Testing
+- `GET /ping` - Simple health check
+- `GET /health` - Detailed service status
+- `POST /chat` - Direct AI chat endpoint
+
+## Database Schema
+
+### Users Table
+```sql
+users
+-----
+- wa_id (TEXT, PRIMARY KEY) - WhatsApp user ID
+- name (TEXT) - User's display name
+- created_at (TIMESTAMP) - Account creation time
+- updated_at (TIMESTAMP) - Last activity time
+```
+
+## Features
+
+### User Management
+- Automatic user creation when first message is received
+- User name updates from WhatsApp profile
+- Activity tracking with automatic timestamp updates
+
+### AI Chat
+- Context-aware conversations using user names
+- Conversation memory (last 6 messages)
+- Error handling and fallback responses
+
+### Security
+- Environment variable configuration
+- Optional Row Level Security (RLS) in Supabase
+- Input validation and error handling
+
+## Development
+
+The application uses:
+- **FastAPI** for the web framework
+- **LangGraph** for conversation flow management
+- **OpenAI GPT-4** for AI responses
+- **Supabase** for user data storage
+- **WhatsApp Business API** for messaging
+
+## Deployment
+
+The application includes a Dockerfile for containerized deployment. You can deploy it to:
+- Hugging Face Spaces
+- Railway
+- Heroku
+- Any container platform
+
+## License
+
+MIT License

main.py

@@ -11,6 +11,8 @@ from langchain_core.memory import BaseMemory
 from langchain_core.chat_history import BaseChatMessageHistory
 from langchain_core.messages import HumanMessage, AIMessage
 from langchain_openai import ChatOpenAI
+from supabase import create_client, Client
+from datetime import datetime
 
 # --- App and Config ---
 app = FastAPI()
@@ -18,6 +20,57 @@ VERIFY_TOKEN = os.getenv("VERIFY_TOKEN", "")
 PHONE_NUMBER_ID = os.getenv("PHONE_NUMBER_ID", "")
 WHATSAPP_API_TOKEN = os.getenv("WHATSAPP_API_TOKEN", "")
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+SUPABASE_URL = os.getenv("SUPABASE_URL", "")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY", "")
+
+# --- Supabase Client Setup ---
+supabase: Client = None
+if SUPABASE_URL and SUPABASE_KEY:
+    supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
+else:
+    print("Warning: Supabase credentials not set. Database functionality will be limited.")
+
+# --- User Management Functions ---
+async def get_or_create_user(wa_id: str, name: str = None) -> dict:
+    """Get existing user or create new one"""
+    if not supabase:
+        return {"wa_id": wa_id, "name": name or "Unknown"}
+    
+    try:
+        # Try to get existing user
+        response = supabase.table("users").select("*").eq("wa_id", wa_id).execute()
+        
+        if response.data:
+            # User exists, update if name provided
+            user = response.data[0]
+            if name and name != user.get("name"):
+                supabase.table("users").update({"name": name, "updated_at": datetime.utcnow().isoformat()}).eq("wa_id", wa_id).execute()
+                user["name"] = name
+            return user
+        else:
+            # Create new user
+            new_user = {
+                "wa_id": wa_id,
+                "name": name or "Unknown",
+                "created_at": datetime.utcnow().isoformat(),
+                "updated_at": datetime.utcnow().isoformat()
+            }
+            response = supabase.table("users").insert(new_user).execute()
+            return response.data[0] if response.data else new_user
+            
+    except Exception as e:
+        print(f"Error in get_or_create_user: {e}")
+        return {"wa_id": wa_id, "name": name or "Unknown"}
+
+async def update_user_activity(wa_id: str):
+    """Update user's last activity timestamp"""
+    if not supabase:
+        return
+    
+    try:
+        supabase.table("users").update({"updated_at": datetime.utcnow().isoformat()}).eq("wa_id", wa_id).execute()
+    except Exception as e:
+        print(f"Error updating user activity: {e}")
 
 # --- OpenAI Client Setup ---
 llm = ChatOpenAI(openai_api_key=OPENAI_API_KEY, model="gpt-4o-mini")
@@ -32,6 +85,7 @@ if not OPENAI_API_KEY:
 # --- LangGraph Setup ---
 def chat_with_memory(state):
     user_message = state["user_message"]
+    user_info = state.get("user_info", {})
     
     # Add user message to history
     chat_history.append({"role": "user", "content": user_message})
@@ -39,8 +93,12 @@ def chat_with_memory(state):
     # Keep only last 6 messages for context
     recent_messages = chat_history[-6:] if len(chat_history) > 6 else chat_history
     
-    # Add system message at the beginning
-    messages = [{"role": "system", "content": "You are a helpful and concise assistant."}] + recent_messages
+    # Add system message with user context
+    system_message = "You are a helpful and concise assistant."
+    if user_info.get("name") and user_info["name"] != "Unknown":
+        system_message += f" The user's name is {user_info['name']}."
+    
+    messages = [{"role": "system", "content": system_message}] + recent_messages
 
     try:
         if not OPENAI_API_KEY:
@@ -62,6 +120,7 @@ from typing import TypedDict
 class ChatState(TypedDict):
     user_message: str
     response: str
+    user_info: dict
 
 graph = StateGraph(ChatState)
 graph.add_node("chat", RunnableLambda(chat_with_memory))
@@ -94,13 +153,26 @@ async def receive_message(req: Request):
             return JSONResponse({"status": "ignored", "reason": "no contacts/messages"})
 
         wa_id = contacts[0]["wa_id"]
+        contact_name = contacts[0].get("profile", {}).get("name")
         msg = messages[0]
 
         if msg.get("type") == "text":
             user_message = msg.get("text", {}).get("body", "")
-            ai_result = await chat_graph.ainvoke({"user_message": user_message})
+            
+            # Get or create user in database
+            user_info = await get_or_create_user(wa_id, contact_name)
+            
+            # Update user activity
+            await update_user_activity(wa_id)
+            
+            # Process with AI including user context
+            ai_result = await chat_graph.ainvoke({
+                "user_message": user_message,
+                "user_info": user_info
+            })
+            
             await send_whatsapp_message(wa_id, ai_result["response"])
-            return JSONResponse({"status": "replied"})
+            return JSONResponse({"status": "replied", "user_id": wa_id})
 
     except Exception as e:
         print("Error processing message:", e)
@@ -131,7 +203,7 @@ async def send_whatsapp_message(wa_id: str, message: str):
 class ChatRequest(BaseModel):
     message: str
     model: Optional[str] = "gpt-4o-mini"
-    max_tokens: Optional[int] = 150
+    max_tokens: Optional[int] = 1500
 
 class ChatResponse(BaseModel):
     response: str
@@ -153,6 +225,57 @@ def health_check():
     status = {
         "api": "healthy",
         "whatsapp": "configured" if WHATSAPP_API_TOKEN else "not configured",
-        "openai": "configured" if OPENAI_API_KEY else "not configured"
+        "openai": "configured" if OPENAI_API_KEY else "not configured",
+        "supabase": "configured" if supabase else "not configured"
     }
-    return status
+    return status
+
+# --- User Management Endpoints ---
+@app.get("/users/{wa_id}")
+async def get_user(wa_id: str):
+    """Get user by WhatsApp ID"""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not configured")
+    
+    try:
+        response = supabase.table("users").select("*").eq("wa_id", wa_id).execute()
+        if response.data:
+            return response.data[0]
+        else:
+            raise HTTPException(status_code=404, detail="User not found")
+    except Exception as e:
+        print(f"Error getting user: {e}")
+        raise HTTPException(status_code=500, detail="Database error")
+
+@app.get("/users")
+async def list_users(limit: int = 50, offset: int = 0):
+    """List all users with pagination"""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not configured")
+    
+    try:
+        response = supabase.table("users").select("*").range(offset, offset + limit - 1).order("created_at", desc=True).execute()
+        return {"users": response.data, "count": len(response.data)}
+    except Exception as e:
+        print(f"Error listing users: {e}")
+        raise HTTPException(status_code=500, detail="Database error")
+
+@app.put("/users/{wa_id}")
+async def update_user(wa_id: str, name: str):
+    """Update user name"""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not configured")
+    
+    try:
+        response = supabase.table("users").update({
+            "name": name,
+            "updated_at": datetime.utcnow().isoformat()
+        }).eq("wa_id", wa_id).execute()
+        
+        if response.data:
+            return response.data[0]
+        else:
+            raise HTTPException(status_code=404, detail="User not found")
+    except Exception as e:
+        print(f"Error updating user: {e}")
+        raise HTTPException(status_code=500, detail="Database error")

requirements.txt

@@ -6,4 +6,5 @@ openai
 langchain
 langchain-openai
 langgraph
-langchain-core 
+langchain-core
+supabase 

supabase_setup.sql

@@ -0,0 +1,33 @@
+-- Create users table for WhatsApp AI Agent
+CREATE TABLE IF NOT EXISTS users (
+    wa_id TEXT PRIMARY KEY,
+    name TEXT NOT NULL DEFAULT 'Unknown',
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Create index for better query performance
+CREATE INDEX IF NOT EXISTS idx_users_created_at ON users(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_users_updated_at ON users(updated_at DESC);
+
+-- Enable Row Level Security (RLS) - optional but recommended
+ALTER TABLE users ENABLE ROW LEVEL SECURITY;
+
+-- Create policy to allow all operations (you can restrict this based on your needs)
+CREATE POLICY "Allow all operations on users" ON users
+    FOR ALL USING (true);
+
+-- Optional: Create a function to automatically update the updated_at timestamp
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = NOW();
+    RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+-- Create trigger to automatically update updated_at
+CREATE TRIGGER update_users_updated_at 
+    BEFORE UPDATE ON users 
+    FOR EACH ROW 
+    EXECUTE FUNCTION update_updated_at_column();