Update app.py

app.py

@@ -8,6 +8,8 @@ from backend.semantic_search import table, retriever
 import numpy as np
 from time import perf_counter
 import requests
+from jinja2 import Environment, FileSystemLoader
+from pathlib import Path
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)
@@ -23,8 +25,8 @@ else:
     os.environ["GROQ_API_KEY"] = api_key
 
 # Bhashini API setup
-bhashini_api_key = os.getenv("API_KEY")
-bhashini_user_id = os.getenv("USER_ID")
+bhashini_api_key = os.getenv("API_KEY", "").strip()
+bhashini_user_id = os.getenv("USER_ID", "").strip()
 
 def bhashini_translate(text: str, from_code: str = "en", to_code: str = "hi") -> dict:
     """Translates text from source language to target language using the Bhashini API."""
@@ -42,6 +44,11 @@ def bhashini_translate(text: str, from_code: str = "en", to_code: str = "hi") ->
         "userID": bhashini_user_id,
         "ulcaApiKey": bhashini_api_key
     }
+    for key, value in headers.items():
+        if not isinstance(value, str) or '\n' in value or '\r' in value:
+            print(f"Invalid header value for {key}: {value}")
+            return {"status_code": 400, "message": f"Invalid header value for {key}", "translated_content": None}
+
     payload = {
         "pipelineTasks": [{"taskType": "translation", "config": {"language": {"sourceLanguage": from_code, "targetLanguage": to_code}}}],
         "pipelineRequestConfig": {"pipelineId": "64392f96daac500b55c543cd"}
@@ -56,7 +63,7 @@ def bhashini_translate(text: str, from_code: str = "en", to_code: str = "hi") ->
 
     print('Initial request successful, processing response...')
     response_data = response.json()
-    print('Full response data:', response_data)  # Debug the full response
+    print('Full response data:', response_data)
     if "pipelineInferenceAPIEndPoint" not in response_data or "callbackUrl" not in response_data["pipelineInferenceAPIEndPoint"]:
         print('Unexpected response structure:', response_data)
         return {"status_code": 400, "message": "Unexpected API response structure", "translated_content": None}
@@ -105,6 +112,12 @@ agent = Agent(
     markdown=True
 )
 
+# Set up Jinja2 environment
+proj_dir = Path(__file__).parent
+env = Environment(loader=FileSystemLoader(proj_dir / 'templates'))
+template = env.get_template('template.j2')  # For document context
+template_html = env.get_template('template_html.j2')  # For HTML output
+
 # Response Generation Function
 def retrieve_and_generate_response(query, cross_encoder_choice, history=None):
     """Generate response using semantic search and LLM"""
@@ -112,7 +125,7 @@ def retrieve_and_generate_response(query, cross_encoder_choice, history=None):
     top_k_rank = 20
     
     if not query.strip():
-        return "Please provide a valid question."
+        return "Please provide a valid question.", []
     
     try:
         start_time = perf_counter()
@@ -148,24 +161,27 @@ def retrieve_and_generate_response(query, cross_encoder_choice, history=None):
         response_text = response.content if hasattr(response, 'content') else str(response)
         
         logger.info(f"Response generation took {perf_counter() - start_time:.2f} seconds")
-        return response_text
+        return response_text, documents  # Return documents for template
     
     except Exception as e:
         logger.error(f"Error in response generation: {e}")
-        return f"Error generating response: {str(e)}"
+        return f"Error generating response: {str(e)}", []
 
 def simple_chat_function(message, history, cross_encoder_choice):
     """Chat function with semantic search and retriever integration"""
     if not message.strip():
-        return "", history
+        return "", history, ""
     
-    # Generate response using the semantic search function
-    response = retrieve_and_generate_response(message, cross_encoder_choice, history)
+    # Generate response and get documents
+    response, documents = retrieve_and_generate_response(message, cross_encoder_choice, history)
     
     # Add to history
     history.append([message, response])
     
-    return "", history
+    # Render template with documents and query
+    prompt_html = template_html.render(documents=documents, query=message)
+    
+    return "", history, prompt_html
 
 def translate_text(selected_language, history):
     """Translate the last response in history to the selected language."""
@@ -233,26 +249,30 @@ with gr.Blocks(title="Science Chatbot", theme='gradio/soft') as demo:
         label="Select Language for Translation"
     )
     translated_textbox = gr.Textbox(label="Translated Response")
+    prompt_html = gr.HTML()  # Add HTML component for the template
 
     # Event handlers
     def update_chat_and_translate(message, history, cross_encoder_choice, selected_language):
         if not message.strip():
-            return "", history, ""
+            return "", history, "", ""
         
-        # Generate response
-        response = retrieve_and_generate_response(message, cross_encoder_choice, history)
+        # Generate response and get documents
+        response, documents = retrieve_and_generate_response(message, cross_encoder_choice, history)
         history.append([message, response])
         
         # Translate response
         translated_text = translate_text(selected_language, history)
         
-        return "", history, translated_text
+        # Render template with documents and query
+        prompt_html_content = template_html.render(documents=documents, query=message)
+        
+        return "", history, translated_text, prompt_html_content
 
-    msg.submit(update_chat_and_translate, [msg, chatbot, cross_encoder, language_dropdown], [msg, chatbot, translated_textbox])
-    submit_btn.click(update_chat_and_translate, [msg, chatbot, cross_encoder, language_dropdown], [msg, chatbot, translated_textbox])
+    msg.submit(update_chat_and_translate, [msg, chatbot, cross_encoder, language_dropdown], [msg, chatbot, translated_textbox, prompt_html])
+    submit_btn.click(update_chat_and_translate, [msg, chatbot, cross_encoder, language_dropdown], [msg, chatbot, translated_textbox, prompt_html])
 
     clear = gr.Button("Clear Conversation")
-    clear.click(lambda: ([], "", ""), outputs=[chatbot, msg, translated_textbox])
+    clear.click(lambda: ([], "", "", ""), outputs=[chatbot, msg, translated_textbox, prompt_html])
 
     # Example questions
     gr.Examples(
@@ -268,43 +288,50 @@ with gr.Blocks(title="Science Chatbot", theme='gradio/soft') as demo:
     )
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)# import gradio as gr# import requests
-# import gradio as gr
-# from ragatouille import RAGPretrainedModel
+    demo.launch(server_name="0.0.0.0", server_port=7860)# import gradio as gr
+# from phi.agent import Agent
+# from phi.model.groq import Groq
+# import os
 # import logging
-# from pathlib import Path
-# from time import perf_counter
 # from sentence_transformers import CrossEncoder
-# from huggingface_hub import InferenceClient
-# from jinja2 import Environment, FileSystemLoader
-# import numpy as np
-# from os import getenv
-# from backend.query_llm import generate_hf, generate_qwen
 # from backend.semantic_search import table, retriever
-# from huggingface_hub import InferenceClient
+# import numpy as np
+# from time import perf_counter
+# import requests
+# from jinja2 import Environment, FileSystemLoader
+
+# # Set up logging
+# logging.basicConfig(level=logging.INFO)
+# logger = logging.getLogger(__name__)
 
+# # API Key setup
+# api_key = os.getenv("GROQ_API_KEY")
+# if not api_key:
+#     gr.Warning("GROQ_API_KEY not found. Set it in 'Repository secrets'.")
+#     logger.error("GROQ_API_KEY not found.")
+#     api_key = ""  # Fallback to empty string, but this will fail without a key
+# else:
+#     os.environ["GROQ_API_KEY"] = api_key
 
-# # Bhashini API translation function
-# api_key = getenv('API_KEY')
-# user_id = getenv('USER_ID')
+# # Bhashini API setup
+# bhashini_api_key = os.getenv("API_KEY")
+# bhashini_user_id = os.getenv("USER_ID")
 
 # def bhashini_translate(text: str, from_code: str = "en", to_code: str = "hi") -> dict:
 #     """Translates text from source language to target language using the Bhashini API."""
-    
 #     if not text.strip():
 #         print('Input text is empty. Please provide valid text for translation.')
-#         return {"status_code": 400, "message": "Input text is empty", "translated_content": None, "speech_content": None}
+#         return {"status_code": 400, "message": "Input text is empty", "translated_content": None}
 #     else:
-#         print('Input text - ',text)
-#     print(f'Starting translation process from {from_code} to {to_code}...')
+#         print('Input text - ', text)
 #     print(f'Starting translation process from {from_code} to {to_code}...')
 #     gr.Warning(f'Translating to {to_code}...')
     
 #     url = 'https://meity-auth.ulcacontrib.org/ulca/apis/v0/model/getModelsPipeline'
 #     headers = {
 #         "Content-Type": "application/json",
-#         "userID": user_id,
-#         "ulcaApiKey": api_key
+#         "userID": bhashini_user_id,
+#         "ulcaApiKey": bhashini_api_key
 #     }
 #     payload = {
 #         "pipelineTasks": [{"taskType": "translation", "config": {"language": {"sourceLanguage": from_code, "targetLanguage": to_code}}}],
@@ -315,11 +342,16 @@ if __name__ == "__main__":
 #     response = requests.post(url, json=payload, headers=headers)
     
 #     if response.status_code != 200:
-#         print(f'Error in initial request: {response.status_code}')
+#         print(f'Error in initial request: {response.status_code}, Response: {response.text}')
 #         return {"status_code": response.status_code, "message": "Error in translation request", "translated_content": None}
 
 #     print('Initial request successful, processing response...')
 #     response_data = response.json()
+#     print('Full response data:', response_data)  # Debug the full response
+#     if "pipelineInferenceAPIEndPoint" not in response_data or "callbackUrl" not in response_data["pipelineInferenceAPIEndPoint"]:
+#         print('Unexpected response structure:', response_data)
+#         return {"status_code": 400, "message": "Unexpected API response structure", "translated_content": None}
+
 #     service_id = response_data["pipelineResponseConfig"][0]["config"][0]["serviceId"]
 #     callback_url = response_data["pipelineInferenceAPIEndPoint"]["callbackUrl"]
     
@@ -338,7 +370,7 @@ if __name__ == "__main__":
 #     compute_response = requests.post(callback_url, json=compute_payload, headers=headers2)
     
 #     if compute_response.status_code != 200:
-#         print(f'Error in translation request: {compute_response.status_code}')
+#         print(f'Error in translation request: {compute_response.status_code}, Response: {compute_response.text}')
 #         return {"status_code": compute_response.status_code, "message": "Error in translation", "translated_content": None}
     
 #     print('Translation request successful, processing translation...')
@@ -348,157 +380,391 @@ if __name__ == "__main__":
 #     print(f'Translation successful. Translated content: "{translated_content}"')
 #     return {"status_code": 200, "message": "Translation successful", "translated_content": translated_content}
 
-
-# # Existing chatbot functions
-# VECTOR_COLUMN_NAME = "vector"
-# TEXT_COLUMN_NAME = "text"
-# HF_TOKEN = getenv("HUGGING_FACE_HUB_TOKEN")
+# # Initialize PhiData Agent
+# agent = Agent(
+#     name="Science Education Assistant",
+#     role="You are a helpful science tutor for 10th-grade students",
+#     instructions=[
+#         "You are an expert science teacher specializing in 10th-grade curriculum.",
+#         "Provide clear, accurate, and age-appropriate explanations.",
+#         "Use simple language and examples that students can understand.",
+#         "Focus on concepts from physics, chemistry, and biology.",
+#         "Structure responses with headings and bullet points when helpful.",
+#         "Encourage learning and curiosity."
+#     ],
+#     model=Groq(id="llama3-70b-8192", api_key=api_key),
+#     markdown=True
+# )
+# # Set up Jinja2 environment
 # proj_dir = Path(__file__).parent
-
-# logging.basicConfig(level=logging.INFO)
-# logger = logging.getLogger(__name__)
-# client = InferenceClient("mistralai/Mixtral-8x7B-Instruct-v0.1", token=HF_TOKEN)
 # env = Environment(loader=FileSystemLoader(proj_dir / 'templates'))
 
-# template = env.get_template('template.j2')
-# template_html = env.get_template('template_html.j2')
 
-# # def add_text(history, text):
-# #     history = [] if history is None else history
-# #     history = history + [(text, None)]
-# #     return history, gr.Textbox(value="", interactive=False)
-
-# def bot(history, cross_encoder):
+# template_html = env.get_template('template_html.j2')
 
+# # Response Generation Function
+# def retrieve_and_generate_response(query, cross_encoder_choice, history=None):
+#     """Generate response using semantic search and LLM"""
 #     top_rerank = 25
 #     top_k_rank = 20
-#     query = history[-1][0] if history else ''
-#     print('\nQuery: ',query )
-#     print('\nHistory:',history)
-#     if not query:
-#         gr.Warning("Please submit a non-empty string as a prompt")
-#         raise ValueError("Empty string was submitted")
-
-#     logger.warning('Retrieving documents...')
-    
-#     if cross_encoder == '(HIGH ACCURATE) ColBERT':
-#         gr.Warning('Retrieving using ColBERT.. First time query will take a minute for model to load..pls wait')
-#         RAG = RAGPretrainedModel.from_pretrained("colbert-ir/colbertv2.0")
-#         RAG_db = RAG.from_index('.ragatouille/colbert/indexes/cbseclass10index')
-#         documents_full = RAG_db.search(query, k=top_k_rank)
-        
-#         documents = [item['content'] for item in documents_full]
-#         prompt = template.render(documents=documents, query=query)
-#         prompt_html = template_html.render(documents=documents, query=query)
-    
-#         generate_fn = generate_hf
-    
-#         history[-1][1] = ""
-#         for character in generate_fn(prompt, history[:-1]):
-#             history[-1][1] = character
-#             yield history, prompt_html
-#     else:
-#         document_start = perf_counter()
     
-#         query_vec = retriever.encode(query)
-#         doc1 = table.search(query_vec, vector_column_name=VECTOR_COLUMN_NAME).limit(top_k_rank)
+#     if not query.strip():
+#         return "Please provide a valid question."
     
-#         documents = table.search(query_vec, vector_column_name=VECTOR_COLUMN_NAME).limit(top_rerank).to_list()
-#         documents = [doc[TEXT_COLUMN_NAME] for doc in documents]
-    
-#         query_doc_pair = [[query, doc] for doc in documents]
-#         if cross_encoder == '(FAST) MiniLM-L6v2':
-#             cross_encoder1 = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
-#         elif cross_encoder == '(ACCURATE) BGE reranker':
-#             cross_encoder1 = CrossEncoder('BAAI/bge-reranker-base')
+#     try:
+#         start_time = perf_counter()
         
-#         cross_scores = cross_encoder1.predict(query_doc_pair)
-#         sim_scores_argsort = list(reversed(np.argsort(cross_scores)))
+#         # Encode query and search documents
+#         query_vec = retriever.encode(query)
+#         documents = table.search(query_vec, vector_column_name="vector").limit(top_rerank).to_list()
+#         documents = [doc["text"] for doc in documents]
         
+#         # Re-rank documents using cross-encoder
+#         cross_encoder_model = CrossEncoder('BAAI/bge-reranker-base') if cross_encoder_choice == '(ACCURATE) BGE reranker' else CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
+#         query_doc_pair = [[query, doc] for doc in documents]
+#         cross_scores = cross_encoder_model.predict(query_doc_pair)
+#         sim_scores_argsort = list(reversed(np.argsort(cross_scores)))
 #         documents = [documents[idx] for idx in sim_scores_argsort[:top_k_rank]]
+        
+#         # Create context from top documents
+#         context = "\n\n".join(documents[:10]) if documents else ""
+#         context = f"Context information from educational materials:\n{context}\n\n"
+        
+#         # Add conversation history for context
+#         history_context = ""
+#         if history and len(history) > 0:
+#             for user_msg, bot_msg in history[-2:]:  # Last 2 exchanges
+#                 if user_msg and bot_msg:
+#                     history_context += f"Previous Q: {user_msg}\nPrevious A: {bot_msg}\n"
+        
+#         # Create full prompt
+#         full_prompt = f"{history_context}{context}Question: {query}\n\nPlease answer the question using the context provided above. If the context doesn't contain relevant information, use your general knowledge about 10th-grade science topics."
+        
+#         # Generate response
+#         response = agent.run(full_prompt)
+#         response_text = response.content if hasattr(response, 'content') else str(response)
+        
+#         logger.info(f"Response generation took {perf_counter() - start_time:.2f} seconds")
+#         return response_text
     
-#         document_time = perf_counter() - document_start
+#     except Exception as e:
+#         logger.error(f"Error in response generation: {e}")
+#         return f"Error generating response: {str(e)}"
+
+# def simple_chat_function(message, history, cross_encoder_choice):
+#     """Chat function with semantic search and retriever integration"""
+#     if not message.strip():
+#         return "", history
+    
+#     # Generate response using the semantic search function
+#     response = retrieve_and_generate_response(message, cross_encoder_choice, history)
     
-#         prompt = template.render(documents=documents, query=query)
-#         prompt_html = template_html.render(documents=documents, query=query)
+#     # Add to history
+#     history.append([message, response])
     
-#         #generate_fn = generate_hf
-#         generate_fn=generate_qwen
-#         # Create a new history entry instead of modifying the tuple directly
-#         new_history = history[:-1] + [ (prompt, "") ] # query replaced prompt
-#         output=''
-#         # for character in generate_fn(prompt, history[:-1]):
-#         #     #new_history[-1] = (query, character) 
-#         #     output+=character
-#         output=generate_fn(prompt, history[:-1])
+#     return "", history
+
+# def translate_text(selected_language, history):
+#     """Translate the last response in history to the selected language."""
+#     iso_language_codes = {
+#         "Hindi": "hi", "Gom": "gom", "Kannada": "kn", "Dogri": "doi", "Bodo": "brx", "Urdu": "ur",
+#         "Tamil": "ta", "Kashmiri": "ks", "Assamese": "as", "Bengali": "bn", "Marathi": "mr",
+#         "Sindhi": "sd", "Maithili": "mai", "Punjabi": "pa", "Malayalam": "ml", "Manipuri": "mni",
+#         "Telugu": "te", "Sanskrit": "sa", "Nepali": "ne", "Santali": "sat", "Gujarati": "gu", "Odia": "or"
+#     }
+    
+#     to_code = iso_language_codes[selected_language]
+#     response_text = history[-1][1] if history and history[-1][1] else ''
+#     print('response_text for translation', response_text)
+#     translation = bhashini_translate(response_text, to_code=to_code)
+#     return translation.get('translated_content', 'Translation failed.')
+
+# # Gradio Interface with layout template
+# with gr.Blocks(title="Science Chatbot", theme='gradio/soft') as demo:
+#     # Header section
+#     with gr.Row():
+#         with gr.Column(scale=10):
+#             gr.HTML(value="""<div style="color: #FF4500;"><h1>Welcome! I am your friend!</h1>Ask me !I will help you<h1><span style="color: #008000">I AM A CHATBOT FOR 10TH SCIENCE WITH TRANSLATION IN 22 LANGUAGES</span></h1></div>""")
+#             gr.HTML(value=f"""<p style="font-family: sans-serif; font-size: 16px;">A free chat bot developed by K.M.RAMYASRI,TGT,GHS.SUTHUKENY using Open source LLMs for 10 std students</p>""")
+#             gr.HTML(value=f"""<p style="font-family: Arial, sans-serif; font-size: 14px;"> Suggestions may be sent to <a href="mailto:[email protected]" style="color: #00008B; font-style: italic;">[email protected]</a>.</p>""")
+#         with gr.Column(scale=3):
+#             try:
+#                 gr.Image(value='logo.png', height=200, width=200)
+#             except:
+#                 gr.HTML("<div style='height: 200px; width: 200px; background-color: #f0f0f0; display: flex; align-items: center; justify-content: center;'>Logo</div>")
+
+#     # Chat and input components
+#     chatbot = gr.Chatbot(
+#         [],
+#         elem_id="chatbot",
+#         avatar_images=('https://aui.atlassian.com/aui/8.8/docs/images/avatar-person.svg',
+#                        'https://huggingface.co/datasets/huggingface/brand-assets/resolve/main/hf-logo.svg'),
+#         bubble_full_width=False,
+#         show_copy_button=True,
+#         show_share_button=True,
+#     )
+
+#     with gr.Row():
+#         msg = gr.Textbox(
+#             scale=3,
+#             show_label=False,
+#             placeholder="Enter text and press enter",
+#             container=False,
+#         )
+#         submit_btn = gr.Button(value="Submit text", scale=1, variant="primary")
+
+#     # Additional controls
+#     cross_encoder = gr.Radio(
+#         choices=['(FAST) MiniLM-L6v2', '(ACCURATE) BGE reranker'],
+#         value='(ACCURATE) BGE reranker',
+#         label="Embeddings Model",
+#         info="Select the model for document ranking"
+#     )
+#     language_dropdown = gr.Dropdown(
+#         choices=[
+#             "Hindi", "Gom", "Kannada", "Dogri", "Bodo", "Urdu", "Tamil", "Kashmiri", "Assamese", "Bengali", "Marathi",
+#             "Sindhi", "Maithili", "Punjabi", "Malayalam", "Manipuri", "Telugu", "Sanskrit", "Nepali", "Santali",
+#             "Gujarati", "Odia"
+#         ],
+#         value="Hindi",
+#         label="Select Language for Translation"
+#     )
+#     translated_textbox = gr.Textbox(label="Translated Response")
+
+#     # Event handlers
+#     def update_chat_and_translate(message, history, cross_encoder_choice, selected_language):
+#         if not message.strip():
+#             return "", history, ""
+        
+#         # Generate response
+#         response = retrieve_and_generate_response(message, cross_encoder_choice, history)
+#         history.append([message, response])
         
-#         print('Output:',output)
-#         new_history[-1] = (prompt, output) #query replaced with prompt
-#         print('New History',new_history)
-#         #print('prompt html',prompt_html)# Update the last tuple with new text
+#         # Translate response
+#         translated_text = translate_text(selected_language, history)
         
-#         history_list = list(history[-1])
-#         history_list[1] = output  # Assuming `character` is what you want to assign
-#         # Update the history with the modified list converted back to a tuple
-#         history[-1] = tuple(history_list)
+#         return "", history, translated_text
+
+#     msg.submit(update_chat_and_translate, [msg, chatbot, cross_encoder, language_dropdown], [msg, chatbot, translated_textbox])
+#     submit_btn.click(update_chat_and_translate, [msg, chatbot, cross_encoder, language_dropdown], [msg, chatbot, translated_textbox])
+
+#     clear = gr.Button("Clear Conversation")
+#     clear.click(lambda: ([], "", ""), outputs=[chatbot, msg, translated_textbox])
+
+#     # Example questions
+#     gr.Examples(
+#         examples=[
+#             'What is the difference between metals and non-metals?',
+#             'What is an ionic bond?',
+#             'Explain asexual reproduction',
+#             'What is photosynthesis?',
+#             'Explain Newton\'s laws of motion'
+#         ],
+#         inputs=msg,
+#         label="Try these example questions:"
+#     )
+
+# if __name__ == "__main__":
+#     demo.launch(server_name="0.0.0.0", server_port=7860)# import gradio as gr
+# import gradio as gr
+# from phi.agent import Agent
+# from phi.model.groq import Groq
+# import os
+# import logging
+# from sentence_transformers import CrossEncoder
+# from backend.semantic_search import table, retriever
+# import numpy as np
+# from time import perf_counter
+# import requests
+
+# # Set up logging
+# logging.basicConfig(level=logging.INFO)
+# logger = logging.getLogger(__name__)
+
+# # API Key setup
+# api_key = os.getenv("GROQ_API_KEY")
+# if not api_key:
+#     gr.Warning("GROQ_API_KEY not found. Set it in 'Repository secrets'.")
+#     logger.error("GROQ_API_KEY not found.")
+#     api_key = ""  # Fallback to empty string, but this will fail without a key
+# else:
+#     os.environ["GROQ_API_KEY"] = api_key
+
+# # Bhashini API setup
+# bhashini_api_key = os.getenv("API_KEY")
+# bhashini_user_id = os.getenv("USER_ID")
+
+# def bhashini_translate(text: str, from_code: str = "en", to_code: str = "hi") -> dict:
+#     """Translates text from source language to target language using the Bhashini API."""
+#     if not text.strip():
+#         print('Input text is empty. Please provide valid text for translation.')
+#         return {"status_code": 400, "message": "Input text is empty", "translated_content": None}
+#     else:
+#         print('Input text - ', text)
+#     print(f'Starting translation process from {from_code} to {to_code}...')
+#     gr.Warning(f'Translating to {to_code}...')
+    
+#     url = 'https://meity-auth.ulcacontrib.org/ulca/apis/v0/model/getModelsPipeline'
+#     headers = {
+#         "Content-Type": "application/json",
+#         "userID": bhashini_user_id,
+#         "ulcaApiKey": bhashini_api_key
+#     }
+#     payload = {
+#         "pipelineTasks": [{"taskType": "translation", "config": {"language": {"sourceLanguage": from_code, "targetLanguage": to_code}}}],
+#         "pipelineRequestConfig": {"pipelineId": "64392f96daac500b55c543cd"}
+#     }
+    
+#     print('Sending initial request to get the pipeline...')
+#     response = requests.post(url, json=payload, headers=headers)
+    
+#     if response.status_code != 200:
+#         print(f'Error in initial request: {response.status_code}, Response: {response.text}')
+#         return {"status_code": response.status_code, "message": "Error in translation request", "translated_content": None}
 
-#             #history[-1][1] = character
-#         # yield new_history, prompt_html
-#         yield history, prompt_html
-#          # new_history,prompt_html
-#         # history[-1][1] = ""
-#         # for character in generate_fn(prompt, history[:-1]):
-#         #     history[-1][1] = character
-#         #     yield history, prompt_html
+#     print('Initial request successful, processing response...')
+#     response_data = response.json()
+#     print('Full response data:', response_data)  # Debug the full response
+#     if "pipelineInferenceAPIEndPoint" not in response_data or "callbackUrl" not in response_data["pipelineInferenceAPIEndPoint"]:
+#         print('Unexpected response structure:', response_data)
+#         return {"status_code": 400, "message": "Unexpected API response structure", "translated_content": None}
 
-# #def translate_text(response_text, selected_language):
+#     service_id = response_data["pipelineResponseConfig"][0]["config"][0]["serviceId"]
+#     callback_url = response_data["pipelineInferenceAPIEndPoint"]["callbackUrl"]
+    
+#     print(f'Service ID: {service_id}, Callback URL: {callback_url}')
+    
+#     headers2 = {
+#         "Content-Type": "application/json",
+#         response_data["pipelineInferenceAPIEndPoint"]["inferenceApiKey"]["name"]: response_data["pipelineInferenceAPIEndPoint"]["inferenceApiKey"]["value"]
+#     }
+#     compute_payload = {
+#         "pipelineTasks": [{"taskType": "translation", "config": {"language": {"sourceLanguage": from_code, "targetLanguage": to_code}, "serviceId": service_id}}],
+#         "inputData": {"input": [{"source": text}], "audio": [{"audioContent": None}]}
+#     }
     
-# def translate_text(selected_language,history):
+#     print(f'Sending translation request with text: "{text}"')
+#     compute_response = requests.post(callback_url, json=compute_payload, headers=headers2)
     
+#     if compute_response.status_code != 200:
+#         print(f'Error in translation request: {compute_response.status_code}, Response: {compute_response.text}')
+#         return {"status_code": compute_response.status_code, "message": "Error in translation", "translated_content": None}
+    
+#     print('Translation request successful, processing translation...')
+#     compute_response_data = compute_response.json()
+#     translated_content = compute_response_data["pipelineResponse"][0]["output"][0]["target"]
+    
+#     print(f'Translation successful. Translated content: "{translated_content}"')
+#     return {"status_code": 200, "message": "Translation successful", "translated_content": translated_content}
+
+# # Initialize PhiData Agent
+# agent = Agent(
+#     name="Science Education Assistant",
+#     role="You are a helpful science tutor for 10th-grade students",
+#     instructions=[
+#         "You are an expert science teacher specializing in 10th-grade curriculum.",
+#         "Provide clear, accurate, and age-appropriate explanations.",
+#         "Use simple language and examples that students can understand.",
+#         "Focus on concepts from physics, chemistry, and biology.",
+#         "Structure responses with headings and bullet points when helpful.",
+#         "Encourage learning and curiosity."
+#     ],
+#     model=Groq(id="llama3-70b-8192", api_key=api_key),
+#     markdown=True
+# )
+
+# # Response Generation Function
+# def retrieve_and_generate_response(query, cross_encoder_choice, history=None):
+#     """Generate response using semantic search and LLM"""
+#     top_rerank = 25
+#     top_k_rank = 20
+    
+#     if not query.strip():
+#         return "Please provide a valid question."
+    
+#     try:
+#         start_time = perf_counter()
+        
+#         # Encode query and search documents
+#         query_vec = retriever.encode(query)
+#         documents = table.search(query_vec, vector_column_name="vector").limit(top_rerank).to_list()
+#         documents = [doc["text"] for doc in documents]
+        
+#         # Re-rank documents using cross-encoder
+#         cross_encoder_model = CrossEncoder('BAAI/bge-reranker-base') if cross_encoder_choice == '(ACCURATE) BGE reranker' else CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
+#         query_doc_pair = [[query, doc] for doc in documents]
+#         cross_scores = cross_encoder_model.predict(query_doc_pair)
+#         sim_scores_argsort = list(reversed(np.argsort(cross_scores)))
+#         documents = [documents[idx] for idx in sim_scores_argsort[:top_k_rank]]
+        
+#         # Create context from top documents
+#         context = "\n\n".join(documents[:10]) if documents else ""
+#         context = f"Context information from educational materials:\n{context}\n\n"
+        
+#         # Add conversation history for context
+#         history_context = ""
+#         if history and len(history) > 0:
+#             for user_msg, bot_msg in history[-2:]:  # Last 2 exchanges
+#                 if user_msg and bot_msg:
+#                     history_context += f"Previous Q: {user_msg}\nPrevious A: {bot_msg}\n"
+        
+#         # Create full prompt
+#         full_prompt = f"{history_context}{context}Question: {query}\n\nPlease answer the question using the context provided above. If the context doesn't contain relevant information, use your general knowledge about 10th-grade science topics."
+        
+#         # Generate response
+#         response = agent.run(full_prompt)
+#         response_text = response.content if hasattr(response, 'content') else str(response)
+        
+#         logger.info(f"Response generation took {perf_counter() - start_time:.2f} seconds")
+#         return response_text
+    
+#     except Exception as e:
+#         logger.error(f"Error in response generation: {e}")
+#         return f"Error generating response: {str(e)}"
+
+# def simple_chat_function(message, history, cross_encoder_choice):
+#     """Chat function with semantic search and retriever integration"""
+#     if not message.strip():
+#         return "", history
+    
+#     # Generate response using the semantic search function
+#     response = retrieve_and_generate_response(message, cross_encoder_choice, history)
+    
+#     # Add to history
+#     history.append([message, response])
+    
+#     return "", history
+
+# def translate_text(selected_language, history):
+#     """Translate the last response in history to the selected language."""
 #     iso_language_codes = {
-#         "Hindi": "hi",
-#         "Gom": "gom",
-#         "Kannada": "kn",
-#         "Dogri": "doi",
-#         "Bodo": "brx",
-#         "Urdu": "ur",
-#         "Tamil": "ta",
-#         "Kashmiri": "ks",
-#         "Assamese": "as",
-#         "Bengali": "bn",
-#         "Marathi": "mr",
-#         "Sindhi": "sd",
-#         "Maithili": "mai",
-#         "Punjabi": "pa",
-#         "Malayalam": "ml",
-#         "Manipuri": "mni",
-#         "Telugu": "te",
-#         "Sanskrit": "sa",
-#         "Nepali": "ne",
-#         "Santali": "sat",
-#         "Gujarati": "gu",
-#         "Odia": "or"
+#         "Hindi": "hi", "Gom": "gom", "Kannada": "kn", "Dogri": "doi", "Bodo": "brx", "Urdu": "ur",
+#         "Tamil": "ta", "Kashmiri": "ks", "Assamese": "as", "Bengali": "bn", "Marathi": "mr",
+#         "Sindhi": "sd", "Maithili": "mai", "Punjabi": "pa", "Malayalam": "ml", "Manipuri": "mni",
+#         "Telugu": "te", "Sanskrit": "sa", "Nepali": "ne", "Santali": "sat", "Gujarati": "gu", "Odia": "or"
 #     }
     
 #     to_code = iso_language_codes[selected_language]
-#     response_text = history[-1][1] if history else ''
-#     print('response_text for translation',response_text)
+#     response_text = history[-1][1] if history and history[-1][1] else ''
+#     print('response_text for translation', response_text)
 #     translation = bhashini_translate(response_text, to_code=to_code)
-#     return translation['translated_content']
-   
+#     return translation.get('translated_content', 'Translation failed.')
 
-# # Gradio interface
-# with gr.Blocks(theme='gradio/soft') as CHATBOT:
-#     history_state = gr.State([])
+# # Gradio Interface with layout template
+# with gr.Blocks(title="Science Chatbot", theme='gradio/soft') as demo:
+#     # Header section
 #     with gr.Row():
 #         with gr.Column(scale=10):
-#             gr.HTML(value="""<div style="color: #FF4500;"><h1>Welcome! I am your friend!</h1>Ask me !I will help you<h1><span style="color: #008000">I AM A CHATBOT FOR 9 SCIENCE WITH TRANSLATION IN 22 LANGUAGES</span></h1></div>""")
+#             gr.HTML(value="""<div style="color: #FF4500;"><h1>Welcome! I am your friend!</h1>Ask me !I will help you<h1><span style="color: #008000">I AM A CHATBOT FOR 10TH SCIENCE WITH TRANSLATION IN 22 LANGUAGES</span></h1></div>""")
 #             gr.HTML(value=f"""<p style="font-family: sans-serif; font-size: 16px;">A free chat bot developed by K.M.RAMYASRI,TGT,GHS.SUTHUKENY using Open source LLMs for 10 std students</p>""")
 #             gr.HTML(value=f"""<p style="font-family: Arial, sans-serif; font-size: 14px;"> Suggestions may be sent to <a href="mailto:[email protected]" style="color: #00008B; font-style: italic;">[email protected]</a>.</p>""")
-
 #         with gr.Column(scale=3):
-#             gr.Image(value='logo.png', height=200, width=200)
+#             try:
+#                 gr.Image(value='logo.png', height=200, width=200)
+#             except:
+#                 gr.HTML("<div style='height: 200px; width: 200px; background-color: #f0f0f0; display: flex; align-items: center; justify-content: center;'>Logo</div>")
 
+#     # Chat and input components
 #     chatbot = gr.Chatbot(
 #         [],
 #         elem_id="chatbot",
@@ -510,57 +776,361 @@ if __name__ == "__main__":
 #     )
 
 #     with gr.Row():
-#         txt = gr.Textbox(
+#         msg = gr.Textbox(
 #             scale=3,
 #             show_label=False,
 #             placeholder="Enter text and press enter",
 #             container=False,
 #         )
-#         txt_btn = gr.Button(value="Submit text", scale=1)
-    
-#     cross_encoder = gr.Radio(choices=['(FAST) MiniLM-L6v2', '(ACCURATE) BGE reranker', '(HIGH ACCURATE) ColBERT'], value='(ACCURATE) BGE reranker', label="Embeddings", info="Only First query to Colbert may take little time)")
+#         submit_btn = gr.Button(value="Submit text", scale=1, variant="primary")
+
+#     # Additional controls
+#     cross_encoder = gr.Radio(
+#         choices=['(FAST) MiniLM-L6v2', '(ACCURATE) BGE reranker'],
+#         value='(ACCURATE) BGE reranker',
+#         label="Embeddings Model",
+#         info="Select the model for document ranking"
+#     )
 #     language_dropdown = gr.Dropdown(
 #         choices=[
 #             "Hindi", "Gom", "Kannada", "Dogri", "Bodo", "Urdu", "Tamil", "Kashmiri", "Assamese", "Bengali", "Marathi",
 #             "Sindhi", "Maithili", "Punjabi", "Malayalam", "Manipuri", "Telugu", "Sanskrit", "Nepali", "Santali",
 #             "Gujarati", "Odia"
 #         ],
-#         value="Hindi",  # default to Hindi
+#         value="Hindi",
 #         label="Select Language for Translation"
 #     )
+#     translated_textbox = gr.Textbox(label="Translated Response")
+
+#     # Event handlers
+#     def update_chat_and_translate(message, history, cross_encoder_choice, selected_language):
+#         if not message.strip():
+#             return "", history, ""
+        
+#         # Generate response
+#         response = retrieve_and_generate_response(message, cross_encoder_choice, history)
+#         history.append([message, response])
+        
+#         # Translate response
+#         translated_text = translate_text(selected_language, history)
+        
+#         return "", history, translated_text
+
+#     msg.submit(update_chat_and_translate, [msg, chatbot, cross_encoder, language_dropdown], [msg, chatbot, translated_textbox])
+#     submit_btn.click(update_chat_and_translate, [msg, chatbot, cross_encoder, language_dropdown], [msg, chatbot, translated_textbox])
+
+#     clear = gr.Button("Clear Conversation")
+#     clear.click(lambda: ([], "", ""), outputs=[chatbot, msg, translated_textbox])
+
+#     # Example questions
+#     gr.Examples(
+#         examples=[
+#             'What is the difference between metals and non-metals?',
+#             'What is an ionic bond?',
+#             'Explain asexual reproduction',
+#             'What is photosynthesis?',
+#             'Explain Newton\'s laws of motion'
+#         ],
+#         inputs=msg,
+#         label="Try these example questions:"
+#     )
+
+# if __name__ == "__main__":
+#     demo.launch(server_name="0.0.0.0", server_port=7860)
+
+# 1f# import gradio as gr# import requests
+# # import gradio as gr
+# # from ragatouille import RAGPretrainedModel
+# # import logging
+# # from pathlib import Path
+# # from time import perf_counter
+# # from sentence_transformers import CrossEncoder
+# # from huggingface_hub import InferenceClient
+# # from jinja2 import Environment, FileSystemLoader
+# # import numpy as np
+# # from os import getenv
+# # from backend.query_llm import generate_hf, generate_qwen
+# # from backend.semantic_search import table, retriever
+# # from huggingface_hub import InferenceClient
+
+
+# # # Bhashini API translation function
+# # api_key = getenv('API_KEY')
+# # user_id = getenv('USER_ID')
+
+# # def bhashini_translate(text: str, from_code: str = "en", to_code: str = "hi") -> dict:
+# #     """Translates text from source language to target language using the Bhashini API."""
     
-#     prompt_html = gr.HTML()
+# #     if not text.strip():
+# #         print('Input text is empty. Please provide valid text for translation.')
+# #         return {"status_code": 400, "message": "Input text is empty", "translated_content": None, "speech_content": None}
+# #     else:
+# #         print('Input text - ',text)
+# #     print(f'Starting translation process from {from_code} to {to_code}...')
+# #     print(f'Starting translation process from {from_code} to {to_code}...')
+# #     gr.Warning(f'Translating to {to_code}...')
     
-#     translated_textbox = gr.Textbox(label="Translated Response")
-#     def update_history_and_translate(txt, cross_encoder, history_state, language_dropdown):
-#         print('History state',history_state)
-#         history = history_state
-#         history.append((txt, ""))
-#         #history_state.value=(history)
+# #     url = 'https://meity-auth.ulcacontrib.org/ulca/apis/v0/model/getModelsPipeline'
+# #     headers = {
+# #         "Content-Type": "application/json",
+# #         "userID": user_id,
+# #         "ulcaApiKey": api_key
+# #     }
+# #     payload = {
+# #         "pipelineTasks": [{"taskType": "translation", "config": {"language": {"sourceLanguage": from_code, "targetLanguage": to_code}}}],
+# #         "pipelineRequestConfig": {"pipelineId": "64392f96daac500b55c543cd"}
+# #     }
+    
+# #     print('Sending initial request to get the pipeline...')
+# #     response = requests.post(url, json=payload, headers=headers)
+    
+# #     if response.status_code != 200:
+# #         print(f'Error in initial request: {response.status_code}')
+# #         return {"status_code": response.status_code, "message": "Error in translation request", "translated_content": None}
+
+# #     print('Initial request successful, processing response...')
+# #     response_data = response.json()
+# #     service_id = response_data["pipelineResponseConfig"][0]["config"][0]["serviceId"]
+# #     callback_url = response_data["pipelineInferenceAPIEndPoint"]["callbackUrl"]
+    
+# #     print(f'Service ID: {service_id}, Callback URL: {callback_url}')
+    
+# #     headers2 = {
+# #         "Content-Type": "application/json",
+# #         response_data["pipelineInferenceAPIEndPoint"]["inferenceApiKey"]["name"]: response_data["pipelineInferenceAPIEndPoint"]["inferenceApiKey"]["value"]
+# #     }
+# #     compute_payload = {
+# #         "pipelineTasks": [{"taskType": "translation", "config": {"language": {"sourceLanguage": from_code, "targetLanguage": to_code}, "serviceId": service_id}}],
+# #         "inputData": {"input": [{"source": text}], "audio": [{"audioContent": None}]}
+# #     }
+    
+# #     print(f'Sending translation request with text: "{text}"')
+# #     compute_response = requests.post(callback_url, json=compute_payload, headers=headers2)
+    
+# #     if compute_response.status_code != 200:
+# #         print(f'Error in translation request: {compute_response.status_code}')
+# #         return {"status_code": compute_response.status_code, "message": "Error in translation", "translated_content": None}
+    
+# #     print('Translation request successful, processing translation...')
+# #     compute_response_data = compute_response.json()
+# #     translated_content = compute_response_data["pipelineResponse"][0]["output"][0]["target"]
+    
+# #     print(f'Translation successful. Translated content: "{translated_content}"')
+# #     return {"status_code": 200, "message": "Translation successful", "translated_content": translated_content}
+
+
+# # # Existing chatbot functions
+# # VECTOR_COLUMN_NAME = "vector"
+# # TEXT_COLUMN_NAME = "text"
+# # HF_TOKEN = getenv("HUGGING_FACE_HUB_TOKEN")
+# # proj_dir = Path(__file__).parent
+
+# # logging.basicConfig(level=logging.INFO)
+# # logger = logging.getLogger(__name__)
+# # client = InferenceClient("mistralai/Mixtral-8x7B-Instruct-v0.1", token=HF_TOKEN)
+# # env = Environment(loader=FileSystemLoader(proj_dir / 'templates'))
+
+# # template = env.get_template('template.j2')
+# # template_html = env.get_template('template_html.j2')
+
+# # # def add_text(history, text):
+# # #     history = [] if history is None else history
+# # #     history = history + [(text, None)]
+# # #     return history, gr.Textbox(value="", interactive=False)
+
+# # def bot(history, cross_encoder):
+
+# #     top_rerank = 25
+# #     top_k_rank = 20
+# #     query = history[-1][0] if history else ''
+# #     print('\nQuery: ',query )
+# #     print('\nHistory:',history)
+# #     if not query:
+# #         gr.Warning("Please submit a non-empty string as a prompt")
+# #         raise ValueError("Empty string was submitted")
+
+# #     logger.warning('Retrieving documents...')
+    
+# #     if cross_encoder == '(HIGH ACCURATE) ColBERT':
+# #         gr.Warning('Retrieving using ColBERT.. First time query will take a minute for model to load..pls wait')
+# #         RAG = RAGPretrainedModel.from_pretrained("colbert-ir/colbertv2.0")
+# #         RAG_db = RAG.from_index('.ragatouille/colbert/indexes/cbseclass10index')
+# #         documents_full = RAG_db.search(query, k=top_k_rank)
+        
+# #         documents = [item['content'] for item in documents_full]
+# #         prompt = template.render(documents=documents, query=query)
+# #         prompt_html = template_html.render(documents=documents, query=query)
+    
+# #         generate_fn = generate_hf
+    
+# #         history[-1][1] = ""
+# #         for character in generate_fn(prompt, history[:-1]):
+# #             history[-1][1] = character
+# #             yield history, prompt_html
+# #     else:
+# #         document_start = perf_counter()
+    
+# #         query_vec = retriever.encode(query)
+# #         doc1 = table.search(query_vec, vector_column_name=VECTOR_COLUMN_NAME).limit(top_k_rank)
+    
+# #         documents = table.search(query_vec, vector_column_name=VECTOR_COLUMN_NAME).limit(top_rerank).to_list()
+# #         documents = [doc[TEXT_COLUMN_NAME] for doc in documents]
+    
+# #         query_doc_pair = [[query, doc] for doc in documents]
+# #         if cross_encoder == '(FAST) MiniLM-L6v2':
+# #             cross_encoder1 = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
+# #         elif cross_encoder == '(ACCURATE) BGE reranker':
+# #             cross_encoder1 = CrossEncoder('BAAI/bge-reranker-base')
+        
+# #         cross_scores = cross_encoder1.predict(query_doc_pair)
+# #         sim_scores_argsort = list(reversed(np.argsort(cross_scores)))
+        
+# #         documents = [documents[idx] for idx in sim_scores_argsort[:top_k_rank]]
+    
+# #         document_time = perf_counter() - document_start
+    
+# #         prompt = template.render(documents=documents, query=query)
+# #         prompt_html = template_html.render(documents=documents, query=query)
+    
+# #         #generate_fn = generate_hf
+# #         generate_fn=generate_qwen
+# #         # Create a new history entry instead of modifying the tuple directly
+# #         new_history = history[:-1] + [ (prompt, "") ] # query replaced prompt
+# #         output=''
+# #         # for character in generate_fn(prompt, history[:-1]):
+# #         #     #new_history[-1] = (query, character) 
+# #         #     output+=character
+# #         output=generate_fn(prompt, history[:-1])
+        
+# #         print('Output:',output)
+# #         new_history[-1] = (prompt, output) #query replaced with prompt
+# #         print('New History',new_history)
+# #         #print('prompt html',prompt_html)# Update the last tuple with new text
+        
+# #         history_list = list(history[-1])
+# #         history_list[1] = output  # Assuming `character` is what you want to assign
+# #         # Update the history with the modified list converted back to a tuple
+# #         history[-1] = tuple(history_list)
+
+# #             #history[-1][1] = character
+# #         # yield new_history, prompt_html
+# #         yield history, prompt_html
+# #          # new_history,prompt_html
+# #         # history[-1][1] = ""
+# #         # for character in generate_fn(prompt, history[:-1]):
+# #         #     history[-1][1] = character
+# #         #     yield history, prompt_html
+
+# # #def translate_text(response_text, selected_language):
+    
+# # def translate_text(selected_language,history):
+    
+# #     iso_language_codes = {
+# #         "Hindi": "hi",
+# #         "Gom": "gom",
+# #         "Kannada": "kn",
+# #         "Dogri": "doi",
+# #         "Bodo": "brx",
+# #         "Urdu": "ur",
+# #         "Tamil": "ta",
+# #         "Kashmiri": "ks",
+# #         "Assamese": "as",
+# #         "Bengali": "bn",
+# #         "Marathi": "mr",
+# #         "Sindhi": "sd",
+# #         "Maithili": "mai",
+# #         "Punjabi": "pa",
+# #         "Malayalam": "ml",
+# #         "Manipuri": "mni",
+# #         "Telugu": "te",
+# #         "Sanskrit": "sa",
+# #         "Nepali": "ne",
+# #         "Santali": "sat",
+# #         "Gujarati": "gu",
+# #         "Odia": "or"
+# #     }
+    
+# #     to_code = iso_language_codes[selected_language]
+# #     response_text = history[-1][1] if history else ''
+# #     print('response_text for translation',response_text)
+# #     translation = bhashini_translate(response_text, to_code=to_code)
+# #     return translation['translated_content']
+   
+
+# # # Gradio interface
+# # with gr.Blocks(theme='gradio/soft') as CHATBOT:
+# #     history_state = gr.State([])
+# #     with gr.Row():
+# #         with gr.Column(scale=10):
+# #             gr.HTML(value="""<div style="color: #FF4500;"><h1>Welcome! I am your friend!</h1>Ask me !I will help you<h1><span style="color: #008000">I AM A CHATBOT FOR 9 SCIENCE WITH TRANSLATION IN 22 LANGUAGES</span></h1></div>""")
+# #             gr.HTML(value=f"""<p style="font-family: sans-serif; font-size: 16px;">A free chat bot developed by K.M.RAMYASRI,TGT,GHS.SUTHUKENY using Open source LLMs for 10 std students</p>""")
+# #             gr.HTML(value=f"""<p style="font-family: Arial, sans-serif; font-size: 14px;"> Suggestions may be sent to <a href="mailto:[email protected]" style="color: #00008B; font-style: italic;">[email protected]</a>.</p>""")
+
+# #         with gr.Column(scale=3):
+# #             gr.Image(value='logo.png', height=200, width=200)
+
+# #     chatbot = gr.Chatbot(
+# #         [],
+# #         elem_id="chatbot",
+# #         avatar_images=('https://aui.atlassian.com/aui/8.8/docs/images/avatar-person.svg',
+# #                        'https://huggingface.co/datasets/huggingface/brand-assets/resolve/main/hf-logo.svg'),
+# #         bubble_full_width=False,
+# #         show_copy_button=True,
+# #         show_share_button=True,
+# #     )
+
+# #     with gr.Row():
+# #         txt = gr.Textbox(
+# #             scale=3,
+# #             show_label=False,
+# #             placeholder="Enter text and press enter",
+# #             container=False,
+# #         )
+# #         txt_btn = gr.Button(value="Submit text", scale=1)
+    
+# #     cross_encoder = gr.Radio(choices=['(FAST) MiniLM-L6v2', '(ACCURATE) BGE reranker', '(HIGH ACCURATE) ColBERT'], value='(ACCURATE) BGE reranker', label="Embeddings", info="Only First query to Colbert may take little time)")
+# #     language_dropdown = gr.Dropdown(
+# #         choices=[
+# #             "Hindi", "Gom", "Kannada", "Dogri", "Bodo", "Urdu", "Tamil", "Kashmiri", "Assamese", "Bengali", "Marathi",
+# #             "Sindhi", "Maithili", "Punjabi", "Malayalam", "Manipuri", "Telugu", "Sanskrit", "Nepali", "Santali",
+# #             "Gujarati", "Odia"
+# #         ],
+# #         value="Hindi",  # default to Hindi
+# #         label="Select Language for Translation"
+# #     )
+    
+# #     prompt_html = gr.HTML()
+    
+# #     translated_textbox = gr.Textbox(label="Translated Response")
+# #     def update_history_and_translate(txt, cross_encoder, history_state, language_dropdown):
+# #         print('History state',history_state)
+# #         history = history_state
+# #         history.append((txt, ""))
+# #         #history_state.value=(history)
         
-#         # Call bot function
-#         # bot_output = list(bot(history, cross_encoder))
-#         bot_output = next(bot(history, cross_encoder))
-#         print('bot_output',bot_output)
-#         #history, prompt_html = bot_output[-1]
-#         history, prompt_html = bot_output
-#         print('History',history)
-#         # Update the history state
-#         history_state[:] = history
+# #         # Call bot function
+# #         # bot_output = list(bot(history, cross_encoder))
+# #         bot_output = next(bot(history, cross_encoder))
+# #         print('bot_output',bot_output)
+# #         #history, prompt_html = bot_output[-1]
+# #         history, prompt_html = bot_output
+# #         print('History',history)
+# #         # Update the history state
+# #         history_state[:] = history
         
-#         # Translate text
-#         translated_text = translate_text(language_dropdown, history)
-#         return history, prompt_html, translated_text
+# #         # Translate text
+# #         translated_text = translate_text(language_dropdown, history)
+# #         return history, prompt_html, translated_text
 
-#     txt_msg = txt_btn.click(update_history_and_translate, [txt, cross_encoder, history_state, language_dropdown], [chatbot, prompt_html, translated_textbox])
-#     txt_msg = txt.submit(update_history_and_translate, [txt, cross_encoder, history_state, language_dropdown], [chatbot, prompt_html, translated_textbox])
+# #     txt_msg = txt_btn.click(update_history_and_translate, [txt, cross_encoder, history_state, language_dropdown], [chatbot, prompt_html, translated_textbox])
+# #     txt_msg = txt.submit(update_history_and_translate, [txt, cross_encoder, history_state, language_dropdown], [chatbot, prompt_html, translated_textbox])
 
-#     examples = ['WHAT IS DIFFERENCES BETWEEN HOMOGENOUS AND HETEROGENOUS MIXTURE?','WHAT IS COVALENT BOND?',
-#             'EXPLAIN GOLGI APPARATUS']            
+# #     examples = ['WHAT IS DIFFERENCES BETWEEN HOMOGENOUS AND HETEROGENOUS MIXTURE?','WHAT IS COVALENT BOND?',
+# #             'EXPLAIN GOLGI APPARATUS']            
 
-#     gr.Examples(examples, txt)
+# #     gr.Examples(examples, txt)
 
 
-# # Launch the Gradio application
-# CHATBOT.launch(share=True,debug=True)
+# # # Launch the Gradio application
+# # CHATBOT.launch(share=True,debug=True)