langgraph setup

main.py

@@ -5,31 +5,55 @@ 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.memory import ConversationBufferMemory
+from langchain_openai import ChatOpenAI
 
+# --- 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", "")
 
-# Initialize OpenAI client
-openai_client = None
-if OPENAI_API_KEY:
-    openai_client = OpenAI(api_key=OPENAI_API_KEY)
+# --- OpenAI Client Setup ---
+llm = ChatOpenAI(openai_api_key=OPENAI_API_KEY, model="gpt-4o-mini")
+memory = ConversationBufferMemory(return_messages=True, memory_key="chat_history")
 
-# Pydantic model for chat requests
-class ChatRequest(BaseModel):
-    message: str
-    model: Optional[str] = "gpt-4o-mini"  # Using the cheapest OpenAI model
-    max_tokens: Optional[int] = 150
+# 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.")
 
-# Pydantic model for chat responses
-class ChatResponse(BaseModel):
-    response: str
-    model: str
-    tokens_used: Optional[int] = None
+# --- LangGraph Setup ---
+def chat_with_memory(state):
+    user_message = state["user_message"]
+    memory.chat_memory.add_user_message(user_message)
+
+    messages = memory.chat_memory.messages[-6:]  # Use last few messages
+    messages = [{"role": msg.type, "content": msg.content} for msg in messages]
+
+    messages.insert(0, {"role": "system", "content": "You are a helpful and concise assistant."})
 
+    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)
+        memory.chat_memory.add_ai_message(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 ---
+graph = StateGraph()
+graph.add_node("chat", RunnableLambda(chat_with_memory))
+graph.set_entry_point("chat")
+graph.set_finish_point("chat")
+chat_graph = graph.compile()
+
+# --- Webhook Verification ---
 @app.get("/webhook")
 def verify_webhook(
     hub_mode: str = Query(None, alias="hub.mode"),
@@ -40,6 +64,7 @@ def verify_webhook(
         return PlainTextResponse(hub_challenge)
     raise HTTPException(status_code=403, detail="Invalid token")
 
+# --- Webhook Receiver ---
 @app.post("/webhook")
 async def receive_message(req: Request):
     body = await req.json()
@@ -56,14 +81,9 @@ async def receive_message(req: Request):
         msg = messages[0]
 
         if msg.get("type") == "text":
-            # Get the user's message
             user_message = msg.get("text", {}).get("body", "")
-            
-            # Generate AI response using OpenAI
-            ai_response = await generate_ai_response(user_message)
-            
-            # Send the AI response back to WhatsApp
-            await send_whatsapp_message(wa_id, ai_response)
+            ai_result = await chat_graph.ainvoke({"user_message": user_message})
+            await send_whatsapp_message(wa_id, ai_result["response"])
             return JSONResponse({"status": "replied"})
 
     except Exception as e:
@@ -72,58 +92,7 @@ async def receive_message(req: Request):
 
     return JSONResponse({"status": "ignored"})
 
-async def generate_ai_response(user_message: str) -> str:
-    """Generate AI response using OpenAI API"""
-    if not openai_client:
-        return "Sorry, AI chat is not available. Please check your OpenAI API key configuration."
-    
-    try:
-        response = openai_client.chat.completions.create(
-            model="gpt-4o-mini",
-            messages=[
-                {"role": "system", "content": "You are a helpful assistant. Keep your responses concise and friendly."},
-                {"role": "user", "content": user_message}
-            ],
-            max_tokens=150,
-            temperature=0.7
-        )
-        
-        ai_response = response.choices[0].message.content
-        return ai_response if ai_response else "I'm sorry, I couldn't generate a response."
-        
-    except Exception as e:
-        print(f"Error generating AI response: {e}")
-        return "Sorry, I'm having trouble processing your request right now."
-
-@app.post("/chat", response_model=ChatResponse)
-async def chat_with_ai(request: ChatRequest):
-    """Basic chat endpoint for direct API calls"""
-    if not openai_client:
-        raise HTTPException(status_code=500, detail="OpenAI API key not configured")
-    
-    try:
-        response = openai_client.chat.completions.create(
-            model=request.model,
-            messages=[
-                {"role": "system", "content": "You are a helpful assistant. Keep your responses concise and friendly."},
-                {"role": "user", "content": request.message}
-            ],
-            max_tokens=request.max_tokens,
-            temperature=0.7
-        )
-        
-        ai_response = response.choices[0].message.content
-        usage = response.usage
-        
-        return ChatResponse(
-            response=ai_response,
-            model=request.model,
-            tokens_used=usage.total_tokens if usage else None
-        )
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error generating response: {str(e)}")
-
+# --- 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 = {
@@ -142,13 +111,29 @@ async def send_whatsapp_message(wa_id: str, message: str):
     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] = 150
+
+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():
-    """Health check endpoint to verify API connectivity"""
     status = {
         "api": "healthy",
         "whatsapp": "configured" if WHATSAPP_API_TOKEN else "not configured",

requirements.txt

@@ -2,4 +2,8 @@ fastapi
 uvicorn
 python-dotenv
 httpx
-openai 
+openai
+langchain
+langchain-openai
+langgraph
+langchain-core