Update app.py

app.py

@@ -226,7 +226,7 @@
 import os
 import time
 import requests
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Request, HTTPException
 from fastapi.responses import HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
@@ -236,6 +236,11 @@ from simple_salesforce import Salesforce, SalesforceLogin
 import uuid
 import datetime
 import json
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 # Define Pydantic model for incoming request body
 class MessageRequest(BaseModel):
@@ -244,10 +249,10 @@ class MessageRequest(BaseModel):
 # Initialize FastAPI app
 app = FastAPI()
 
-# Allow CORS requests from any domain
+# Allow CORS requests from any domain (not recommended for production)
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
+    allow_origins=["*"],  # Allows all origins
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -257,32 +262,49 @@ app.add_middleware(
 app.mount("/static", StaticFiles(directory="static"), name="static")
 templates = Jinja2Templates(directory="static")
 
-# Configure ChatGroq API
-CHATGROQ_API_URL = "https://api.chatgroq.com/v1/chat/completions"  # Replace with actual endpoint
+# Validate environment variables
+required_env_vars = ["CHATGROQ_API_KEY", "username", "password", "security_token", "domain"]
+for var in required_env_vars:
+    if not os.getenv(var):
+        logger.error(f"Environment variable {var} is not set")
+        raise ValueError(f"Environment variable {var} is not set")
+
+# Configure ChatGroq API (replace with actual endpoint and model)
+CHATGROQ_API_URL = os.getenv("CHATGROQ_API_URL", "https://api.example.com/v1/chat/completions")  # Update with correct endpoint
 CHATGROQ_API_KEY = os.getenv("CHATGROQ_API_KEY")
+CHATGROQ_MODEL = os.getenv("CHATGROQ_MODEL", "default-model")  # Update with correct model
 
 # Salesforce credentials
 username = os.getenv("username")
 password = os.getenv("password")
 security_token = os.getenv("security_token")
-domain = os.getenv("domain")  # Using sandbox environment
-session_id, sf_instance = SalesforceLogin(username=username, password=password, security_token=security_token, domain=domain)
-sf = Salesforce(instance=sf_instance, session_id=session_id)
+domain = os.getenv("domain")  # e.g., 'test' for sandbox
+
+# Initialize Salesforce connection
+try:
+    session_id, sf_instance = SalesforceLogin(
+        username=username, password=password, security_token=security_token, domain=domain
+    )
+    sf = Salesforce(instance=sf_instance, session_id=session_id)
+except Exception as e:
+    logger.error(f"Failed to connect to Salesforce: {e}")
+    raise HTTPException(status_code=500, detail="Salesforce connection failed")
 
 # Chat history
 chat_history = []
 current_chat_history = []
+MAX_HISTORY_SIZE = 100  # Limit chat history size
 
 def handle_query(query):
     # Prepare context from chat history
     context_str = ""
-    for past_query, response in reversed(current_chat_history):
+    for past_query, response in reversed(current_chat_history[-10:]):  # Limit context to last 10 exchanges
         if past_query.strip():
             context_str += f"User asked: '{past_query}'\nBot answered: '{response}'\n"
 
-    # Construct the prompt for ChatGroq
+    # Construct the prompt
     prompt = f"""
-    You are the Clara Redfernstech chatbot. Your goal is to provide accurate, professional, and helpful answers to user queries based on the company's data. Always ensure your responses are clear and concise. Give response within 10-15 words only.
+    You are the Clara Redfernstech chatbot. Provide accurate, professional answers in 10-15 words.
     
     Context:
     {context_str}
@@ -297,21 +319,24 @@ def handle_query(query):
         "Content-Type": "application/json",
     }
     payload = {
-        "model": "meta-llama/llama-4-maverick-17b-128e-instruct",  # Replace with the actual model name
+        "model": CHATGROQ_MODEL,  # Use configured model
         "messages": [{"role": "user", "content": prompt}],
-        "max_tokens": 50,  # Adjust as needed
+        "max_tokens": 50,
         "temperature": 0.1,
     }
 
     try:
-        response = requests.post(CHATGROQ_API_URL, headers=headers, json=payload)
+        response = requests.post(CHATGROQ_API_URL, headers=headers, json=payload, timeout=10)
+        response.raise_for_status()  # Raise exception for bad status codes
         response_data = response.json()
         response_text = response_data["choices"][0]["message"]["content"].strip()
-    except Exception as e:
-        print(f"Error querying ChatGroq: {e}")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error querying ChatGroq API: {e}")
         response_text = "Sorry, I couldn't find an answer."
 
     # Update chat history
+    if len(current_chat_history) >= MAX_HISTORY_SIZE:
+        current_chat_history.pop(0)  # Remove oldest entry
     current_chat_history.append((query, response_text))
     return response_text
 
@@ -322,35 +347,48 @@ async def load_chat(request: Request, id: str):
 @app.post("/hist/")
 async def save_chat_history(history: dict):
     user_id = history.get('userId')
-    if user_id is None:
-        return {"error": "userId is required"}, 400
+    if not user_id:
+        logger.error("userId is missing in history request")
+        raise HTTPException(status_code=400, detail="userId is required")
 
     hist = ''.join([f"'{entry['sender']}: {entry['message']}'\n" for entry in history['history']])
-    hist = "You are a Redfernstech summarize model. Your aim is to use this conversation to identify user interests solely based on that conversation: " + hist
+    hist = "You are a Redfernstech summarize model. Identify user interests from this conversation: " + hist
 
     try:
         sf.Lead.update(user_id, {'Description': hist})
+        logger.info(f"Chat history updated for user {user_id}")
     except Exception as e:
-        return {"error": f"Failed to update lead: {str(e)}"}, 500
+        logger.error(f"Failed to update lead: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to update lead: {str(e)}")
     
     return {"summary": hist, "message": "Chat history saved"}
 
 @app.post("/webhook")
 async def receive_form_data(request: Request):
-    form_data = await request.json()
-    first_name, last_name = split_name(form_data['name'])
+    try:
+        form_data = await request.json()
+    except json.JSONDecodeError:
+        logger.error("Invalid JSON in webhook request")
+        raise HTTPException(status_code=400, detail="Invalid JSON")
+
+    first_name, last_name = split_name(form_data.get('name', ''))
     data = {
         'FirstName': first_name,
         'LastName': last_name,
         'Description': 'hii',  # Static description
-        'Company': form_data['company'],  # Assuming company is available in form_data
-        'Phone': form_data['phone'].strip(),  # Phone from form data
-        'Email': form_data['email'],  # Email from form data
+        'Company': form_data.get('company', ''),
+        'Phone': form_data.get('phone', '').strip(),
+        'Email': form_data.get('email', ''),
     }
-    a = sf.Lead.create(data)
-    unique_id = a['id']
-    print("Received form data:", form_data)
-    return JSONResponse({"id": unique_id})
+
+    try:
+        result = sf.Lead.create(data)
+        unique_id = result['id']
+        logger.info(f"Lead created with ID {unique_id}")
+        return JSONResponse({"id": unique_id})
+    except Exception as e:
+        logger.error(f"Failed to create lead: {e}")
+        raise HTTPException(status_code=500, detail="Failed to create lead: {str(e)}")
 
 @app.post("/chat/")
 async def chat(request: MessageRequest):
@@ -362,7 +400,10 @@ async def chat(request: MessageRequest):
         "response": response,
         "timestamp": datetime.datetime.now().isoformat()
     }
+    if len(chat_history) >= MAX_HISTORY_SIZE:
+        chat_history.pop(0)  # Remove oldest entry
     chat_history.append(message_data)
+    logger.info(f"Chat message processed: {message}")
     return {"response": response}
 
 @app.get("/")
@@ -372,12 +413,8 @@ def read_root():
 def split_name(full_name):
     words = full_name.strip().split()
     if len(words) == 1:
-        first_name = ''
-        last_name = words[0]
+        return '', words[0]
     elif len(words) == 2:
-        first_name = words[0]
-        last_name = words[1]
+        return words[0], words[1]
     else:
-        first_name = words[0]
-        last_name = ' '.join(words[1:])
-    return first_name, last_name
+        return words[0], ' '.join(words[1:])