Spaces:
Sleeping
Sleeping
| 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 | |
| from jinja2 import Environment, FileSystemLoader | |
| from pathlib import Path | |
| import time | |
| # Set up logging | |
| logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') | |
| 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 = "" | |
| else: | |
| os.environ["GROQ_API_KEY"] = api_key | |
| # Bhashini API setup | |
| bhashini_api_key = os.getenv("API_KEY", "").strip() | |
| bhashini_user_id = os.getenv("USER_ID", "").strip() | |
| # 🎯 MODEL LIST: Ordered by parameter size (largest → smallest) | |
| # Fallback chain: if rate limit (429) or model error, try next model | |
| MODEL_CHAIN = [ | |
| {"id": "llama-3.3-70b-versatile", "name": "Llama 3.3 70B", "priority": 1}, | |
| {"id": "qwen/qwen3-32b", "name": "Qwen3 32B", "priority": 2}, | |
| {"id": "meta-llama/llama-4-scout-17b-16e-instruct", "name": "Llama-4 Scout 17B", "priority": 3}, | |
| {"id": "groq/compound", "name": "Groq Compound", "priority": 4}, | |
| {"id": "gemma2-9b-it", "name": "Gemma2 9B", "priority": 5}, | |
| {"id": "llama-3.1-8b-instant", "name": "Llama 3.1 8B Instant", "priority": 6}, | |
| ] | |
| def bhashini_translate(text: str, from_code: str = "en", to_code: str = "hi") -> dict: | |
| """Translates text using Bhashini API""" | |
| if not text.strip(): | |
| return {"status_code": 400, "message": "Input text is empty", "translated_content": None} | |
| print(f'Translating: "{text[:50]}..." from {from_code} 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"} | |
| } | |
| try: | |
| response = requests.post(url, json=payload, headers=headers, timeout=30) | |
| if response.status_code != 200: | |
| logger.error(f"Bhashini initial request failed: {response.status_code}") | |
| return {"status_code": response.status_code, "message": "Translation request failed", "translated_content": None} | |
| response_data = response.json() | |
| if "pipelineInferenceAPIEndPoint" not in response_data: | |
| return {"status_code": 400, "message": "Unexpected API response", "translated_content": None} | |
| service_id = response_data["pipelineResponseConfig"][0]["config"][0]["serviceId"] | |
| callback_url = response_data["pipelineInferenceAPIEndPoint"]["callbackUrl"] | |
| 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}]} | |
| } | |
| compute_response = requests.post(callback_url, json=compute_payload, headers=headers2, timeout=60) | |
| if compute_response.status_code != 200: | |
| return {"status_code": compute_response.status_code, "message": "Translation failed", "translated_content": None} | |
| compute_response_data = compute_response.json() | |
| translated_content = compute_response_data["pipelineResponse"][0]["output"][0]["target"] | |
| return {"status_code": 200, "message": "Success", "translated_content": translated_content} | |
| except Exception as e: | |
| logger.error(f"Bhashini translation error: {e}") | |
| return {"status_code": 500, "message": f"Translation error: {str(e)}", "translated_content": None} | |
| def create_agent_with_model(model_id: str) -> Agent: | |
| """Create a Phi Agent with specified Groq model - SOCIAL SCIENCE FOCUS""" | |
| return Agent( | |
| name="Social Science Education Assistant", | |
| role="You are a helpful social science tutor for 10th-grade students", | |
| instructions=[ | |
| "You are an expert social science teacher specializing in 10th-grade curriculum.", | |
| "Provide clear, accurate, and age-appropriate explanations on History, Geography, Civics, and Economics.", | |
| "Use simple language and real-world examples that students can relate to.", | |
| "Focus on key topics: Indian History, World History, Physical & Human Geography, Democratic Politics, Economic Development, and Contemporary Issues.", | |
| "Structure responses with headings, bullet points, and timelines when helpful.", | |
| "Encourage critical thinking about society, governance, and sustainable development.", | |
| "If uncertain, acknowledge limitations and suggest reliable sources like NCERT textbooks.", | |
| "Promote values of democracy, secularism, equality, and environmental responsibility." | |
| ], | |
| model=Groq(id=model_id, api_key=api_key), | |
| markdown=True, | |
| timeout=60 | |
| ) | |
| def generate_with_fallback(prompt: str) -> tuple[str, str]: | |
| """ | |
| Try models in descending size order. | |
| Returns: (response_text, model_used) | |
| """ | |
| last_error = None | |
| for model_config in MODEL_CHAIN: | |
| model_id = model_config["id"] | |
| model_name = model_config["name"] | |
| priority = model_config["priority"] | |
| logger.info(f"🔄 Trying model #{priority}: {model_name} ({model_id})") | |
| try: | |
| agent = create_agent_with_model(model_id) | |
| response = agent.run(prompt) | |
| response_text = response.content if hasattr(response, 'content') else str(response) | |
| logger.info(f"✅ Success with {model_name}") | |
| return response_text.strip(), model_name | |
| except Exception as e: | |
| error_msg = str(e).lower() | |
| last_error = e | |
| # Check for errors that warrant fallback to next model | |
| should_fallback = any([ | |
| "429" in error_msg, | |
| "rate limit" in error_msg, | |
| "too many requests" in error_msg, | |
| "model_decommissioned" in error_msg, | |
| "model_not_found" in error_msg, | |
| "invalid_request_error" in error_msg and "model" in error_msg, | |
| "timeout" in error_msg and priority < len(MODEL_CHAIN) | |
| ]) | |
| if should_fallback: | |
| logger.warning(f"⚠️ {model_name} failed ({type(e).__name__}), falling back to next model...") | |
| time.sleep(0.5 * priority) | |
| continue | |
| else: | |
| logger.error(f"❌ {model_name} failed with non-fallback error: {e}") | |
| break | |
| # All models failed | |
| error_details = f"{type(last_error).__name__}: {str(last_error)}" if last_error else "Unknown error" | |
| logger.error(f"💥 All models failed. Last error: {error_details}") | |
| fallback_response = ( | |
| "⚠️ I'm experiencing high demand right now. Please try again in a moment.\n\n" | |
| f"*Technical note: Unable to connect to available models ({error_details})*" | |
| ) | |
| return fallback_response, "fallback" | |
| def retrieve_and_generate_response(query, cross_encoder_choice, history=None): | |
| """Generate response using semantic search + multi-model LLM fallback""" | |
| top_rerank = 25 | |
| top_k_rank = 20 | |
| if not query.strip(): | |
| return "Please provide a valid question.", [], "N/A" | |
| 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 | |
| model_name = 'BAAI/bge-reranker-base' if cross_encoder_choice == '(ACCURATE) BGE reranker' else 'cross-encoder/ms-marco-MiniLM-L-6-v2' | |
| cross_encoder_model = CrossEncoder(model_name) | |
| 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 social science 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:]: | |
| if user_msg and bot_msg: | |
| history_context += f"Previous Q: {user_msg}\nPrevious A: {bot_msg}\n" | |
| # Create full prompt - SOCIAL SCIENCE FOCUS | |
| 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 social science topics including History, Geography, Civics, and Economics." | |
| # Generate response with model fallback chain | |
| response_text, model_used = generate_with_fallback(full_prompt) | |
| # Add model attribution to response | |
| if model_used != "fallback": | |
| response_text = f"*Powered by {model_used}*\n\n{response_text}" | |
| elapsed = perf_counter() - start_time | |
| logger.info(f"⏱️ Response generated in {elapsed:.2f}s using {model_used}") | |
| return response_text, documents, model_used | |
| except Exception as e: | |
| logger.error(f"❌ Error in response generation: {e}") | |
| return f"Error: {str(e)}", [], "error" | |
| 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.get(selected_language, "hi") | |
| response_text = history[-1][1] if history and len(history) > 0 and history[-1][1] else '' | |
| if not response_text or response_text.startswith("Error:"): | |
| return "Translation not available for error messages." | |
| # Remove model attribution line for cleaner translation | |
| clean_text = response_text.split("\n\n", 1)[-1] if "*Powered by" in response_text else response_text | |
| translation = bhashini_translate(clean_text, to_code=to_code) | |
| return translation.get('translated_content', 'Translation failed.') | |
| # Set up Jinja2 environment | |
| proj_dir = Path(__file__).parent | |
| env = Environment(loader=FileSystemLoader(proj_dir / 'templates')) | |
| template = env.get_template('template.j2') | |
| template_html = env.get_template('template_html.j2') | |
| # Gradio Interface - SOCIAL SCIENCE THEME | |
| with gr.Blocks(title="Social Science Chatbot", theme='gradio/soft', css=""" | |
| .model-badge { | |
| background: #e0f2fe; color: #0369a1; padding: 2px 8px; | |
| border-radius: 12px; font-size: 0.8em; font-weight: 500; | |
| display: inline-block; margin: 4px 0; | |
| } | |
| .gradio-container { max-width: 1200px !important; margin: auto; } | |
| """) as demo: | |
| # Header section - SOCIAL SCIENCE FOCUS | |
| with gr.Row(): | |
| with gr.Column(scale=10): | |
| gr.HTML(value="""<div style="color: #8B4513;"><h1>🌍 Welcome! I am your Social Science Friend!</h1><p>Ask me anything about History, Geography, Civics & Economics!</p><h2><span style="color: #228B22">✨ Multi-Model AI with 22-Language Translation</span></h2></div>""") | |
| gr.HTML(value="<p style='font-family: sans-serif; font-size: 14px; color: #666;'>Developed by K.M. Ramyasri, TGT, GHS Suthukeny • Open Source • Free for 10th Grade Students</p>") | |
| gr.HTML(value="<p style='font-family: Arial, sans-serif; font-size: 13px;'>Suggestions: <a href='mailto:ramyasriraman2019@gmail.com' style='color: #0066cc;'>ramyasriraman2019@gmail.com</a></p>") | |
| with gr.Column(scale=3): | |
| try: | |
| gr.Image(value='logo.png', height=180, width=180, show_label=False) | |
| except: | |
| gr.HTML("<div style='height: 180px; width: 180px; background: linear-gradient(135deg, #8B4513 0%, #D2691E 100%); border-radius: 50%; display: flex; align-items: center; justify-content: center; color: white; font-weight: bold; font-size: 3em;'>🗺️</div>") | |
| # Model status indicator (Markdown component) | |
| model_status = gr.Markdown(value="🔄 *Ready to answer with best available model*") | |
| # Chatbot | |
| 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, | |
| height=400 | |
| ) | |
| # Input row | |
| with gr.Row(): | |
| msg = gr.Textbox( | |
| scale=4, | |
| show_label=False, | |
| placeholder="Ask a social science question (e.g., 'What caused the French Revolution?')", | |
| container=False, | |
| autofocus=True | |
| ) | |
| submit_btn = gr.Button(value="🚀 Ask", scale=1, variant="primary") | |
| # Controls | |
| with gr.Row(): | |
| cross_encoder = gr.Radio( | |
| choices=['(FAST) MiniLM-L6v2', '(ACCURATE) BGE reranker'], | |
| value='(ACCURATE) BGE reranker', | |
| label="🔍 Document Ranking", | |
| info="Balance speed vs accuracy for source retrieval" | |
| ) | |
| 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="🌐 Translate Response To", | |
| scale=2 | |
| ) | |
| # Outputs | |
| with gr.Row(): | |
| translated_textbox = gr.Textbox(label="🌍 Translated Response", lines=3, interactive=False) | |
| prompt_html = gr.HTML(label="📚 Source Documents") | |
| # Event handler function - NO .update() calls, return values instead | |
| def update_chat_and_translate(message, history, cross_encoder_choice, selected_language): | |
| """Handler that returns all outputs in correct order""" | |
| # Handle empty message | |
| if not message.strip(): | |
| return "", history, "", "", "🔄 *Ready to answer with best available model*" | |
| # Generate response with fallback chain | |
| response, documents, model_used = retrieve_and_generate_response( | |
| message, cross_encoder_choice, history | |
| ) | |
| # Prepare markdown status as STRING (return value, not .update()) | |
| status_emoji = "✅" if model_used != "fallback" else "⚠️" | |
| model_status_text = f"{status_emoji} *Responded using: **{model_used}***" | |
| # Add to chat history | |
| history.append([message, response]) | |
| # Translate response | |
| translated_text = translate_text(selected_language, history) | |
| # Render HTML template | |
| prompt_html_content = template_html.render( | |
| documents=documents, | |
| query=message, | |
| model=model_used, | |
| timestamp=time.strftime("%H:%M:%S") | |
| ) | |
| # RETURN ALL VALUES IN EXACT ORDER MATCHING outputs=[...] | |
| # outputs=[msg, chatbot, translated_textbox, prompt_html, model_status] | |
| return ( | |
| "", # 1. msg: clear input textbox | |
| history, # 2. chatbot: updated conversation history | |
| translated_text, # 3. translated_textbox: translation result | |
| prompt_html_content, # 4. prompt_html: rendered source documents | |
| model_status_text # 5. model_status: markdown status (STRING) | |
| ) | |
| # Bind events - outputs order must match return tuple order | |
| msg.submit( | |
| update_chat_and_translate, | |
| inputs=[msg, chatbot, cross_encoder, language_dropdown], | |
| outputs=[msg, chatbot, translated_textbox, prompt_html, model_status] | |
| ) | |
| submit_btn.click( | |
| update_chat_and_translate, | |
| inputs=[msg, chatbot, cross_encoder, language_dropdown], | |
| outputs=[msg, chatbot, translated_textbox, prompt_html, model_status] | |
| ) | |
| # Clear button - return tuple matching its outputs order: [chatbot, msg, translated_textbox, prompt_html, model_status] | |
| clear = gr.Button("🗑️ Clear Conversation", variant="secondary") | |
| clear.click( | |
| lambda: ([], "", "", "", "🔄 *Ready to answer with best available model*"), | |
| outputs=[chatbot, msg, translated_textbox, prompt_html, model_status] | |
| ) | |
| # Example questions - SOCIAL SCIENCE FOCUS | |
| gr.Examples( | |
| examples=[ | |
| "What were the main causes of the Indian National Movement?", | |
| "Explain the features of the Indian Constitution", | |
| "What is sustainable development and why is it important?", | |
| "Describe the impact of globalization on Indian economy", | |
| "What are the major physical divisions of India?", | |
| "Explain the functioning of local government in India", | |
| "What led to the rise of nationalism in Europe?", | |
| "How does the electoral process work in a democracy?" | |
| ], | |
| inputs=msg, | |
| label="💡 Try these social science questions:" | |
| ) | |
| # Footer with technical details (collapsible) | |
| gr.Markdown(""" | |
| <details> | |
| <summary>🔧 Technical: Model Fallback Chain (Largest → Smallest)</summary> | |
| | Priority | Model | Parameters | Use Case | | |
| |----------|-------|-----------|----------| | |
| | 1 | Llama 3.3 70B | ~70B | Complex reasoning, highest accuracy | | |
| | 2 | Qwen3 32B | ~32B | Strong multilingual & social science performance | | |
| | 3 | Llama-4 Scout 17B | ~17B | Balanced speed/quality | | |
| | 4 | Groq Compound | ~12B | Specialized mixture model | | |
| | 5 | Gemma2 9B | ~9B | Fast responses, good quality | | |
| | 6 | Llama 3.1 8B Instant | ~8B | ⚡ Fastest fallback, lowest cost | | |
| *If a model hits rate limits or errors, the system automatically tries the next model.* | |
| </details> | |
| """) | |
| if __name__ == "__main__": | |
| logger.info("🚀 Starting Social Science Chatbot with multi-model fallback...") | |
| logger.info(f"Model chain: {[m['name'] for m in MODEL_CHAIN]}") | |
| logger.info("📚 Focus: History, Geography, Civics, Economics (10th Grade)") | |
| demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True) | |
| # 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 | |
| # from jinja2 import Environment, FileSystemLoader | |
| # from pathlib import Path | |
| # # 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", "").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.""" | |
| # 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 | |
| # } | |
| # 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"} | |
| # } | |
| # 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} | |
| # print('Initial request successful, processing response...') | |
| # response_data = response.json() | |
| # 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} | |
| # 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}, 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 | |
| # ) | |
| # # 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""" | |
| # 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, documents # Return documents for template | |
| # 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 and get documents | |
| # response, documents = retrieve_and_generate_response(message, cross_encoder_choice, history) | |
| # # Add to history | |
| # history.append([message, response]) | |
| # # 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.""" | |
| # 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:ramyasriraman2019@gmail.com" style="color: #00008B; font-style: italic;">ramyadevi1607@yahoo.com</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") | |
| # 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, "", "" | |
| # # 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) | |
| # # 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, 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, prompt_html]) | |
| # # 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 | |
| # # 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 | |
| # # 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 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} | |
| # # 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"] | |
| # # 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}, 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 | |
| # # ) | |
| # # # Set up Jinja2 environment | |
| # # proj_dir = Path(__file__).parent | |
| # # env = Environment(loader=FileSystemLoader(proj_dir / 'templates')) | |
| # # 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 | |
| # # 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" | |
| # # } | |
| # # 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:ramyasriraman2019@gmail.com" style="color: #00008B; font-style: italic;">ramyadevi1607@yahoo.com</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]) | |
| # # # 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)# import gradio as gr | |