app.py

# import os
# import time
# from fastapi import FastAPI,Request
# from fastapi.responses import HTMLResponse
# from fastapi.staticfiles import StaticFiles
# from llama_index.core import StorageContext, load_index_from_storage, VectorStoreIndex, SimpleDirectoryReader, ChatPromptTemplate, Settings
# from llama_index.embeddings.huggingface import HuggingFaceEmbedding
# from pydantic import BaseModel
# from fastapi.responses import JSONResponse
# import uuid  # for generating unique IDs
# import datetime
# from fastapi.middleware.cors import CORSMiddleware
# from fastapi.templating import Jinja2Templates
# from huggingface_hub import InferenceClient
# import json
# import re
# from gradio_client import Client
# from simple_salesforce import Salesforce, SalesforceLogin
# from llama_index.llms.huggingface import HuggingFaceLLM
# # from llama_index.llms.huggingface import HuggingFaceInferenceAPI


# # Define Pydantic model for incoming request body
# class MessageRequest(BaseModel):
#     message: str
# repo_id = "meta-llama/Meta-Llama-3-8B-Instruct"
# llm_client = InferenceClient(
#     model=repo_id,
#     token=os.getenv("HF_TOKEN"),
# )


# os.environ["HF_TOKEN"] = os.getenv("HF_TOKEN")
# 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)

#     # Create Salesforce object
# sf = Salesforce(instance=sf_instance, session_id=session_id)

# app = FastAPI()


# @app.middleware("http")
# async def add_security_headers(request: Request, call_next):
#     response = await call_next(request)
#     response.headers["Content-Security-Policy"] = "frame-ancestors *; frame-src *; object-src *;"
#     response.headers["X-Frame-Options"] = "ALLOWALL"
#     return response


# # Allow CORS requests from any domain
# app.add_middleware(
#     CORSMiddleware,
#     allow_origins=["*"],
#     allow_credentials=True,
#     allow_methods=["*"],
#     allow_headers=["*"],
# )




# @app.get("/favicon.ico")
# async def favicon():
#     return HTMLResponse("")  # or serve a real favicon if you have one


# app.mount("/static", StaticFiles(directory="static"), name="static")

# templates = Jinja2Templates(directory="static")
# # Configure Llama index settings
# Settings.llm = HuggingFaceLLM(
#     model_name="meta-llama/Meta-Llama-3-8B-Instruct",
#     tokenizer_name="meta-llama/Meta-Llama-3-8B-Instruct",
#     context_window=3000,
#     token=os.getenv("HF_TOKEN"),
#     max_new_tokens=512,
#     generate_kwargs={"temperature": 0.1},
# )

# Settings.embed_model = HuggingFaceEmbedding(
#     model_name="BAAI/bge-small-en-v1.5"
# )

# PERSIST_DIR = "db"
# PDF_DIRECTORY = 'data'

# # Ensure directories exist
# os.makedirs(PDF_DIRECTORY, exist_ok=True)
# os.makedirs(PERSIST_DIR, exist_ok=True)
# chat_history = []
# current_chat_history = []
# def data_ingestion_from_directory():
#     documents = SimpleDirectoryReader(PDF_DIRECTORY).load_data()
#     storage_context = StorageContext.from_defaults()
#     index = VectorStoreIndex.from_documents(documents)
#     index.storage_context.persist(persist_dir=PERSIST_DIR)

# def initialize():
#     start_time = time.time()
#     data_ingestion_from_directory()  # Process PDF ingestion at startup
#     print(f"Data ingestion time: {time.time() - start_time} seconds")
# def split_name(full_name):
#     # Split the name by spaces
#     words = full_name.strip().split()
    
#     # Logic for determining first name and last name
#     if len(words) == 1:
#         first_name = ''
#         last_name = words[0]
#     elif len(words) == 2:
#         first_name = words[0]
#         last_name = words[1]
#     else:
#         first_name = words[0]
#         last_name = ' '.join(words[1:])
    
#     return first_name, last_name

# initialize()  # Run initialization tasks


# def handle_query(query):
#     chat_text_qa_msgs = [
#         (
#             "user",
#             """
#             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       
#             {context_str}
#             Question:
#             {query_str}
#             """
#         )
#     ]
#     text_qa_template = ChatPromptTemplate.from_messages(chat_text_qa_msgs)
    
#     storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR)
#     index = load_index_from_storage(storage_context)
#     context_str = ""
#     for past_query, response in reversed(current_chat_history):
#         if past_query.strip():
#             context_str += f"User asked: '{past_query}'\nBot answered: '{response}'\n"

    
#     query_engine = index.as_query_engine(text_qa_template=text_qa_template, context_str=context_str)
#     answer = query_engine.query(query)

#     if hasattr(answer, 'response'):
#         response=answer.response
#     elif isinstance(answer, dict) and 'response' in answer:
#         response =answer['response']
#     else:
#         response ="Sorry, I couldn't find an answer."
#     current_chat_history.append((query, response))
#     return response
# @app.get("/ch/{id}", response_class=HTMLResponse)
# async def load_chat(request: Request, id: str):
#     return templates.TemplateResponse("index.html", {"request": request, "user_id": id})
# # Route to save chat history
# @app.post("/hist/")
# async def save_chat_history(history: dict):
#     # Check if 'userId' is present in the incoming dictionary
#     user_id = history.get('userId')
#     print(user_id)

#     # Ensure user_id is defined before proceeding
#     if user_id is None:
#         return {"error": "userId is required"}, 400

#     # Construct the chat history string
#     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
#     print(hist)

#     # Get the summarized result from the client model
#     result = hist

#     try:
#         sf.Lead.update(user_id, {'Description': result})
#     except Exception as e:
#         return {"error": f"Failed to update lead: {str(e)}"}, 500
    
#     return {"summary": result, "message": "Chat history saved"}
# @app.post("/webhook")
# async def receive_form_data(request: Request):
#     form_data = await request.json()
#     # Log in to Salesforce
#     first_name, last_name = split_name(form_data['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
#     }
#     a=sf.Lead.create(data)
#     # Generate a unique ID (for tracking user)
#     unique_id = a['id']
    
#     # Here you can do something with form_data like saving it to a database
#     print("Received form data:", form_data)
    
#     # Send back the unique id to the frontend
#     return JSONResponse({"id": unique_id})

# @app.post("/chat/")
# async def chat(request: MessageRequest):
#     message = request.message  # Access the message from the request body
#     response = handle_query(message)  # Process the message
#     message_data = {
#         "sender": "User",
#         "message": message,
#         "response": response,
#         "timestamp": datetime.datetime.now().isoformat()
#     }
#     chat_history.append(message_data)
#     return {"response": response}
# @app.get("/")
# def read_root():
#     return {"message": "Welcome to the API"}

import os
import datetime
import json
import logging
from fastapi import FastAPI, Request, HTTPException
from fastapi.responses import HTMLResponse, JSONResponse
from fastapi.staticfiles import StaticFiles
from pydantic import BaseModel
from fastapi.middleware.cors import CORSMiddleware
from fastapi.templating import Jinja2Templates
from simple_salesforce import Salesforce, SalesforceLogin
from langchain_groq import ChatGroq
from langchain_core.prompts import ChatPromptTemplate
from llama_index.core import StorageContext, VectorStoreIndex, SimpleDirectoryReader, Settings, load_index_from_storage
from llama_index.embeddings.huggingface import HuggingFaceEmbedding

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class MessageRequest(BaseModel):
    message: str

app = FastAPI()

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

app.mount("/static", StaticFiles(directory="static"), name="static")
templates = Jinja2Templates(directory="static")

required_env_vars = ["CHATGROQ_API_KEY", "username", "password", "security_token", "domain", "HF_TOKEN"]
for var in required_env_vars:
    if not os.getenv(var):
        logger.error(f"Missing environment variable: {var}")
        raise ValueError(f"Environment variable {var} is not set")

# LLM & Embedding Setup
GROQ_API_KEY = os.getenv("CHATGROQ_API_KEY")
llm = ChatGroq(model_name="llama3-8b-8192", api_key=GROQ_API_KEY, temperature=0.1, max_tokens=50)
Settings.embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5")

# Salesforce setup
sf = None
try:
    session_id, sf_instance = SalesforceLogin(
        username=os.getenv("username"),
        password=os.getenv("password"),
        security_token=os.getenv("security_token"),
        domain=os.getenv("domain")
    )
    sf = Salesforce(instance=sf_instance, session_id=session_id)
    logger.info("Salesforce connected.")
except Exception as e:
    logger.warning(f"Salesforce connection failed: {e}")

chat_history = []
current_chat_history = []
MAX_HISTORY_SIZE = 100

PDF_DIRECTORY = "data"
PERSIST_DIR = "db"
os.makedirs(PDF_DIRECTORY, exist_ok=True)
os.makedirs(PERSIST_DIR, exist_ok=True)

def data_ingestion_from_directory():
    try:
        documents = SimpleDirectoryReader(PDF_DIRECTORY).load_data()
        if not documents:
            logger.warning("No documents found in PDF_DIRECTORY")
            return
        storage_context = StorageContext.from_defaults()
        index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)
        index.storage_context.persist(persist_dir=PERSIST_DIR)
        logger.info("Data ingestion and embedding complete.")
    except Exception as e:
        logger.error(f"Data ingestion failed: {e}")
        raise HTTPException(status_code=500, detail="Data ingestion failed")

def initialize():
    try:
        data_ingestion_from_directory()
    except Exception as e:
        logger.error(f"Initialization error: {e}")
        raise HTTPException(status_code=500, detail="Startup initialization failed")

initialize()

def handle_query(query: str) -> str:
    chat_context = ""
    for past_query, response in reversed(current_chat_history[-10:]):
        chat_context += f"User: {past_query}\nBot: {response}\n"

    # Load index
    try:
        storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR)
        index = load_index_from_storage(storage_context)
        query_engine = index.as_query_engine(similarity_top_k=2)
        retrieved = query_engine.query(query)
        doc_context = getattr(retrieved, 'response', "No relevant documents found.")
    except Exception as e:
        logger.error(f"Retrieval error: {e}")
        doc_context = "No relevant documents found."

    # Prompt template
    prompt_template = ChatPromptTemplate.from_messages([
        ("system", """
You are a helpful and professional company chatbot. 
Answer user queries based on the provided document context and chat history. 
If you are unsure about the answer, politely respond with "I'm sorry, I don't know that yet."

Document Context:
{doc_context}

Chat History:
{chat_context}

Question:
{query}
        """)
    ])
    prompt = prompt_template.format(doc_context=doc_context, chat_context=chat_context, query=query)

    try:
        response = llm.invoke(prompt)
        response_text = response.content.strip()
        if "I'm sorry" not in response_text and len(response_text.strip()) < 3:
            response_text = "I'm sorry, I don't know that yet."
    except Exception as e:
        logger.error(f"Groq API Error: {e}")
        response_text = "I'm sorry, I don't know that yet."

    if len(current_chat_history) >= MAX_HISTORY_SIZE:
        current_chat_history.pop(0)
    current_chat_history.append((query, response_text))

    return response_text

@app.get("/ch/{id}", response_class=HTMLResponse)
async def load_chat(request: Request, id: str):
    return templates.TemplateResponse("index.html", {"request": request, "user_id": id})

@app.post("/hist/")
async def save_chat_history(history: dict):
    if not sf:
        return JSONResponse({"error": "Salesforce not connected"}, status_code=503)

    user_id = history.get('userId')
    if not user_id:
        return JSONResponse({"error": "userId missing"}, status_code=400)

    hist = '\n'.join([f"{entry['sender']}: {entry['message']}" for entry in history.get("history", [])])
    summary = "This is the chat summary: " + hist

    try:
        sf.Lead.update(user_id, {'Description': summary})
        return {"summary": summary, "message": "Chat history saved"}
    except Exception as e:
        return JSONResponse({"error": str(e)}, status_code=500)

@app.post("/webhook")
async def receive_form_data(request: Request):
    if not sf:
        return JSONResponse({"error": "Salesforce not connected"}, status_code=503)

    try:
        form_data = await request.json()
    except json.JSONDecodeError:
        return JSONResponse({"error": "Invalid JSON"}, status_code=400)

    first_name, last_name = split_name(form_data.get("name", ""))
    lead_data = {
        "FirstName": first_name,
        "LastName": last_name,
        "Company": form_data.get("company", ""),
        "Phone": form_data.get("phone", ""),
        "Email": form_data.get("email", ""),
        "Description": "Lead from website form"
    }

    try:
        result = sf.Lead.create(lead_data)
        return {"id": result.get("id")}
    except Exception as e:
        return JSONResponse({"error": str(e)}, status_code=500)

@app.post("/chat/")
async def chat(request: MessageRequest):
    message = request.message
    response = handle_query(message)
    chat_entry = {
        "sender": "User",
        "message": message,
        "response": response,
        "timestamp": datetime.datetime.now().isoformat()
    }
    if len(chat_history) >= MAX_HISTORY_SIZE:
        chat_history.pop(0)
    chat_history.append(chat_entry)
    return {"response": response}

@app.get("/health")
async def health_check():
    try:
        storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR)
        load_index_from_storage(storage_context)
        return {"status": "healthy"}
    except Exception as e:
        return {"status": "unhealthy", "error": str(e)}

@app.get("/")
def read_root():
    return {"message": "Welcome to the company chatbot API"}

def split_name(full_name):
    parts = full_name.strip().split()
    if len(parts) == 1:
        return '', parts[0]
    return parts[0], ' '.join(parts[1:])