Update app.py

app.py

@@ -1,12 +1,12 @@
 import gradio as gr
 from graph_tool import generate_plot
 from metrics import EduBotMetrics
-from together import Together
 import os
 import time
 import logging
 import json
 import re
+import requests
 
 # --- Environment and Logging Setup ---
 logging.basicConfig(level=logging.INFO)
@@ -17,13 +17,13 @@ hf_token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACEHUB_API_TOKE
 if not hf_token:
     logger.warning("Neither HF_TOKEN nor HUGGINGFACEHUB_API_TOKEN is set, the application may not work.")
 
-# --- LLM Configuration ---
-client = Together(api_key=hf_token)
+# --- HF API Configuration ---
+HF_API_URL = "https://api-inference.huggingface.co/models/Qwen/Qwen2.5-7B-Instruct"
+HF_HEADERS = {"Authorization": f"Bearer {hf_token}"}
 
 metrics_tracker = EduBotMetrics(save_file="edu_metrics.json")
 
 # --- Tools ---
-
 tools = [
     {
         "type": "function",
@@ -47,7 +47,6 @@ tools = [
 ]
 
 # --- LLM Templates ---
-# Enhanced base system message
 SYSTEM_MESSAGE = """You are EduBot, an expert multi-concept tutor designed to facilitate genuine learning and understanding. Your primary mission is to guide students through the learning process rather than providing direct answers to academic work.
 
 ## Core Educational Principles
@@ -75,20 +74,23 @@ You recognize that students may seek direct answers to homework, assignments, or
 - **Encourage original thinking**: Help students develop their own reasoning and analytical skills
 - **Suggest study strategies**: Recommend effective learning approaches for the subject matter
 
+## Tool Usage
+You have access to a create_graph tool that can generate bar charts, line graphs, and pie charts. Use this tool when:
+- A visual representation would help explain a concept
+- The student asks for data visualization
+- Creating practice problems that involve interpreting charts
+- Demonstrating mathematical relationships visually
+
+When using the create_graph tool, provide JSON-formatted data and labels. For example:
+- data_json: '{"Math": 85, "Science": 92, "English": 78}'
+- labels_json: '["Math", "Science", "English"]'
+
 ## Response Guidelines
 - **For math problems**: Explain concepts, provide formula derivations, and guide through problem-solving steps without computing final numerical answers
 - **For multiple-choice questions**: Discuss the concepts being tested and help students understand how to analyze options rather than identifying the correct choice
 - **For essays or written work**: Discuss research strategies, organizational techniques, and critical thinking approaches rather than providing content or thesis statements
 - **For factual questions**: Provide educational context and encourage students to synthesize information rather than stating direct answers
 
-## Handling Limitations
-**Web Search Requests**: You do not have access to the internet and cannot perform web searches. When asked to search the web, respond honestly about this limitation and offer alternative assistance:
-- "I'm unable to perform web searches, but I can help you plan a research strategy for this topic"
-- "I can't browse the internet, but I'd be happy to teach you effective Google search syntax to find what you need"
-- "While I can't search online, I can help you evaluate whether sources you find are reliable and appropriate for your research"
-
-**Other Limitations**: When encountering other technical limitations, acknowledge them directly and offer constructive alternatives that support learning. You are also unable to create images or attach images to your response. Never pretend to say that an image is in a response.
-
 ## Communication Guidelines
 - Maintain a supportive, non-judgmental tone in all interactions
 - Assume positive intent while redirecting toward genuine learning
@@ -97,59 +99,6 @@ You recognize that students may seek direct answers to homework, assignments, or
 - Encourage students to explain their thinking and reasoning
 - Provide honest, accurate feedback even when it may not be what the student wants to hear
 
-## Modes
-**Select the mode that best matches the user's needs.**
-
-**Math Mode**
-LaTeX formatting is enabled for math. You must provide LaTeX formatting for all math, either as inline LaTeX or centered display LaTeX.
-You will address requests to solve, aid in understanding, or explore mathematical context. Use logical ordering for content, providing necessary terms and definitions as well as concept explanations along with math to foster understanding of core concepts. Rather than specifically answering the math problem provided, begin with solving a similar problem that requires the same steps and foundational mathematical knowledge, then prompt the user to work through the problem themselves. If the user insists you solve the problem, engage in a two-way conversation where you provide the steps but request the user solve for the answer one step at a time.
-LaTeX should always be used for math.
-LaTeX Examples:
-- Inline: "The slope is $m = \\frac{{y_2 - y_1}}{{x_2 - x_1}}$ in this case."
-- Display: "The quadratic formula is: $x = \\frac{{-b \\pm \\sqrt{{b^2-4ac}}}}{{2a}}$"
-Always use double backslashes (\\\\) for LaTeX commands like \\\\frac, \\\\sqrt, \\\\int, etc.
-
-**Research Mode**
-Your main goal is to help the user learn to research topics, a critical skill. Function as a partner rather than a search engine.
-Over the course of the conversation, guide the user through a seven-step research process:
-1) **Identifying a topic**
-2) **Finding background information**
-3) **Developing a research design**
-4) **Collecting data**
-5) **Analyzing data**
-6) **Drawing conclusions**
-7) **Disseminating findings**
-You may provide formatted citations if the user asks for them and provides the needed information. If not all information is provided but citations are requested, follow up with guidance on how to obtain the information to generate a citation. By default, you will not provide citations.
-Example citations:
-APA Style
-In-text: (Smith, 2023, p. 45)
-Reference: Smith, J. A. (2023). Book title. Publisher.
-MLA Style
-In-text: (Smith 45)
-Works Cited: Smith, John A. Book Title. Publisher, 2023.
-Chicago Style
-Footnote: ¹John A. Smith, Book Title (Publisher, 2023), 45.
-Bibliography: Smith, John A. Book Title. Publisher, 2023.
-Harvard Style
-In-text: (Smith 2023, p. 45)
-Reference: Smith, J.A. (2023) Book title. Publisher.
-IEEE Style
-In-text: [1]
-Reference: [1] J. A. Smith, Book Title. Publisher, 2023.
-In this mode you may not use LaTeX formatting.
-
-**Study Mode**
-Engage the user in a mix of two teaching styles: student-centered and inquiry-based learning.
-Student Centered: Adjust to reflect the student's reading level and level of understanding of a topic as the conversation progresses. Do not assume the user is an expert but instead assume they may have familiarity but desire to learn more about the topic they are studying. Provide definitions for terms you use in a conversational way, gradually shifting to using just the terms without definitions as the user becomes more familiar with them.
-Inquiry-based learning: Engage the user through questions that compel them to consider what they want to know and then explore the topics through guided conversation.
-Over the course of the conversation, prompt the user with a question to gauge their growing knowledge or progress on the topic. 
-For example: 
-After two to three turns of conversation discussing a topic, pick a specific term or concept from the conversation history to craft either a multiple-choice or written answer question for the user with no other comments along with it. If the student is correct, congratulate them on their progress and inquire about their next learning goal on the topic. If the user fails the question, return with a short response that explains the correct answer in a kind tone.
-In this mode you may not use LaTeX formatting.
-
-**General/Other Mode**
-You are EduBot, a comprehensive AI learning assistant. Help users leverage educational tools and resources to enrich their education. Offer yourself as a resource for the student, prompting them to request help with **math topics**, **research strategy**, or **studying a topic**.
-
 Your goal is to be an educational partner who empowers students to succeed through understanding, not a service that completes their work for them."""
 
 # --- Core Logic Functions ---
@@ -168,97 +117,180 @@ def smart_truncate(text, max_length=3000):
         words = text[:max_length].split()
         return ' '.join(words[:-1]) + "... [Response truncated - ask for continuation]"
 
+def detect_tool_request(text):
+    """Simple heuristic to detect when a graph might be helpful."""
+    graph_keywords = [
+        "chart", "graph", "plot", "visualize", "show data", "bar chart", 
+        "line graph", "pie chart", "diagram", "compare", "data visualization"
+    ]
+    text_lower = text.lower()
+    return any(keyword in text_lower for keyword in graph_keywords)
+
+def call_hf_api(messages, max_retries=3):
+    """Call Hugging Face API with retry logic."""
+    payload = {
+        "inputs": format_messages_for_hf(messages),
+        "parameters": {
+            "max_new_tokens": 1024,
+            "temperature": 0.7,
+            "top_p": 0.9,
+            "return_full_text": False
+        }
+    }
+    
+    for attempt in range(max_retries):
+        try:
+            response = requests.post(HF_API_URL, headers=HF_HEADERS, json=payload, timeout=30)
+            
+            if response.status_code == 503:
+                # Model is loading
+                if attempt < max_retries - 1:
+                    wait_time = 10 + (attempt * 5)
+                    logger.info(f"Model loading, waiting {wait_time} seconds...")
+                    time.sleep(wait_time)
+                    continue
+                else:
+                    return "The model is currently loading. Please try again in a few moments."
+            
+            response.raise_for_status()
+            result = response.json()
+            
+            if isinstance(result, list) and len(result) > 0:
+                return result[0].get('generated_text', '').strip()
+            else:
+                return "I apologize, but I received an unexpected response format. Please try again."
+                
+        except requests.exceptions.Timeout:
+            if attempt < max_retries - 1:
+                logger.warning(f"Request timeout, retrying... (attempt {attempt + 1})")
+                time.sleep(2)
+                continue
+            else:
+                return "I'm sorry, the request timed out. Please try again."
+        except requests.exceptions.RequestException as e:
+            if attempt < max_retries - 1:
+                logger.warning(f"Request failed: {e}, retrying... (attempt {attempt + 1})")
+                time.sleep(2)
+                continue
+            else:
+                return f"I'm sorry, there was an error connecting to the service: {str(e)}"
+    
+    return "I'm sorry, I encountered an error and couldn't generate a response."
+
+def format_messages_for_hf(messages):
+    """Format messages for HF API."""
+    formatted = ""
+    for msg in messages:
+        role = msg["role"]
+        content = msg["content"]
+        if role == "system":
+            formatted += f"System: {content}\n\n"
+        elif role == "user":
+            formatted += f"Human: {content}\n\n"
+        elif role == "assistant":
+            formatted += f"Assistant: {content}\n\n"
+    
+    formatted += "Assistant: "
+    return formatted
+
+def process_response_for_tools(response_text, original_query):
+    """Check if we should generate a graph based on the response and query."""
+    # Simple heuristic - if the response mentions creating a chart/graph or the query requested one
+    should_create_graph = (
+        detect_tool_request(original_query) or 
+        any(phrase in response_text.lower() for phrase in [
+            "let me create a", "i'll make a", "here's a chart", "here's a graph"
+        ])
+    )
+    
+    if should_create_graph:
+        # Try to extract data from context or create a simple example
+        if "grade" in original_query.lower() or "score" in original_query.lower():
+            data_json = '{"Math": 85, "Science": 92, "English": 78, "History": 88}'
+            labels_json = '["Math", "Science", "English", "History"]'
+            title = "Sample Grade Distribution"
+            plot_type = "bar"
+        elif "population" in original_query.lower():
+            data_json = '{"City A": 1200000, "City B": 950000, "City C": 800000}'
+            labels_json = '["City A", "City B", "City C"]'
+            title = "Population Comparison"
+            plot_type = "bar"
+        elif "time" in original_query.lower() or "trend" in original_query.lower():
+            data_json = '{"Jan": 20, "Feb": 25, "Mar": 30, "Apr": 28, "May": 35}'
+            labels_json = '["Jan", "Feb", "Mar", "Apr", "May"]'
+            title = "Monthly Trends"
+            plot_type = "line"
+        else:
+            # Default example
+            data_json = '{"Category A": 30, "Category B": 25, "Category C": 20, "Category D": 25}'
+            labels_json = '["Category A", "Category B", "Category C", "Category D"]'
+            title = "Sample Data Distribution"
+            plot_type = "pie"
+        
+        try:
+            graph_html = generate_plot(data_json, labels_json, plot_type, title)
+            response_text += f"\n\n{graph_html}"
+        except Exception as e:
+            logger.error(f"Error generating graph: {e}")
+            response_text += f"\n\n<p style='color:orange;'>I tried to create a visualization but encountered an error. The concept explanation above should still be helpful!</p>"
+    
+    return response_text
+
 def respond_with_enhanced_streaming(message, history):
-    """Streams the bot's response, handling tool calls and errors with metrics tracking."""
+    """Generate response using HF API with tool support."""
     timing_context = metrics_tracker.start_timing()
     error_occurred = False
     error_message = None
     full_response = ""
     
     try:
+        # Prepare messages for API
         api_messages = [{"role": "system", "content": SYSTEM_MESSAGE}]
+        
         if history:
-            # Handle the new messages format from Gradio
-            for exchange in history[-5:]:  # Only use last 5 exchanges for context
+            # Handle message history
+            for exchange in history[-5:]:  # Use last 5 exchanges
                 if isinstance(exchange, dict):
-                    # New format: {"role": "user", "content": "..."}
                     api_messages.append(exchange)
                 else:
-                    # Old format: [user_message, assistant_message]
-                    api_messages.append({"role": "user", "content": exchange[0]})
-                    api_messages.append({"role": "assistant", "content": exchange[1]})
+                    # Fallback for other formats
+                    api_messages.append({"role": "user", "content": str(exchange[0])})
+                    api_messages.append({"role": "assistant", "content": str(exchange[1])})
         
         api_messages.append({"role": "user", "content": message})
         
         metrics_tracker.mark_provider_start(timing_context)
         
-        stream = client.chat.completions.create(
-            model="Qwen/Qwen2.5-7B-Instruct",
-            messages=api_messages,
-            max_tokens=4096,
-            temperature=0.7,
-            top_p=0.9,
-            stream=True,
-            tools=tools,
-        )
+        # Get response from HF API
+        response_text = call_hf_api(api_messages)
+        
+        # Process response for potential tool usage
+        response_text = process_response_for_tools(response_text, message)
         
-        # Buffers to handle multi-chunk tool calls
-        tool_call_name = ""
-        tool_call_args_str = ""
-
-        for chunk in stream:
-            # Check if chunk has choices and handle accordingly
-            if hasattr(chunk, 'choices') and chunk.choices and len(chunk.choices) > 0:
-                choice = chunk.choices[0]
-                
-                # Handle text chunks
-                if hasattr(choice, 'delta') and hasattr(choice.delta, 'content') and choice.delta.content:
-                    text_chunk = choice.delta.content
-                    full_response += text_chunk
-                    yield full_response
-                
-                # Handle tool call chunks
-                if hasattr(choice, 'delta') and hasattr(choice.delta, 'tool_calls') and choice.delta.tool_calls:
-                    tool_call_delta = choice.delta.tool_calls[0]
-                    
-                    # Accumulate name and arguments from stream
-                    if hasattr(tool_call_delta, 'function'):
-                        if hasattr(tool_call_delta.function, 'name') and tool_call_delta.function.name:
-                            tool_call_name = tool_call_delta.function.name
-                        if hasattr(tool_call_delta.function, 'arguments') and tool_call_delta.function.arguments:
-                            tool_call_args_str += tool_call_delta.function.arguments
-                    
-                    # Check if we have received the full tool call
-                    if tool_call_name and '}' in tool_call_args_str:
-                        try:
-                            tool_args = json.loads(tool_call_args_str)
-                            if tool_call_name == "create_graph":
-                                logger.info(f"Executing tool: {tool_call_name} with args: {tool_args}")
-                                graph_html = generate_plot(**tool_args)
-                                full_response += graph_html
-                                yield full_response
-                            
-                            # Reset buffers
-                            tool_call_name = ""
-                            tool_call_args_str = ""
-
-                        except json.JSONDecodeError:
-                            logger.error("JSON parsing failed for tool arguments.")
-                            full_response += f"<p style='color:red;'>Error parsing graph data.</p>"
-                            yield full_response
-                        except Exception as e:
-                            logger.exception("Error executing tool")
-                            full_response += f"<p style='color:red;'>Error executing tool: {e}</p>"
-                            yield full_response
-
         metrics_tracker.mark_provider_end(timing_context)
+        
+        # Simulate streaming by yielding chunks
+        words = response_text.split()
+        current_response = ""
+        
+        for i, word in enumerate(words):
+            current_response += word + " "
+            if i % 3 == 0:  # Yield every 3 words to simulate streaming
+                yield current_response.strip()
+                time.sleep(0.01)  # Small delay to simulate streaming
+        
+        # Final yield with complete response
+        full_response = current_response.strip()
+        yield full_response
+        
         logger.info(f"Response completed. Length: {len(full_response)} characters")
         
     except Exception as e:
         error_occurred = True
         error_message = str(e)
         logger.exception("Error in response generation")
-        yield "Sorry, an error occurred while generating the response."
+        full_response = "Sorry, an error occurred while generating the response."
+        yield full_response
 
     finally:
         metrics_tracker.log_interaction(
@@ -327,7 +359,7 @@ def respond_and_update(message, history):
     # Add user message to history
     history.append({"role": "user", "content": message})
     # Yield history to show the user message immediately, and clear the textbox
-    yield history, "" 
+    yield history, ""
 
     # Stream the bot's response
     full_response = ""
@@ -372,9 +404,9 @@ def create_interface():
                     show_share_button=False,
                     avatar_images=None,
                     elem_id="main-chatbot",
-                    container=False,  # Remove wrapper
+                    container=False,
                     scale=1,
-                    height="70vh"  # Explicit height instead of min_height
+                    height="70vh"
                 )
             
             # Input Section - fixed height
@@ -406,5 +438,4 @@ def create_interface():
 if __name__ == "__main__":
     logger.info("Starting EduBot...")
     demo = create_interface()
-    demo.launch(debug=True, share=True)
-    
+    demo.launch(debug=True, share=True)