Update src/agent/agenttools.py

src/agent/agenttools.py

@@ -2,6 +2,10 @@ from llama_index.core.tools import FunctionTool
 from src.setup.utils import retry
 from src.controller.customlogger import logging
 from src.llm.source_llm import LLMCall
+import base64
+import matplotlib.pyplot as plt
+from io import BytesIO
+
 
 
 class ChatBotFunctionTools:
@@ -13,9 +17,8 @@ class ChatBotFunctionTools:
         logging.info(f"Tool Call: machine_learning_concept('{query}')")
         prompt = (
             "You are a Machine Learning teacher.\n"
-            "Explain the following ML concept in:\n"
-            "The explaination should include geometrical or mathematical intuition"
-            "Try to keep answer crisp and compact"
+            "Explain the following ML concept clearly, with geometric or mathematical intuition.\n"
+            "Keep it crisp, compact, and meaningful.\n"
             f"User Query: {query}"
         )
         return self.generator.complete(prompt)
@@ -25,187 +28,145 @@ class ChatBotFunctionTools:
         logging.info(f"Tool Call: math_concept('{query}')")
         prompt = (
             "You are a Math teacher.\n"
-            "Explain the following mathematics behind the Machine Learning algorithm in details with each step by step :\n"
-            "Try to keep answer crisp and compact"
-            f"User Query: {query}"
+            "Explain the mathematics behind the following ML-related concept in a step-by-step manner:\n"
+            f"{query}\n"
+            "Keep it compact and clear."
         )
         return self.generator.complete(prompt)
 
     @retry(max_retries=5, delay=1)
     def deep_learning_architecture(self, arch):
         logging.info(f"Tool Call: deep_learning_architecture('{arch}')")
-        prompt = f"Explain the {arch} neural network architecture with diagram description"
+        prompt = (
+            f"You are a Deep Learning instructor.\n"
+            f"Explain the architecture of {arch} with a diagram description and its components' roles."
+        )
         return self.generator.complete(prompt)
 
     @retry(max_retries=5, delay=1)
-    def visualize_algorithm(self, algo):
-        logging.info(f"Tool Call: visualize_algorithm('{algo}')")
-        prompt = f"Create visualization code that demonstrates how {algo} works"
+    def mathematical_intuition(self, algo):
+        logging.info(f"Tool Call: mathematical_intuition('{algo}')")
+        prompt = (
+            f"You are a Machine Learning expert.\n"
+            f"Provide the mathematical intuition behind the algorithm '{algo}'. "
+            "Keep the explanation compact and intuitive."
+        )
         return self.generator.complete(prompt)
 
     @retry(max_retries=5, delay=1)
     def concept_combiner(self, concepts):
         logging.info(f"Tool Call: concept_combiner('{concepts}')")
-        prompt = f"Explain the relationship between these concepts: {', '.join(concepts)}"
+        prompt = (
+            f"Explain the relationship and integration between the following concepts: {', '.join(concepts)}"
+        )
         return self.generator.complete(prompt)
 
     @retry(max_retries=5, delay=1)
     def llm_query(self, concepts):
         logging.info(f"Tool Call: llm_query('{concepts}')")
-        prompt = f"You are an Expert to Answer the following question respond to the best of your knowledge: {', '.join(concepts)}"
+        prompt = (
+            f"You are an expert LLM assistant. Respond to the following questions or topics with the best technical insight:\n"
+            f"{', '.join(concepts)}"
+        )
+        return self.generator.complete(prompt)
+
+    @retry(max_retries=5, delay=1)
+    def recommend_learning_path(self, topic_area):
+        logging.info(f"Tool Call: recommend_learning_path('{topic_area}')")
+        prompt = (
+            f"You are an AI tutor. Provide a structured learning path for '{topic_area}', including prerequisites, "
+            "recommended topics by order, and example projects."
+        )
+        return self.generator.complete(prompt)
+
+    @retry(max_retries=5, delay=1)
+    def quiz_question(self, topic):
+        logging.info(f"Tool Call: quiz_question('{topic}')")
+        prompt = (
+            f"Generate a 3-question quiz on '{topic}' with multiple choice options and answers. "
+            "Format: Question, 4 options (A–D), and the correct answer."
+        )
+        return self.generator.complete(prompt)
+
+    @retry(max_retries=5, delay=1)
+    def code_example(self, concept):
+        logging.info(f"Tool Call: code_example('{concept}')")
+        prompt = (
+            f"Provide a short Python code example demonstrating the concept '{concept}', "
+            "and explain the key parts in comments or brief explanations."
+        )
         return self.generator.complete(prompt)
 
+    @retry(max_retries=5, delay=1)
+    def doubt_clarifier(self, user_doubt):
+        logging.info(f"Tool Call: doubt_clarifier('{user_doubt}')")
+        prompt = (
+            f"A student has the following doubt: '{user_doubt}'. "
+            "As a teacher, explain it in simple terms, use analogies if helpful."
+        )
+        return self.generator.complete(prompt)
+
+    @retry(max_retries=5, delay=1)
+    def daily_study_plan(self, goals):
+        logging.info(f"Tool Call: daily_study_plan('{goals}')")
+        prompt = (
+            f"Create a one-week daily study plan to help achieve the following goals: '{goals}'. "
+            "Break it down by day with suggested hours, topics, and activities."
+        )
+        return self.generator.complete(prompt)
+
+    @retry(max_retries=5, delay=1)
+    def dsa_concept(self, concept):
+        logging.info(f"Tool Call: dsa_concept('{concept}')")
+        prompt = (
+            f"Explain the data structure or algorithm '{concept}' with real-life analogy, use-case, and time complexity. "
+            "Keep it beginner-friendly but technically accurate."
+        )
+        return self.generator.complete(prompt)
+
+    @retry(max_retries=5, delay=1)
+
+    def plot_generator(self, query):
+        logging.info(f"Tool Call: plot_generator('{query}')")
+        # Ask the LLM to generate Python code for plotting
+        code_prompt = (
+            f"You are a data visualization assistant. Generate Python code using matplotlib or seaborn to create a plot for: '{query}'.\n"
+            "Keep it clear and labeled. Assume necessary imports like matplotlib.pyplot are already done."
+        )
+        code = self.generator.complete(code_prompt)
+
+        # Attempt to execute the plot code safely
+        try:
+            # Setup isolated namespace and capture the figure
+            local_env = {}
+            exec_globals = {"plt": plt}
+            exec(code, exec_globals, local_env)
+
+            # Capture and encode the plot
+            buf = BytesIO()
+            plt.savefig(buf, format='png')
+            plt.close()
+            buf.seek(0)
+            encoded_img = base64.b64encode(buf.read()).decode('utf-8')
+            return {"image": encoded_img, "code": code}
+        except Exception as e:
+            return {"error": str(e), "code": code}
+    
+
     @retry(max_retries=5, delay=1)
     def get_tools(self):
         return {
             "ml_concept": FunctionTool.from_defaults(fn=self.machine_learning_concept),
             "dl_architecture": FunctionTool.from_defaults(fn=self.deep_learning_architecture),
-            "algo_visualizer": FunctionTool.from_defaults(fn=self.visualize_algorithm),
+            "mathematical_intuition": FunctionTool.from_defaults(fn=self.mathematical_intuition),
             "concept_combiner": FunctionTool.from_defaults(fn=self.concept_combiner),
             "math_concept": FunctionTool.from_defaults(fn=self.math_concept),
-            "llm_query": FunctionTool.from_defaults(fn=self.llm_query)
+            "llm_query": FunctionTool.from_defaults(fn=self.llm_query),
+            "learning_path": FunctionTool.from_defaults(fn=self.recommend_learning_path),
+            "quiz": FunctionTool.from_defaults(fn=self.quiz_question),
+            "code_example": FunctionTool.from_defaults(fn=self.code_example),
+            "doubt_clarifier": FunctionTool.from_defaults(fn=self.doubt_clarifier),
+            "daily_study_plan": FunctionTool.from_defaults(fn=self.daily_study_plan),
+            "dsa_concept": FunctionTool.from_defaults(fn=self.dsa_concept),
+            "plot_generator": FunctionTool.from_defaults(fn=self.plot_generator)
         }
-
-
-
-# class LearningAgent:
-#     """Core agent that orchestrates tool usage for learning system"""
-#
-#     def __init__(self, llm_value):
-#         self.llm = LLMCall(llm_type=llm_value).get_llm()
-#         self.tools = self._setup_tools()
-#         self.chat_history: List[Dict[str, str]] = []  # Stores properly formatted messages
-#         self.max_history = 20
-#
-#     def _setup_tools(self) -> Dict[str, FunctionTool]:
-#         """Initialize all learning tools"""
-#         return {
-#             **self._setup_ml_tools(),
-#             **self._setup_dl_tools(),
-#             **self._setup_graph_tools(),
-#             **self._setup_utility_tools()
-#         }
-#
-#     def _setup_ml_tools(self) -> Dict[str, FunctionTool]:
-#         """Machine Learning tools"""
-#
-#         def ml_concept_explainer(query: str) -> str:
-#             prompt = f"Explain this ML concept in simple terms with examples: {query}"
-#             return self.llm.complete(prompt).text
-#
-#         return {
-#             "ml_concept": FunctionTool.from_defaults(fn=ml_concept_explainer)
-#         }
-#
-#     def _setup_dl_tools(self) -> Dict[str, FunctionTool]:
-#         """Deep Learning tools"""
-#
-#         def dl_architecture(arch: str) -> str:
-#             prompt = f"Explain the {arch} neural network architecture with diagram description"
-#             return self.llm.complete(prompt).text
-#
-#         return {
-#             "dl_architecture": FunctionTool.from_defaults(fn=dl_architecture)
-#         }
-#
-#     def _setup_graph_tools(self) -> Dict[str, FunctionTool]:
-#         """Graph/Visualization tools"""
-#
-#         def visualize_algorithm(algo: str) -> str:
-#             prompt = f"Create visualization code that demonstrates how {algo} works"
-#             return self.llm.complete(prompt).text
-#
-#         return {
-#             "algo_visualizer": FunctionTool.from_defaults(fn=visualize_algorithm)
-#         }
-#
-#     def _setup_utility_tools(self) -> Dict[str, FunctionTool]:
-#         """Utility tools"""
-#
-#         def concept_combiner(concepts: List[str]) -> str:
-#             prompt = f"Explain the relationship between these concepts: {', '.join(concepts)}"
-#             return self.llm.complete(prompt).text
-#
-#         return {
-#             "concept_combiner": FunctionTool.from_defaults(fn=concept_combiner)
-#         }
-#
-#     def extract_json_from_markdown(self, markdown_text):
-#         """
-#         Extract and parse JSON content from a markdown-style code block.
-#         Handles formats like ```json ... ```
-#         """
-#         try:
-#             # Extract JSON block using regex
-#             match = re.search(r"```json\s*(\{.*?\})\s*```", markdown_text, re.DOTALL)
-#             if not match:
-#                 raise ValueError("No JSON block found in markdown")
-#
-#             json_str = match.group(1)
-#             return json.loads(json_str)
-#         except Exception as e:
-#             print(f"[ERROR] Could not parse JSON: {e}")
-#             return None
-#
-#     def determine_tools(self, query: str):
-#         """Decide which tools to use based on query"""
-#         previous_questions = ""
-#         if self.chat_history:
-#             previous_questions = "\n".join([msg["content"] for msg in self.chat_history if msg["role"] == "user"][:-1]) \
-#                 if self.chat_history else "No previous questions"
-#         prompt = f"""Analyze this learning query and select appropriate tools also form the condensed query based on
-#                     previous_questions and Query:
-#                     Query: {query}
-#                     Previous Query: {previous_questions}
-#                     Available Tools: {list(self.tools.keys())}
-#                     Return dictionary of tool names and condensed query as dictionary in the below format:
-#                             ```json
-#                             {{
-#                               "condensed_query": condensed query considering chat history and user query as string,
-#                               "tool_names": tool names as comma-separated list
-#                             }}
-#                             ```
-#                     Do Not add additional text"""
-#
-#         response = self.llm.complete(prompt).text
-#         response = self.extract_json_from_markdown(response)
-#         return [t.strip() for t in response['tool_names'].split(",") if t.strip() in self.tools], response["condensed_query"]
-#
-#     def execute_tools(self, tools: List[str], query: str) -> tuple[str, str]:
-#         """Execute multiple tools and combine results"""
-#         tool_results = []
-#         content_results = []
-#
-#         for tool in tools:
-#             try:
-#                 tool_output = self.tools[tool](query)
-#                 content = tool_output.content if isinstance(tool_output, ToolOutput) else str(tool_output)
-#                 tool_results.append(tool)
-#                 content_results.append(content)
-#             except Exception as e:
-#                 logging.error(f"Tool {tool} failed: {str(e)}")
-#                 tool_results.append(tool)
-#                 content_results.append(f"Error: {str(e)}")
-#
-#         if len(tool_results) > 1:
-#             combined = "\n\n".join(f"**{t}**:\n{c}" for t, c in zip(tool_results, content_results))
-#             explanation = self.tools["concept_combiner"](content_results)
-#             return "multiple", f"{combined}\n\n**Combined Analysis**:\n{explanation}"
-#         return tool_results[0], content_results[0]
-#
-#     def process_query(self, query: str) -> tuple[List[Dict[str, str]], str, str]:
-#         """Process query and return properly formatted messages"""
-#         tools, condensed_query = self.determine_tools(query)
-#         logging.info(f"Selected tools: {tools}")
-#
-#         tool_used, response = self.execute_tools(tools, condensed_query)
-#
-#         # Format messages for Gradio Chatbot
-#         user_msg = {"role": "user", "content": query.title()}
-#         assistant_msg = {"role": "assistant", "content": response}
-#
-#         self.chat_history.extend([user_msg, assistant_msg])
-#         if len(self.chat_history) > self.max_history * 2:  # *2 for user+assistant pairs
-#             self.chat_history = self.chat_history[-(self.max_history * 2):]
-#
-#         return self.chat_history, tool_used, response