Added Graph Generating Functionality

app.py

@@ -29,7 +29,7 @@ tools = [
         "type": "function",
         "function": {
             "name": "create_graph",
-            "description": "Generates a plot (bar, line, or pie) and returns it as an HTML-formatted Base64-encoded image string. The data and labels arguments must be JSON-encoded strings. Use simple, descriptive labels for plots. Use this tool to produce plots for practice questions, data visualization use cases, or any other case where the student may benefit from a graph.",
+            "description": "Generates a plot (bar, line, or pie) and returns it as an HTML-formatted Base64-encoded image string. Use this tool when teaching concepts that benefit from visual representation, such as: statistical distributions, mathematical functions, data comparisons, survey results, grade analyses, scientific relationships, economic models, or any quantitative information that would be clearer with a graph. The data and labels arguments must be JSON-encoded strings.",
             "parameters": {
                 "type": "object",
                 "properties": {
@@ -75,21 +75,34 @@ You recognize that students may seek direct answers to homework, assignments, or
 - **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
+You have access to a create_graph tool. Use this tool naturally when a visual representation would enhance understanding or when discussing concepts that involve data, relationships, patterns, or quantitative information. Consider creating graphs for:
+- Mathematical concepts (functions, distributions, relationships)
+- Statistical examples and explanations
+- Scientific data and relationships
+- Practice problems involving graph interpretation
+- Comparative analyses
+- Economic models or business concepts
+- Any situation where visualization aids comprehension
 
-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"]'
+When using the create_graph tool, format data as JSON strings:
+- data_json: '{"Category1": 25, "Category2": 40, "Category3": 35}'
+- labels_json: '["Category1", "Category2", "Category3"]'
+
+## Function Calling Format
+When you need to create a graph, use this exact format:
+
+<function_call>
+{"name": "create_graph", "arguments": {"data_json": "{\"key1\": value1, \"key2\": value2}", "labels_json": "[\"label1\", \"label2\"]", "plot_type": "bar|line|pie", "title": "Graph Title", "x_label": "X Axis Label", "y_label": "Y Axis Label"}}
+</function_call>
+
+The graph will be automatically generated and displayed in your response.
 
 ## 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
+- Use graphs naturally when they would clarify or enhance your explanations
 
 ## Communication Guidelines
 - Maintain a supportive, non-judgmental tone in all interactions
@@ -103,6 +116,41 @@ Your goal is to be an educational partner who empowers students to succeed throu
 
 # --- Core Logic Functions ---
 
+def execute_function_call(function_name, function_args):
+    """Execute the called function and return the result."""
+    if function_name == "create_graph":
+        try:
+            return generate_plot(
+                data_json=function_args.get("data_json", "{}"),
+                labels_json=function_args.get("labels_json", "[]"),
+                plot_type=function_args.get("plot_type", "bar"),
+                title=function_args.get("title", "Graph"),
+                x_label=function_args.get("x_label", ""),
+                y_label=function_args.get("y_label", "")
+            )
+        except Exception as e:
+            return f"<p style='color:red;'>Error creating graph: {str(e)}</p>"
+    else:
+        return f"<p style='color:red;'>Unknown function: {function_name}</p>"
+
+def parse_function_calls(text):
+    """Parse function calls from model response."""
+    function_calls = []
+    
+    # Look for function call patterns in the text
+    function_pattern = r'<function_call>(.*?)</function_call>'
+    matches = re.findall(function_pattern, text, re.DOTALL)
+    
+    for match in matches:
+        try:
+            # Parse the function call JSON
+            call_data = json.loads(match.strip())
+            function_calls.append(call_data)
+        except json.JSONDecodeError:
+            continue
+    
+    return function_calls
+
 def smart_truncate(text, max_length=3000):
     """Truncates text intelligently to the last full sentence or word."""
     if len(text) <= max_length:
@@ -113,7 +161,31 @@ def smart_truncate(text, max_length=3000):
     if len(sentences) > 1:
         return ' '.join(sentences[:-1]) + "... [Response truncated - ask for continuation]"
     # Otherwise, split by word
-+            "top_p": 0.9,
+    words = text[:max_length].split()
+    return ' '.join(words[:-1]) + "... [Response truncated]"
+
+def generate_response_with_tools(messages, max_retries=3):
+    """Generate response with function calling capability."""
+    
+    # Format messages for the API
+    formatted_messages = []
+    formatted_messages.append(f"System: {SYSTEM_MESSAGE}")
+    
+    for msg in messages:
+        if msg["role"] == "user":
+            formatted_messages.append(f"User: {msg['content']}")
+        elif msg["role"] == "assistant":
+            formatted_messages.append(f"Assistant: {msg['content']}")
+    
+    conversation = "\n\n".join(formatted_messages)
+    conversation += "\n\nAssistant: "
+    
+    payload = {
+        "inputs": conversation,
+        "parameters": {
+            "max_new_tokens": 1000,
+            "temperature": 0.7,
+            "top_p": 0.9,
             "return_full_text": False
         }
     }
@@ -136,276 +208,87 @@ def smart_truncate(text, max_length=3000):
             result = response.json()
             
             if isinstance(result, list) and len(result) > 0:
-                return result[0].get('generated_text', '').strip()
+                raw_response = result[0].get('generated_text', '').strip()
+                
+                # Process function calls
+                function_calls = parse_function_calls(raw_response)
+                
+                for call in function_calls:
+                    if call.get("name") == "create_graph":
+                        # Execute the function call
+                        html_result = execute_function_call("create_graph", call.get("arguments", {}))
+                        # Replace the function call with the generated HTML
+                        pattern = r'<function_call>.*?</function_call>'
+                        raw_response = re.sub(pattern, html_result, raw_response, count=1, flags=re.DOTALL)
+                
+                return smart_truncate(raw_response)
             else:
                 return "I apologize, but I received an unexpected response format. Please try again."
                 
-        except requests.exceptions.Timeout:
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Request failed (attempt {attempt + 1}): {e}")
             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:
+                return f"I'm having trouble connecting right now. Please try again later. (Error: {e})"
+        except Exception as e:
+            logger.error(f"Unexpected error (attempt {attempt + 1}): {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, with support for graph generation."""
-    timing_context = metrics_tracker.start_timing()
-    error_occurred = False
-    response = ""
-    mode = ""
+                return f"An unexpected error occurred: {e}"
 
+def chat_response(message, history):
+    """Process chat message and return response."""
     try:
-        # ---- Call HuggingFace Inference ----
-        payload = {
-            "inputs": message,
-            "parameters": {"return_full_text": False},
-        }
-        headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
-        api_response = requests.post(HF_API_URL, headers=headers, json=payload)
-        api_response.raise_for_status()
-        outputs = api_response.json()
-
-        # HuggingFace might return [{"generated_text": "..."}]
-        model_output = outputs[0].get("generated_text", "").strip()
-
-        # ---- Check if it's a tool call ----
-        try:
-            parsed = json.loads(model_output)
-            if isinstance(parsed, dict) and parsed.get("name") == "create_graph":
-                args = parsed.get("arguments", {})
-                graph_html = generate_plot(
-                    args.get("data_json", "{}"),
-                    args.get("labels_json", "[]"),
-                    args.get("plot_type", "bar"),
-                    args.get("title", "Untitled"),
-                    args.get("x_label", ""),
-                    args.get("y_label", "")
-                )
-                response = graph_html
-                mode = "graph"
-            else:
-                response = model_output
-                mode = "text"
-        except json.JSONDecodeError:
-            # Not JSON → just plain text
-            response = model_output
-            mode = "text"
-
+        # Track metrics
+        metrics_tracker.log_interaction(message, "user_query")
+        
+        # Format conversation history
+        messages = []
+        for user_msg, bot_msg in history:
+            messages.append({"role": "user", "content": user_msg})
+            if bot_msg:
+                messages.append({"role": "assistant", "content": bot_msg})
+        messages.append({"role": "user", "content": message})
+        
+        # Generate response with tool support
+        response = generate_response_with_tools(messages)
+        
+        # Log metrics
+        metrics_tracker.log_interaction(response, "bot_response")
+        
+        return response
+        
     except Exception as e:
-        error_occurred = True
-        response = f"⚠️ Error: {str(e)}"
-        mode = "error"
-
-    finally:
-        metrics_tracker.stop_timing(timing_context, error_occurred)
-
-    return response, mode
-
-
-# ===============================================================================
-# UI CONFIGURATION SECTION - ALL UI RELATED CODE CENTRALIZED HERE
-# ===============================================================================
+        logger.error(f"Error in chat_response: {e}")
+        return f"I apologize, but I encountered an error while processing your message: {str(e)}"
 
-# --- UI: HTML Head Content ---
-html_head_content = '''
-<link rel="preconnect" href="https://fonts.googleapis.com">
-<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-<link href="https://fonts.googleapis.com/css2?family=Oswald:wght@200..700&display=swap" rel="stylesheet">
-<script src="https://polyfill.io/v3/polyfill.min.js?features=es6"></script>
-<script>
-// Force light theme in Gradio
-window.addEventListener('DOMContentLoaded', function () {
-    const gradioURL = window.location.href;
-    const url = new URL(gradioURL);
-    const currentTheme = url.searchParams.get('__theme');
-    
-    if (currentTheme !== 'light') {
-        url.searchParams.set('__theme', 'light');
-        window.location.replace(url.toString());
-    }
-});
-</script>
-'''
-
-# --- UI: MathJax Configuration ---
-mathjax_config = '''
-<script>
-window.MathJax = {
-  tex: {
-    inlineMath: [['$', '$'], ['\\\\(', '\\\\)']],
-    displayMath: [['$$', '$$'], ['\\\\[', '\\\\]']],
-    packages: {'[+]': ['ams']}
-  },
-  svg: {fontCache: 'global'},
-  startup: {
-    ready: () => {
-      MathJax.startup.defaultReady();
-      // Re-render math when new content is added
-      const observer = new MutationObserver(function(mutations) {
-        MathJax.typesetPromise();
-      });
-      observer.observe(document.body, {childList: true, subtree: true});
-    }
-  }
-};
-</script>
-'''
-
-# --- UI: Event Handlers ---
-def respond_and_update(message, history):
-    """Main function to handle user submission."""
-    if not message.strip():
-        return 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, ""
-
-    # Stream the bot's response
-    full_response = ""
-    for response_chunk in respond_with_enhanced_streaming(message, history):
-        full_response = response_chunk
-        # Update the last message (bot's response)
-        if len(history) > 0 and history[-1]["role"] == "user":
-            history.append({"role": "assistant", "content": full_response})
-        else:
-            history[-1] = {"role": "assistant", "content": full_response}
-        yield history, ""
-
-def clear_chat():
-    """Clear the chat history."""
-    return [], ""
-
-# --- UI: Interface Creation ---
+# --- Gradio Interface (UNCHANGED) ---
 def create_interface():
-    """Creates and configures the complete Gradio interface."""
+    """Create and return the Gradio interface."""
     
-    with gr.Blocks(
-        title="EduBot", 
-        fill_width=True, 
-        fill_height=True,
-        theme=gr.themes.Origin(),
-        css="./styles.css"
-    ) as demo:
-        # Add head content and MathJax
-        gr.HTML(html_head_content)
-        gr.HTML('<script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>')
-        gr.HTML(mathjax_config)
+    with gr.Blocks(title="EduBot - AI Tutor", theme=gr.themes.Soft()) as interface:
         
-        with gr.Column(elem_classes=["main-container"]):
-            # Title Section
-            gr.HTML('<div class="title-header"><h1>🎓 EduBot</h1></div>')
-            
-            # Chat Section
-            with gr.Row():
-                chatbot = gr.Chatbot(
-                    type="messages",
-                    show_copy_button=True,
-                    show_share_button=False,
-                    avatar_images=None,
-                    elem_id="main-chatbot",
-                    container=False,
-                    scale=1,
-                    height="70vh"
-                )
-            
-            # Input Section - fixed height
-            with gr.Row(elem_classes=["input-controls"]):
-                msg = gr.Textbox(
-                    placeholder="Ask me about math, research, study strategies, or any educational topic...",
-                    show_label=False,
-                    lines=4,
-                    max_lines=6,
-                    elem_classes=["input-textbox"],
-                    container=False,
-                    scale=4
-                )
-                with gr.Column(elem_classes=["button-column"], scale=1):
-                    send = gr.Button("Send", elem_classes=["send-button"], size="sm")
-                    clear = gr.Button("Clear", elem_classes=["clear-button"], size="sm")
-
-        # Set up event handlers
-        msg.submit(respond_and_update, [msg, chatbot], [chatbot, msg])
-        send.click(respond_and_update, [msg, chatbot], [chatbot, msg])
-        clear.click(clear_chat, outputs=[chatbot, msg])
+        gr.Markdown("# EduBot - Your AI Learning Companion")
         
-        return demo
-
-# ===============================================================================
-# END UI CONFIGURATION SECTION
-# ===============================================================================
+        chatbot = gr.Chatbot(height=400, show_label=False)
+        msg = gr.Textbox(label="Ask me anything!", placeholder="Type your question here...")
+        
+        msg.submit(chat_response, [msg, chatbot], [chatbot])
+        msg.submit(lambda: "", None, [msg])
+    
+    return interface
 
+# --- Main Execution ---
 if __name__ == "__main__":
-    logger.info("Starting EduBot...")
-    demo = create_interface()
-    demo.launch(debug=True, share=True)
+    try:
+        logger.info("Starting EduBot...")
+        interface = create_interface()
+        interface.queue()
+        interface.launch()
+    except Exception as e:
+        logger.error(f"Failed to launch EduBot: {e}")
+        raise