Update app.py

app.py

@@ -1,37 +1,33 @@
 import os
 import time
 from fastapi import FastAPI, Request
-from fastapi.responses import HTMLResponse
+from fastapi.responses import HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
-from llama_index.core import StorageContext, load_index_from_storage, VectorStoreIndex, SimpleDirectoryReader, ChatPromptTemplate, Settings
-from llama_index.llms.huggingface import HuggingFaceInferenceAPI
+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 uuid
+import datetime
 import json
 import re
 from deep_translator import GoogleTranslator
-
-
+import ollama  # Import Ollama for inference
 
 # Define Pydantic model for incoming request body
 class MessageRequest(BaseModel):
     message: str
     language: str
 
-repo_id = "meta-llama/Meta-Llama-3-8B"
-llm_client = InferenceClient(
-    model=repo_id,
-    token=os.getenv("HF_TOKEN"),
-)
-
-os.environ["HF_TOKEN"] = os.getenv("HF_TOKEN")
-
+# Initialize FastAPI app
 app = FastAPI()
 
 @app.middleware("http")
@@ -50,29 +46,16 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-@app.get("/favicon.ico")
-async def favicon():
-    return HTMLResponse("")  # or serve a real favicon if you have one
-
+# Static files setup
 app.mount("/static", StaticFiles(directory="static"), name="static")
-
 templates = Jinja2Templates(directory="static")
 
-# Configure Llama index settings
-Settings.llm = HuggingFaceInferenceAPI(
-    model_name="meta-llama/Meta-Llama-3-8B",
-    tokenizer_name="meta-llama/Meta-Llama-3-8B",
-    context_window=3000,
-    token=os.getenv("HF_TOKEN"),
-    max_new_tokens=512,
-    generate_kwargs={"temperature": 0.3},
-)
-Settings.embed_model = HuggingFaceEmbedding(
-    model_name="BAAI/bge-small-en-v1.5"
-)
+# Configure LlamaIndex settings
+Settings.llm = None  # No need for Hugging Face anymore
+Settings.embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5")
 
 PERSIST_DIR = "db"
-PDF_DIRECTORY = 'data'
+PDF_DIRECTORY = "data"
 
 # Ensure directories exist
 os.makedirs(PDF_DIRECTORY, exist_ok=True)
@@ -91,31 +74,15 @@ def initialize():
     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):
+    """Handles queries using Ollama's local inference"""
     chat_text_qa_msgs = [
         (
             "user",
             """
-            You are the Hotel voice chatbot and your name is hotel helper. Your goal is to provide accurate, professional, and helpful answers to user queries based on the hotel's data. Always ensure your responses are clear and concise. Give response within 10-15 words only.
+            You are the Hotel voice chatbot, and your name is Hotel Helper. Your goal is to provide accurate, professional, and helpful answers based on hotel data. Always keep responses concise (10-15 words max).
             {context_str}
             Question:
             {query_str}
@@ -123,63 +90,63 @@ def handle_query(query):
         )
     ]
     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)
+
     print(query)
-    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
+    
+    try:
+        response = ollama.chat(model="llama3", messages=[{"role": "user", "content": query}])  # Using Ollama
+        response_text = response.get("message", {}).get("content", "Sorry, I couldn't find an answer.")
+    except Exception as e:
+        print(f"Ollama Error: {e}")
+        response_text = "Sorry, something went wrong with the AI model."
+
+    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.get("/voice/{id}", response_class=HTMLResponse)
-async def load_chat(request: Request, id: str):
+async def load_voice_chat(request: Request, id: str):
     return templates.TemplateResponse("voice.html", {"request": request, "user_id": id})
 
-
-
 @app.post("/chat/")
 async def chat(request: MessageRequest):
-    message = request.message  # Access the message from the request body
+    """Handles chat requests and translates responses if needed."""
+    message = request.message
     language = request.language
     language_code = request.language.split('-')[0]
+    
     response = handle_query(message)  # Process the message
-    response1 = response
+    
     try:
-        translator = GoogleTranslator(source='en', target=language_code)  # Translate to Tamil
-        response1 = translator.translate(response)
-        #response1 = translator.translate(response, dest=language_code).text
-        print(response1)
+        translator = GoogleTranslator(source="en", target=language_code)
+        response_translated = translator.translate(response)
     except Exception as e:
-        # Handle translation errors
         print(f"Translation error: {e}")
-        translated_response = "Sorry, I couldn't translate the response."
-    print(f"Selected Language: {language}")
+        response_translated = "Sorry, I couldn't translate the response."
+
     message_data = {
         "sender": "User",
         "message": message,
         "response": response,
-        "timestamp": datetime.datetime.now().isoformat()
+        "timestamp": datetime.datetime.now().isoformat(),
     }
     chat_history.append(message_data)
-    return {"response": response1}
+
+    return {"response": response_translated}
 
 @app.get("/")
 def read_root(request: Request):
     return templates.TemplateResponse("home.html", {"request": request})
-