simplified and broken up code

README.md

@@ -112,9 +112,31 @@ users
 - Optional Row Level Security (RLS) in Supabase
 - Input validation and error handling
 
+## Project Structure
+
+```
+PropAgent/
+├── main.py              # Main application entry point
+├── config.py            # Configuration and client setup
+├── database.py          # Supabase database operations
+├── whatsapp.py          # WhatsApp API integration
+├── ai_chat.py           # LangGraph AI conversation logic
+├── api_routes.py        # FastAPI route definitions
+├── supabase_setup.sql   # Database schema setup
+└── requirements.txt     # Python dependencies
+```
+
 ## Development
 
-The application uses:
+The application uses a modular architecture:
+- **main.py** - Clean entry point focusing on core webhook logic
+- **config.py** - Environment variables and client initialization
+- **database.py** - All Supabase database operations
+- **whatsapp.py** - WhatsApp Business API integration
+- **ai_chat.py** - LangGraph conversation flow and AI processing
+- **api_routes.py** - REST API endpoints and webhook verification
+
+**Technologies:**
 - **FastAPI** for the web framework
 - **LangGraph** for conversation flow management
 - **OpenAI GPT-4** for AI responses

__init__.py

@@ -0,0 +1,2 @@
+# PropAgent - WhatsApp AI Agent Package
+__version__ = "1.0.0" 

ai_chat.py

@@ -0,0 +1,63 @@
+from langgraph.graph import StateGraph, END
+from langchain_core.runnables import RunnableLambda
+from typing import TypedDict
+from config import llm, OPENAI_API_KEY
+
+# Simple in-memory chat history (no deprecation warnings)
+chat_history = []
+
+def chat_with_memory(state):
+    """Chat function with memory and user context"""
+    user_message = state["user_message"]
+    user_info = state.get("user_info", {})
+    
+    # Add user message to history
+    chat_history.append({"role": "user", "content": user_message})
+    
+    # Keep only last 6 messages for context
+    recent_messages = chat_history[-6:] if len(chat_history) > 6 else chat_history
+    
+    # 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:
+            return {"response": "Sorry, AI chat is not available. Please check your OpenAI API key configuration."}
+        
+        response = llm.invoke(messages)
+        
+        # Add AI response to history
+        chat_history.append({"role": "assistant", "content": response.content})
+        
+        return {"response": response.content}
+    except Exception as e:
+        print(f"Error in chat_with_memory: {e}")
+        return {"response": "Sorry, something went wrong: " + str(e)}
+
+class ChatState(TypedDict):
+    user_message: str
+    response: str
+    user_info: dict
+
+# --- Build LangGraph ---
+graph = StateGraph(ChatState)
+graph.add_node("chat", RunnableLambda(chat_with_memory))
+graph.set_entry_point("chat")
+graph.add_edge("chat", END)
+chat_graph = graph.compile()
+
+async def process_message(user_message: str, user_info: dict = None):
+    """Process a message through the AI chat system"""
+    if user_info is None:
+        user_info = {}
+    
+    result = await chat_graph.ainvoke({
+        "user_message": user_message,
+        "user_info": user_info
+    })
+    
+    return result["response"] 

api_routes.py

@@ -0,0 +1,87 @@
+from fastapi import APIRouter, Request, HTTPException, Query
+from fastapi.responses import PlainTextResponse, JSONResponse
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+
+from config import VERIFY_TOKEN, supabase, OPENAI_API_KEY, WHATSAPP_API_TOKEN
+from database import get_user, list_users, update_user_name
+from ai_chat import process_message
+
+router = APIRouter()
+
+# --- Webhook Verification ---
+@router.get("/webhook")
+def verify_webhook(
+    hub_mode: str = Query(None, alias="hub.mode"),
+    hub_token: str = Query(None, alias="hub.verify_token"),
+    hub_challenge: str = Query(None, alias="hub.challenge")
+):
+    if hub_mode == "subscribe" and hub_token == VERIFY_TOKEN:
+        return PlainTextResponse(hub_challenge)
+    raise HTTPException(status_code=403, detail="Invalid token")
+
+# --- Optional Direct Chat Endpoint ---
+class ChatRequest(BaseModel):
+    message: str
+    model: Optional[str] = "gpt-4o-mini"
+    max_tokens: Optional[int] = 1500
+
+class ChatResponse(BaseModel):
+    response: str
+    model: str
+    tokens_used: Optional[int] = None
+
+@router.post("/chat", response_model=ChatResponse)
+async def chat_with_ai(request: ChatRequest):
+    response = await process_message(request.message)
+    return ChatResponse(response=response, model=request.model)
+
+# --- Health ---
+@router.get("/ping")
+def ping():
+    return {"pong": True}
+
+@router.get("/health")
+def health_check():
+    status = {
+        "api": "healthy",
+        "whatsapp": "configured" if WHATSAPP_API_TOKEN else "not configured",
+        "openai": "configured" if OPENAI_API_KEY else "not configured",
+        "supabase": "configured" if supabase else "not configured"
+    }
+    return status
+
+# --- User Management Endpoints ---
+@router.get("/users/{wa_id}")
+async def get_user_endpoint(wa_id: str):
+    """Get user by WhatsApp ID"""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not configured")
+    
+    user = await get_user(wa_id)
+    if user:
+        return user
+    else:
+        raise HTTPException(status_code=404, detail="User not found")
+
+@router.get("/users")
+async def list_users_endpoint(limit: int = 50, offset: int = 0):
+    """List all users with pagination"""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not configured")
+    
+    result = await list_users(limit, offset)
+    return result
+
+@router.put("/users/{wa_id}")
+async def update_user_endpoint(wa_id: str, name: str):
+    """Update user name"""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not configured")
+    
+    user = await update_user_name(wa_id, name)
+    if user:
+        return user
+    else:
+        raise HTTPException(status_code=404, detail="User not found") 

config.py

@@ -0,0 +1,30 @@
+import os
+from supabase import create_client, Client
+from langchain_openai import ChatOpenAI
+
+# --- Environment Variables ---
+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 and SUPABASE_URL.strip() and SUPABASE_KEY.strip():
+    try:
+        supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
+        print("Supabase client initialized successfully")
+    except Exception as e:
+        print(f"Warning: Failed to initialize Supabase client: {e}")
+        supabase = None
+else:
+    print("Warning: Supabase credentials not set. Database functionality will be limited.")
+
+# --- OpenAI Client Setup ---
+llm = ChatOpenAI(openai_api_key=OPENAI_API_KEY, model="gpt-4o-mini")
+
+# Initialize LLM only if API key is available
+if not OPENAI_API_KEY:
+    print("Warning: OPENAI_API_KEY not set. AI functionality will be limited.") 

database.py

@@ -0,0 +1,83 @@
+from datetime import datetime
+from config import supabase
+
+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}")
+
+async def get_user(wa_id: str):
+    """Get user by WhatsApp ID"""
+    if not supabase:
+        return None
+    
+    try:
+        response = supabase.table("users").select("*").eq("wa_id", wa_id).execute()
+        return response.data[0] if response.data else None
+    except Exception as e:
+        print(f"Error getting user: {e}")
+        return None
+
+async def list_users(limit: int = 50, offset: int = 0):
+    """List all users with pagination"""
+    if not supabase:
+        return {"users": [], "count": 0}
+    
+    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}")
+        return {"users": [], "count": 0}
+
+async def update_user_name(wa_id: str, name: str):
+    """Update user name"""
+    if not supabase:
+        return None
+    
+    try:
+        response = supabase.table("users").update({
+            "name": name,
+            "updated_at": datetime.utcnow().isoformat()
+        }).eq("wa_id", wa_id).execute()
+        
+        return response.data[0] if response.data else None
+    except Exception as e:
+        print(f"Error updating user: {e}")
+        return None 

main.py

@@ -1,152 +1,23 @@
-import os
-from fastapi import FastAPI, Request, HTTPException, Query
-from fastapi.responses import PlainTextResponse, JSONResponse
-import httpx
-from openai import OpenAI
-from pydantic import BaseModel
-from typing import Optional
-from langgraph.graph import StateGraph, END
-from langchain_core.runnables import RunnableLambda
-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
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
 
-# --- App and Config ---
-app = FastAPI()
-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", "")
+# Import our modular components
+from config import supabase
+from database import get_or_create_user, update_user_activity
+from whatsapp import send_whatsapp_message
+from ai_chat import process_message
+from api_routes import router
 
-# --- Supabase Client Setup ---
-supabase: Client = None
-if SUPABASE_URL and SUPABASE_KEY and SUPABASE_URL.strip() and SUPABASE_KEY.strip():
-    try:
-        supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
-        print("Supabase client initialized successfully")
-    except Exception as e:
-        print(f"Warning: Failed to initialize Supabase client: {e}")
-        supabase = None
-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")
-
-# Simple in-memory chat history (no deprecation warnings)
-chat_history = []
-
-# Initialize LLM only if API key is available
-if not OPENAI_API_KEY:
-    print("Warning: OPENAI_API_KEY not set. AI functionality will be limited.")
-
-# --- 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})
-    
-    # Keep only last 6 messages for context
-    recent_messages = chat_history[-6:] if len(chat_history) > 6 else chat_history
-    
-    # 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:
-            return {"response": "Sorry, AI chat is not available. Please check your OpenAI API key configuration."}
-        
-        response = llm.invoke(messages)
-        
-        # Add AI response to history
-        chat_history.append({"role": "assistant", "content": response.content})
-        
-        return {"response": response.content}
-    except Exception as e:
-        print(f"Error in chat_with_memory: {e}")
-        return {"response": "Sorry, something went wrong: " + str(e)}
-
-# --- Build LangGraph ---
-from typing import TypedDict
+# --- FastAPI App Setup ---
+app = FastAPI(title="PropAgent", description="WhatsApp AI Agent with Supabase integration")
 
-class ChatState(TypedDict):
-    user_message: str
-    response: str
-    user_info: dict
+# Include all API routes
+app.include_router(router)
 
-graph = StateGraph(ChatState)
-graph.add_node("chat", RunnableLambda(chat_with_memory))
-graph.set_entry_point("chat")
-graph.add_edge("chat", END)
-chat_graph = graph.compile()
-
-# --- Webhook Verification ---
-@app.get("/webhook")
-def verify_webhook(
-    hub_mode: str = Query(None, alias="hub.mode"),
-    hub_token: str = Query(None, alias="hub.verify_token"),
-    hub_challenge: str = Query(None, alias="hub.challenge")
-):
-    if hub_mode == "subscribe" and hub_token == VERIFY_TOKEN:
-        return PlainTextResponse(hub_challenge)
-    raise HTTPException(status_code=403, detail="Invalid token")
-
-# --- Webhook Receiver ---
+# --- WhatsApp Webhook Handler ---
 @app.post("/webhook")
 async def receive_message(req: Request):
+    """Main webhook endpoint for receiving WhatsApp messages"""
     body = await req.json()
     print("Incoming webhook:", body)
 
@@ -154,6 +25,7 @@ async def receive_message(req: Request):
         change = body["entry"][0]["changes"][0]["value"]
         contacts = change.get("contacts")
         messages = change.get("messages")
+        
         if not contacts or not messages:
             return JSONResponse({"status": "ignored", "reason": "no contacts/messages"})
 
@@ -171,12 +43,11 @@ async def receive_message(req: Request):
             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
-            })
+            ai_response = await process_message(user_message, user_info)
+            
+            # Send response back to WhatsApp
+            await send_whatsapp_message(wa_id, ai_response)
             
-            await send_whatsapp_message(wa_id, ai_result["response"])
             return JSONResponse({"status": "replied", "user_id": wa_id})
 
     except Exception as e:
@@ -185,102 +56,15 @@ async def receive_message(req: Request):
 
     return JSONResponse({"status": "ignored"})
 
-# --- WhatsApp Sender ---
-async def send_whatsapp_message(wa_id: str, message: str):
-    url = f"https://graph.facebook.com/v18.0/{PHONE_NUMBER_ID}/messages"
-    headers = {
-        "Authorization": f"Bearer {WHATSAPP_API_TOKEN}",
-        "Content-Type": "application/json"
-    }
-    payload = {
-        "messaging_product": "whatsapp",
-        "to": wa_id,
-        "type": "text",
-        "text": {"body": message}
-    }
-    try:
-        resp = await httpx.post(url, headers=headers, json=payload)
-        print(f"Sent message → {resp.status_code}: {resp.text}")
-    except Exception as e:
-        print(f"Failed to send message: {e}")
-
-# --- Optional Direct Chat Endpoint ---
-class ChatRequest(BaseModel):
-    message: str
-    model: Optional[str] = "gpt-4o-mini"
-    max_tokens: Optional[int] = 1500
-
-class ChatResponse(BaseModel):
-    response: str
-    model: str
-    tokens_used: Optional[int] = None
-
-@app.post("/chat", response_model=ChatResponse)
-async def chat_with_ai(request: ChatRequest):
-    ai_result = await chat_graph.ainvoke({"user_message": request.message})
-    return ChatResponse(response=ai_result["response"], model=request.model)
-
-# --- Health ---
-@app.get("/ping")
-def ping():
-    return {"pong": True}
-
-@app.get("/health")
-def health_check():
-    status = {
-        "api": "healthy",
-        "whatsapp": "configured" if WHATSAPP_API_TOKEN else "not configured",
-        "openai": "configured" if OPENAI_API_KEY else "not configured",
-        "supabase": "configured" if supabase else "not configured"
-    }
-    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")
+# --- Application Startup Event ---
+@app.on_event("startup")
+async def startup_event():
+    """Log startup information"""
+    print("=" * 50)
+    print("PropAgent WhatsApp AI Agent Starting...")
+    print(f"Supabase: {'✅ Connected' if supabase else '❌ Not configured'}")
+    print("=" * 50)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

whatsapp.py

@@ -0,0 +1,23 @@
+import httpx
+from config import PHONE_NUMBER_ID, WHATSAPP_API_TOKEN
+
+async def send_whatsapp_message(wa_id: str, message: str):
+    """Send a message via WhatsApp Business API"""
+    url = f"https://graph.facebook.com/v18.0/{PHONE_NUMBER_ID}/messages"
+    headers = {
+        "Authorization": f"Bearer {WHATSAPP_API_TOKEN}",
+        "Content-Type": "application/json"
+    }
+    payload = {
+        "messaging_product": "whatsapp",
+        "to": wa_id,
+        "type": "text",
+        "text": {"body": message}
+    }
+    try:
+        resp = await httpx.post(url, headers=headers, json=payload)
+        print(f"Sent message → {resp.status_code}: {resp.text}")
+        return resp.status_code == 200
+    except Exception as e:
+        print(f"Failed to send message: {e}")
+        return False