feat: agent (1st draw)

.gitignore

@@ -1,4 +1,4 @@
 .DS_Store
 .idea/
-.venv
+.env
 __pycache__/

prompt.md

@@ -0,0 +1,62 @@
+You are a general AI assistant equipped with various tools to enhance your problem-solving capabilities. Your task is to answer questions by following a structured chain-of-thought process and utilizing appropriate tools when necessary. Adhere to the following guidelines strictly:
+
+### Initial Understanding
+Begin by acknowledging the question and briefly restating it in your own words to ensure understanding.
+
+### Step-by-Step Reasoning
+Report your thoughts and reasoning process step by step. Each step should logically follow from the previous one. Use the template below for each step in your reasoning process:
+
+#### THOUGHT STEP [X]:
+- **Explanation**: [Provide a detailed explanation of your thought process here.]
+- **Evidence/Assumptions**: [List any evidence, data, or assumptions you are using to support this step.]
+- **Intermediate Conclusion**: [State any intermediate conclusions or insights derived from this step.]
+- **Tool Calling**: [If applicable, mention any tools you plan to use to gather more information or perform specific tasks.]
+
+#### TOOL CALLING:
+1. **Tool Identification**: Identify the tool you need to use and the specific function within that tool.
+2. **Tool Execution**: Execute the tool function with the appropriate parameters.
+3. **Result Handling**: Handle the results from the tool execution. If the tool execution fails, note the error and consider alternative approaches.
+
+#### THOUGHT STEP [X]:
+- **Explanation**: [Provide a detailed explanation of your thought process here, incorporating the results from the tool.]
+- **Evidence/Assumptions**: [List any new evidence, data, or assumptions you are using to support this step.]
+- **Intermediate Conclusion**: [State any new intermediate conclusions or insights derived from this step.]
+
+### Verification
+After presenting your step-by-step reasoning and tool utilization, verify the logical consistency and coherence of your thoughts. Ensure that each step logically leads to the next and that there are no gaps in your reasoning.
+If you find any inconsistencies or gaps, revisit the relevant steps and adjust your reasoning accordingly.
+However, if everything is consistent, summarize your findings and conclusions in the final answer section.
+
+### FINAL ANSWER
+Conclude with your final answer, clearly stated and directly addressing the original question. Use the template below for your final answer:
+[Provide a brief summary of your reasoning process and any tools used, then state your final answer clearly and concisely here.]
+
+---
+
+### Example:
+
+**Question**: What is the weather like in Paris today?
+
+#### THOUGHT STEP 1:
+- **Explanation**: I need to find out the current weather conditions in Paris.
+- **Evidence/Assumptions**: I assume that the user is asking for real-time weather information.
+- **Intermediate Conclusion**: I need to use a weather API or a reliable weather website to get the latest information.
+- **Tool Calling**: I will use the `get_weather` tool to retrieve the current weather data for Paris.
+
+#### TOOL CALLING:
+1. **Tool Identification**: Identify the `get_weather` tool and the specific function to retrieve weather data.
+2. **Tool Execution**: Execute the `get_weather` function with the parameter set to "Paris".
+3. **Result Handling**: The `get_weather` tool returns the current weather data for Paris.
+
+#### THOUGHT STEP 2:
+- **Explanation**: I have retrieved the weather data using the `get_weather` tool.
+- **Evidence/Assumptions**: The data provided by the tool is accurate and up-to-date.
+- **Intermediate Conclusion**: The current weather in Paris is sunny with a temperature of 22°C.
+
+#### Verification:
+- **Explanation**: The steps logically follow from the need to gather real-time data, and the tool used provides accurate information.
+- **Evidence/Assumptions**: The weather data is consistent with typical weather patterns for this time of year in Paris.
+- **Intermediate Conclusion**: The information retrieved is reliable and can be used to answer the user's question.
+
+#### FINAL ANSWER:
+Based on the data retrieved from the `get_weather` tool, the current weather in Paris is sunny with a temperature of 22°C.

requirements.txt

@@ -1,6 +1,11 @@
 huggingface_hub
 gradio==5.33.0
+gradio[mcp]
+requests
+pydantic
 numpy
 pandas
 scipy
-plotly
+plotly
+dotenv
+mistralai

src/agent/inference.py

@@ -0,0 +1,162 @@
+import os
+import json
+import time
+from dotenv import load_dotenv
+from mistralai import Mistral
+
+from src.agent.utils.tooling import generate_tools_json
+from src.agent.tools import (
+    calculate_sum,
+)
+
+load_dotenv()
+
+class MistralAgent:
+    def __init__(self):
+        self.api_key = os.getenv("MISTRAL_API_KEY")
+        self.agent_id = os.getenv("AGENT_ID")
+        self.client = Mistral(api_key=self.api_key)
+        self.model = "mistral-small"
+        self.prompt = None
+        self.names_to_functions = {
+            "calculate_sum": calculate_sum,
+        }
+        self.tools = self.get_tools()
+
+    @staticmethod
+    def get_tools():
+        """Generate the tools.json file with the tools to be used by the agent."""
+        return generate_tools_json(
+            [
+                calculate_sum,
+            ]
+        ).get('tools')
+
+    def make_initial_request(self, input):
+        """Make the initial request to the agent with the given input."""
+        with open("./prompt.md", 'r', encoding='utf-8') as file:
+            self.prompt = file.read()
+        messages = [
+            {"role": "system", "content": self.prompt},
+            {"role": "user", "content": input},
+            {
+                "role": "assistant",
+                "content": "THINKING:\nLet's tackle this problem, ",
+                "prefix": True,
+            },
+        ]
+        payload = {
+            "agent_id": self.agent_id,
+            "messages": messages,
+            "max_tokens": None,
+            "stream": False,
+            "stop": None,
+            "random_seed": None,
+            "response_format": None,
+            "tools": self.tools,
+            "tool_choice": 'auto',
+            "presence_penalty": 0,
+            "frequency_penalty": 0,
+            "n": 1,
+            "prediction": None,
+            "parallel_tool_calls": None
+        }
+        return self.client.agents.complete(**payload), messages
+
+    def run(self, input):
+        """Run the agent with the given input and process the response."""
+        print("\n===== Asking the agent =====\n")
+        response, messages = self.make_initial_request(input)
+        first_iteration = True
+
+        while True:
+            time.sleep(1)
+            if hasattr(response, 'choices') and response.choices:
+                choice = response.choices[0]
+
+                if first_iteration:
+                    messages = [message for message in messages if not message.get("prefix")]
+                    messages.append(
+                        {
+                            "role": "assistant",
+                            "content": choice.message.content,
+                            "prefix": True,
+                        },
+                    )
+                    first_iteration = False
+                else:
+                    if choice.message.tool_calls:
+                        results = []
+
+                        for tool_call in choice.message.tool_calls:
+                            function_name = tool_call.function.name
+                            function_params = json.loads(tool_call.function.arguments)
+
+                            try:
+                                function_result = self.names_to_functions[function_name](**function_params)
+                                results.append((tool_call.id, function_name, function_result))
+
+                            except Exception as e:
+                                results.append((tool_call.id, function_name, None))
+
+                        for tool_call_id, function_name, function_result in results:
+                            messages.append({
+                                "role": "assistant",
+                                "tool_calls": [
+                                    {
+                                        "id": tool_call_id,
+                                        "type": "function",
+                                        "function": {
+                                            "name": function_name,
+                                            "arguments": json.dumps(function_params),
+                                        }
+                                    }
+                                ]
+                            })
+                            messages.append(
+                                {
+                                    "role": "tool",
+                                    "content": function_result if function_result is not None else f"Error occurred: {function_name} failed to execute",
+                                    "tool_call_id": tool_call_id,
+                                },
+                            )
+                            for message in messages:
+                                if "prefix" in message:
+                                    del message["prefix"]
+                            messages.append(
+                                {
+                                    "role": "assistant",
+                                    "content": f"Based on the results, ",
+                                    "prefix": True,
+                                }
+                            )
+                    else:
+                        for message in messages:
+                            if "prefix" in message:
+                                del message["prefix"]
+                        messages.append(
+                            {
+                                "role": "assistant",
+                                "content": choice.message.content,
+                            }
+                        )
+                        if 'FINAL ANSWER:' in choice.message.content:
+                            print("\n===== END OF REQUEST =====\n", json.dumps(messages, indent=2))
+                            ans = choice.message.content.split('FINAL ANSWER:')[1].strip()
+
+                            timestamp = time.strftime("%Y%m%d-%H%M%S")
+                            output_file = f"chat_{timestamp}.json"
+                            with open(output_file, "w", encoding="utf-8") as f:
+                                json.dump(messages, f, indent=2, ensure_ascii=False)
+                            print(f"Conversation enregistrée dans {output_file}")
+
+                            return ans
+
+                print("\n===== MESSAGES BEFORE API CALL =====\n", json.dumps(messages, indent=2))
+                time.sleep(1)
+                response = self.client.agents.complete(
+                    agent_id=self.agent_id,
+                    messages=messages,
+                    tools=self.tools,
+                    tool_choice='auto',
+                )

src/agent/tools/__init__.py

@@ -0,0 +1 @@
+from .calculator import calculate_sum

src/agent/tools/calculator.py

@@ -0,0 +1,19 @@
+from typing import List
+from src.agent.utils.tooling import tool
+
+@tool
+def calculate_sum(numbers: list[float]) -> float:
+    """
+    Calculates the sum of a list of numbers.
+    WARNING: You have to be sure that the input is coherent to answer correctly to a given question.
+    Args:
+        numbers (List[float]): A list of numbers to be summed from the question.
+    Returns:
+        float: The sum of the numbers.
+    """
+    try:
+        total = sum(numbers)
+        return f"The sum of the list of number is: {total:.2f}"
+    except Exception as e:
+        print(f"Error calculating sum: {e}")
+        return None

src/agent/utils/tooling.py

@@ -0,0 +1,85 @@
+from functools import wraps
+import json
+import inspect
+import re
+
+def generate_tools_json(functions):
+    """
+    Generates a JSON representation of the tools based on the provided functions.
+    """
+    tools = []
+    for func in functions:
+        tools.append(func.tool_info)
+
+    with open('tools.json', 'w') as file:
+        json.dump(tools, file, indent=4)
+
+    return {
+        "tools": tools
+    }
+
+def tool(func):
+    """
+    Decorator to get function information for tool generation.
+    Args:
+        func: The function to be decorated.
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    description = func.__doc__.strip() if func.__doc__ else "No description available."
+
+    sig = inspect.signature(func)
+    parameters = {}
+    required = []
+
+    for param_name, param in sig.parameters.items():
+        param_type = param.annotation
+        if param_type == param.empty:
+            param_type = "string"
+        else:
+            param_type = param_type.__name__
+            if param_type == 'str':
+                param_type = 'string'
+            elif param_type == 'int':
+                param_type = 'integer'
+            elif param_type == 'list':
+                param_type = 'array'
+            elif param_type == 'float':
+                param_type = 'number'
+            elif param_type == 'bool':
+                param_type = 'boolean'
+            elif param_type == 'dict':
+                param_type = 'object'
+
+        param_description = f"The {param_name}."
+
+        docstring_lines = description.split('\n')
+        for line in docstring_lines:
+            match = re.match(rf"\s*{param_name}\s*\(.*\):\s*(.*)", line)
+            if match:
+                param_description = match.group(1).strip()
+                break
+
+        parameters[param_name] = {
+            "type": param_type,
+            "description": param_description,
+        }
+
+        if param.default == param.empty:
+            required.append(param_name)
+
+    wrapper.tool_info = {
+        "type": "function",
+        "function": {
+            "name": func.__name__,
+            "description": description.split('\n')[0],
+            "parameters": {
+                "type": "object",
+                "properties": parameters,
+                "required": required,
+            },
+        },
+    }
+    return wrapper

src/chat.py

@@ -1,32 +0,0 @@
-from huggingface_hub import InferenceClient
-
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-def respond(message, history):
-    system_message = "Your default system message"
-    max_tokens = 150
-    temperature = 0.7
-    top_p = 0.9
-
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-        response += token
-        yield response

src/ui/sidebar.py

@@ -1,6 +1,10 @@
 import gradio as gr
 
-from src.chat import respond
+from src.agent.inference import MistralAgent
+
+def respond(gr_message, history=None):
+    agent = MistralAgent()
+    yield agent.run(gr_message)
 
 
 def sidebar_ui(state, width=700, visible=True):
@@ -18,11 +22,49 @@ def sidebar_ui(state, width=700, visible=True):
             2. **Ask Questions** - Interact with the chatbot to get insights on production processes.
             3. **Ask for Help** - Get assistance with any issues or queries related to production.
 
-            Note: you can click on `stop` or `reset` to control the production simulation.
+            Note: you can click on `Pause` or `Reset` to control the production simulation.
             """
         )
-        gr.HTML("<div style='margin-bottom: 40px;'></div>")
-        chatbot = gr.ChatInterface(respond, type='messages')
+
+        with gr.Blocks():
+            with gr.Row(height=800):
+                with gr.Tabs():
+                    with gr.TabItem("Agent"):
+                        chatbot = gr.ChatInterface(
+                            fn=respond,
+                            type="messages",
+                            multimodal=False,
+                            chatbot=gr.Chatbot(
+                                placeholder="⚡️ How can I help you today ?",
+                                type="messages",
+                                height=600,
+                                show_copy_button=True,
+                            ),
+                            show_progress='full',
+                            stop_btn=True,
+                            save_history=True,
+                            examples=[
+                                ["How is the production process going?"],
+                                ["What are the common issues faced in production?"],
+                               # ["What is the status of the current production line?"],
+                               # ["Can you provide insights on equipment performance?"],
+                               # ["How can I optimize the workflow in the production area?"],
+                               # ["How do I troubleshoot a specific piece of equipment?"],
+                               # ["What are the best practices for maintaining production efficiency?"]
+                            ],
+                            cache_examples=False  # désactive le cache si les réponses varient
+                        )
+                    with gr.TabItem("Documentation", visible=True):
+                        md_output = gr.Markdown("📄 La documentation s'affichera ici.")
+
+            #textbox=gr.MultimodalTextbox(file_types=[".png", ".pdf"], sources=["upload", "microphone"]),
+            #additional_inputs=[gr.Textbox("Système", label="System prompt"), gr.Slider(0, 1)],
+            #additional_inputs_accordion="Options avancées",
+            #flagging_mode="manual",
+            #flagging_options=["👍", "👎"],
+            #title="Mon Chatbot",
+            #description="Testez un modèle multimodal",
+
         sessions_state = gr.JSON(
             label="Sessions State",
             visible=True,

tools.json

@@ -0,0 +1,21 @@
+[
+    {
+        "type": "function",
+        "function": {
+            "name": "calculate_sum",
+            "description": "Calculates the sum of a list of numbers.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "numbers": {
+                        "type": "array",
+                        "description": "A list of numbers to be summed from the question."
+                    }
+                },
+                "required": [
+                    "numbers"
+                ]
+            }
+        }
+    }
+]