initial commit

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -15,4 +15,113 @@ tags:
 - agent-course
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Simple Local Agent 🤖
+
+Un agent conversationnel simple utilisant SmoLAgents pour se connecter à un modèle de langage, que ce soit via un serveur local (LMStudio) ou via d'autres APIs.
+
+## Prérequis 📋
+
+- Python 3.8+
+- Un modèle de langage hébergé localement ou accessible via une API
+
+## Installation ⚙️
+
+1. Installez les dépendances requises :
+
+```bash
+pip install -r requirements.txt
+```
+
+## Utilisation 💻
+
+### Interface Gradio
+
+1. Assurez-vous que votre serveur LLM est en cours d'exécution à l'adresse spécifiée.
+
+2. Lancez l'agent avec l'interface Gradio :
+
+```bash
+python app.py
+```
+
+### Interface Streamlit (Nouvelle !)
+
+Nous avons également ajouté une interface Streamlit qui offre plus de flexibilité et d'options de configuration :
+
+1. Lancez l'application Streamlit :
+
+```bash
+streamlit run streamlit_app.py
+```
+
+2. Accédez à l'interface via votre navigateur web (généralement à l'adresse http://localhost:8501).
+
+### Fonctionnalités de l'interface Streamlit
+
+- **Interface de chat interactive** pour discuter avec l'agent
+- **Choix entre différents types de modèles** :
+  - OpenAI Server (LMStudio ou autre serveur compatible OpenAI)
+  - Hugging Face API
+  - Hugging Face Cloud
+- **Configuration personnalisable** pour chaque type de modèle
+- **Affichage en temps réel** du raisonnement de l'agent
+- **Informations utiles** dans la barre latérale
+
+## Configuration ⚙️
+
+### Configuration du modèle
+
+L'interface Streamlit permet de configurer facilement le modèle sans modifier le code source :
+
+- **OpenAI Server** : URL du serveur, ID du modèle, clé API
+- **Hugging Face API** : URL du modèle, tokens maximum, température
+- **Hugging Face Cloud** : URL de l'endpoint, tokens maximum, température
+
+### Configuration des outils
+
+L'agent est équipé de plusieurs outils puissants qui lui permettent d'interagir avec le monde extérieur et d'effectuer diverses actions :
+
+#### Outils principaux intégrés
+
+- **DuckDuckGoSearchTool** : Permet à l'agent d'effectuer des recherches web via DuckDuckGo pour obtenir des informations à jour sur n'importe quel sujet.
+- **VisitWebpageTool** : Permet à l'agent de visiter une page web spécifique et d'en extraire le contenu pour analyse.
+- **ShellCommandTool** : Donne à l'agent la capacité d'exécuter des commandes shell sur le système hôte (avec les précautions de sécurité appropriées).
+- **CreateFileTool** : Permet à l'agent de créer de nouveaux fichiers dans le système.
+- **ModifyFileTool** : Permet à l'agent de modifier des fichiers existants.
+- **FinalAnswerTool** : Fournit une réponse finale structurée à l'utilisateur, résumant les informations trouvées.
+
+#### Outils personnalisés
+
+L'agent inclut également quelques outils personnalisés :
+
+- **get_current_realtime** : Renvoie l'heure actuelle du système.
+- **get_current_time_in_timezone** : Récupère l'heure locale actuelle dans un fuseau horaire spécifié (par exemple, "Europe/Paris", "America/New_York").
+
+#### Extensibilité
+
+L'architecture de l'agent est conçue pour être facilement extensible. Vous pouvez ajouter vos propres outils personnalisés en suivant le modèle d'exemple dans le fichier `app.py` :
+
+```python
+@tool
+def my_custom_tool(arg1: str, arg2: int) -> str:
+    """Description de ce que fait l'outil
+    Args:
+        arg1: description du premier argument
+        arg2: description du second argument
+    """
+    # Implémentation de votre outil
+    return "Résultat de l'outil"
+```
+
+## Exemples d'utilisation
+
+Voici quelques exemples de questions que vous pouvez poser à l'agent :
+
+- "Quelle est l'heure actuelle à Tokyo ?"
+- "Peux-tu me faire un résumé des dernières nouvelles sur l'IA ?"
+- "Crée un fichier contenant un exemple de code Python pour trier une liste"
+- "Explique-moi comment fonctionne la technologie des transformers en IA"
+
+---
+
+*Consultez la référence de configuration sur https://huggingface.co/docs/hub/spaces-config-reference* 🌐

app.py

@@ -4,8 +4,13 @@ import requests
 import pytz
 import yaml
 from tools.final_answer import FinalAnswerTool
-
+from tools.visit_webpage import VisitWebpageTool
+from tools.web_search import DuckDuckGoSearchTool
 from Gradio_UI import GradioUI
+from smolagents.models import OpenAIServerModel
+from tools.shell_tool import ShellCommandTool
+from tools.create_file_tool import CreateFileTool
+from tools.modify_file_tool import ModifyFileTool
 
 # Below is an example of a tool that does nothing. Amaze us with your creativity !
 @tool
@@ -18,6 +23,13 @@ def my_custom_tool(arg1:str, arg2:int)-> str: #it's import to specify the return
     """
     return "What magic will you build ?"
 
+# Below is an example of a tool that does nothing. Amaze us with your creativity !
+@tool
+def get_current_realtime()-> str: #it's import to specify the return type
+    #Keep this format for the description / args / args description but feel free to modify the tool
+    """A tool that get the current realtime
+    """
+    return datetime.datetime.now()
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
     """A tool that fetches the current local time in a specified timezone.
@@ -37,15 +49,21 @@ def get_current_time_in_timezone(timezone: str) -> str:
 final_answer = FinalAnswerTool()
 
 # If the agent does not answer, the model is overloaded, please use another model or the following Hugging Face Endpoint that also contains qwen2.5 coder:
-# model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud' 
+# model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud' è
 
-model = HfApiModel(
-max_tokens=2096,
-temperature=0.5,
-model_id='Qwen/Qwen2.5-Coder-32B-Instruct',# it is possible that this model may be overloaded
-custom_role_conversions=None,
-)
+# model = HfApiModel(
+#     model_id="http://192.168.1.141:1234/v1",
+#     max_new_tokens=2096,
+#     temperature=0.5
+# )
+# Configuration du modèle pour se connecter au LLM hébergé localement via LMStudio
+model = OpenAIServerModel(
+    api_base ="http://192.168.1.141:1234/v1",
+    model_id="Qwen/Qwen2.5-Coder-14B-Instruct-GGUF",  # Nom arbitraire pour le modèle local
+    api_key="sk-dummy-key"  # Clé factice pour LMStudio
+    # max_tokens=2096,
 
+)
 
 # Import tool from Hub
 image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
@@ -55,7 +73,7 @@ with open("prompts.yaml", 'r') as stream:
     
 agent = CodeAgent(
     model=model,
-    tools=[final_answer], ## add your tools here (don't remove final answer)
+    tools=[final_answer, DuckDuckGoSearchTool(), VisitWebpageTool(), ShellCommandTool(), CreateFileTool(), ModifyFileTool()],
     max_steps=6,
     verbosity_level=1,
     grammar=None,

requirements.txt

@@ -1,5 +1,9 @@
-markdownify
-smolagents
-requests
-duckduckgo_search
-pandas
+streamlit>=1.28.0
+requests>=2.31.0
+smolagents>=0.0.2
+langchain>=0.0.312
+pydantic>=2.4.2
+openai>=1.2.0
+gradio>=5.15.0
+pytz>=2023.3
+pyyaml>=6.0

streamlit_app.py

@@ -0,0 +1,368 @@
+import streamlit as st
+import os
+import sys
+import yaml
+import datetime
+import pytz
+from typing import List, Dict, Any
+
+# Ajout du répertoire courant au chemin Python pour importer les modules
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+# Import des composants nécessaires pour l'agent
+from smolagents import CodeAgent
+from smolagents.models import OpenAIServerModel, HfApiModel
+from tools.final_answer import FinalAnswerTool
+from tools.visit_webpage import VisitWebpageTool
+from tools.web_search import DuckDuckGoSearchTool
+from tools.shell_tool import ShellCommandTool
+from tools.create_file_tool import CreateFileTool
+from tools.modify_file_tool import ModifyFileTool
+
+# Configuration de la page Streamlit
+st.set_page_config(
+    page_title="Agent Conversationnel SmoLAgents 🤖",
+    page_icon="🤖",
+    layout="wide",
+)
+
+def initialize_agent(model_type="openai_server", model_config=None):
+    """Initialise l'agent avec les outils et le modèle choisi
+    
+    Args:
+        model_type: Type de modèle à utiliser ('openai_server', 'hf_api', etc.)
+        model_config: Configuration spécifique au modèle
+    """
+    
+    # Configuration du modèle en fonction du type choisi
+    if model_type == "openai_server":
+        # Configuration par défaut pour OpenAIServerModel
+        if model_config is None:
+            model_config = {
+                "api_base": "http://192.168.1.141:1234/v1",
+                "model_id": "Qwen/Qwen2.5-Coder-14B-Instruct-GGUF",
+                "api_key": "sk-dummy-key"
+            }
+        
+        model = OpenAIServerModel(
+            api_base=model_config["api_base"],
+            model_id=model_config["model_id"],
+            api_key=model_config["api_key"]
+        )
+    
+    elif model_type == "hf_api":
+        # Configuration par défaut pour HfApiModel
+        if model_config is None:
+            model_config = {
+                "model_id": "http://192.168.1.141:1234/v1",
+                "max_new_tokens": 2096,
+                "temperature": 0.5
+            }
+        
+        model = HfApiModel(
+            model_id=model_config["model_id"],
+            max_new_tokens=model_config["max_new_tokens"],
+            temperature=model_config["temperature"]
+        )
+    
+    elif model_type == "hf_cloud":
+        # Configuration pour HfApiModel avec un endpoint cloud
+        if model_config is None:
+            model_config = {
+                "model_id": "https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud",
+                "max_new_tokens": 2096,
+                "temperature": 0.5
+            }
+        
+        model = HfApiModel(
+            model_id=model_config["model_id"],
+            max_new_tokens=model_config["max_new_tokens"],
+            temperature=model_config["temperature"]
+        )
+    
+    else:
+        st.error(f"Type de modèle non supporté: {model_type}")
+        return None
+    
+    # Chargement des templates de prompt depuis le fichier YAML
+    try:
+        with open("prompts.yaml", 'r') as stream:
+            prompt_templates = yaml.safe_load(stream)
+    except:
+        st.error("Impossible de charger prompts.yaml. Utilisation des prompts par défaut.")
+        prompt_templates = None
+    
+    # Initialisation des outils
+    final_answer = FinalAnswerTool()
+    
+    # Création de l'agent avec les mêmes outils que dans app.py
+    agent = CodeAgent(
+        model=model,
+        tools=[
+            final_answer, 
+            DuckDuckGoSearchTool(), 
+            VisitWebpageTool(), 
+            ShellCommandTool(), 
+            CreateFileTool(), 
+            ModifyFileTool()
+        ],
+        max_steps=6,
+        verbosity_level=1,
+        grammar=None,
+        planning_interval=None,
+        name=None,
+        description=None,
+        prompt_templates=prompt_templates
+    )
+    
+    return agent
+
+def format_step_message(step, is_final=False):
+    """Formate les messages de l'agent pour l'affichage dans Streamlit"""
+    
+    if hasattr(step, "model_output") and step.model_output:
+        # Nettoyer et formater la sortie du modèle pour l'affichage
+        content = step.model_output.strip()
+        if not is_final:
+            return content
+        else:
+            return f"**Réponse finale :** {content}"
+    
+    if hasattr(step, "observations") and step.observations:
+        # Afficher les observations des outils
+        return f"**Observations :** {step.observations.strip()}"
+    
+    if hasattr(step, "error") and step.error:
+        # Afficher les erreurs
+        return f"**Erreur :** {step.error}"
+    
+    # Cas par défaut
+    return str(step)
+
+def process_user_input(agent, user_input):
+    """Traite l'entrée utilisateur avec l'agent et renvoie les résultats étape par étape"""
+    
+    # Vérification de la connexion au serveur LLM
+    try:
+        # Exécution de l'agent et capture des étapes
+        with st.spinner("L'agent réfléchit..."):
+            # Placeholder pour la sortie de l'agent
+            response_container = st.container()
+            
+            # Exécution de l'agent et capture des étapes
+            steps = []
+            final_step = None
+            
+            with response_container:
+                step_container = st.empty()
+                step_text = ""
+                
+                # Exécute l'agent et capture les étapes de manière incrémentale
+                for step in agent.run(user_input, stream=True):
+                    steps.append(step)
+                    
+                    # Mettre à jour l'affichage des étapes
+                    step_number = f"Étape {step.step_number}" if hasattr(step, "step_number") and step.step_number is not None else ""
+                    step_content = format_step_message(step)
+                    
+                    # Ajouter au texte des étapes
+                    if step_number:
+                        step_text += f"### {step_number}\n\n"
+                    step_text += f"{step_content}\n\n---\n\n"
+                    
+                    # Mettre à jour l'affichage
+                    step_container.markdown(step_text)
+                    
+                    # Conserver la dernière étape pour la réponse finale
+                    final_step = step
+                
+                # Afficher la réponse finale
+                if final_step:
+                    final_answer = format_step_message(final_step, is_final=True)
+                    st.markdown(f"## Réponse Finale\n\n{final_answer}")
+            
+            return final_step
+    except Exception as e:
+        st.error(f"Erreur lors de l'exécution de l'agent: {str(e)}")
+        return None
+
+def main():
+    st.title("Agent Conversationnel SmoLAgents 🤖")
+    
+    st.markdown("""
+    Bienvenue! Cet agent utilise SmoLAgents pour se connecter à un modèle de langage.
+    Posez vos questions ci-dessous.
+    """)
+    
+    # Sidebar pour la configuration du modèle
+    with st.sidebar:
+        st.title("Configuration du Modèle")
+        
+        # Sélectionner le type de modèle
+        model_type = st.selectbox(
+            "Type de modèle",
+            ["openai_server", "hf_api", "hf_cloud"],
+            index=0,
+            help="Choisissez le type de modèle à utiliser avec l'agent"
+        )
+        
+        # Configuration spécifique en fonction du type de modèle
+        model_config = {}
+        
+        if model_type == "openai_server":
+            st.subheader("Configuration OpenAI Server")
+            model_config["api_base"] = st.text_input(
+                "URL du serveur",
+                value="http://192.168.1.141:1234/v1",
+                help="Adresse du serveur OpenAI compatible"
+            )
+            model_config["model_id"] = st.text_input(
+                "ID du modèle",
+                value="Qwen/Qwen2.5-Coder-14B-Instruct-GGUF",
+                help="Identifiant du modèle local"
+            )
+            model_config["api_key"] = st.text_input(
+                "Clé API",
+                value="sk-dummy-key",
+                type="password",
+                help="Clé API pour le serveur (dummy pour LMStudio)"
+            )
+        
+        elif model_type == "hf_api":
+            st.subheader("Configuration Hugging Face API")
+            model_config["model_id"] = st.text_input(
+                "URL du modèle",
+                value="http://192.168.1.141:1234/v1",
+                help="URL du modèle ou endpoint"
+            )
+            model_config["max_new_tokens"] = st.slider(
+                "Tokens maximum",
+                min_value=512,
+                max_value=4096,
+                value=2096,
+                help="Nombre maximum de tokens à générer"
+            )
+            model_config["temperature"] = st.slider(
+                "Température",
+                min_value=0.1,
+                max_value=1.0,
+                value=0.5,
+                step=0.1,
+                help="Température pour la génération (plus élevée = plus créatif)"
+            )
+        
+        elif model_type == "hf_cloud":
+            st.subheader("Configuration Hugging Face Cloud")
+            model_config["model_id"] = st.text_input(
+                "URL du endpoint cloud",
+                value="https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud",
+                help="URL de l'endpoint cloud Hugging Face"
+            )
+            model_config["max_new_tokens"] = st.slider(
+                "Tokens maximum",
+                min_value=512,
+                max_value=4096,
+                value=2096,
+                help="Nombre maximum de tokens à générer"
+            )
+            model_config["temperature"] = st.slider(
+                "Température",
+                min_value=0.1,
+                max_value=1.0,
+                value=0.5,
+                step=0.1,
+                help="Température pour la génération (plus élevée = plus créatif)"
+            )
+        
+        # Bouton pour réinitialiser l'agent avec la nouvelle configuration
+        if st.button("Appliquer la configuration"):
+            with st.spinner("Initialisation de l'agent avec le nouveau modèle..."):
+                st.session_state.agent = initialize_agent(model_type, model_config)
+                st.success("✅ Configuration appliquée avec succès!")
+    
+    # Vérifier la connexion au serveur
+    if model_type == "openai_server":
+        llm_api_url = model_config["api_base"].split("/v1")[0]
+        try:
+            import requests
+            response = requests.get(f"{llm_api_url}/health", timeout=2)
+            if response.status_code == 200:
+                st.success("✅ Connexion au serveur LLM établie")
+            else:
+                st.warning("⚠️ Le serveur LLM est accessible mais renvoie un statut non-OK")
+        except Exception:
+            st.error("❌ Impossible de se connecter au serveur LLM. Vérifiez que le serveur est en cours d'exécution à l'adresse spécifiée.")
+    
+    # Initialisation de l'agent si ce n'est pas déjà fait
+    if "agent" not in st.session_state:
+        with st.spinner("Initialisation de l'agent..."):
+            st.session_state.agent = initialize_agent(model_type, model_config)
+    
+    # Initialisation de l'historique de conversation
+    if "messages" not in st.session_state:
+        st.session_state.messages = [
+            {"role": "assistant", "content": "Bonjour! Comment puis-je vous aider aujourd'hui?"}
+        ]
+    
+    # Affichage de l'historique des messages
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+    
+    # Zone de saisie utilisateur
+    if prompt := st.chat_input("Posez votre question..."):
+        # Ajouter la question de l'utilisateur à l'historique
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        
+        # Afficher la question de l'utilisateur
+        with st.chat_message("user"):
+            st.markdown(prompt)
+        
+        # Traiter la demande avec l'agent
+        with st.chat_message("assistant"):
+            response = process_user_input(st.session_state.agent, prompt)
+            
+            if response and hasattr(response, "model_output"):
+                # Ajouter la réponse à l'historique
+                st.session_state.messages.append({"role": "assistant", "content": response.model_output})
+    
+    # Bouton pour effacer l'historique
+    if st.sidebar.button("Nouvelle conversation"):
+        st.session_state.messages = [
+            {"role": "assistant", "content": "Bonjour! Comment puis-je vous aider aujourd'hui?"}
+        ]
+        st.rerun()
+    
+    # Afficher des informations supplémentaires dans la barre latérale
+    with st.sidebar:
+        st.title("À propos de cet agent")
+        st.markdown("""
+        Cet agent utilise SmoLAgents pour se connecter à un modèle de langage hébergé localement.
+        
+        ### Outils disponibles
+        - Recherche web (DuckDuckGo)
+        - Visite de pages web
+        - Exécution de commandes shell
+        - Création et modification de fichiers
+        
+        ### Configuration
+        Utilisez les options ci-dessus pour configurer le modèle de langage.
+        
+        ### Problèmes courants
+        - Si l'agent ne répond pas, vérifiez que le serveur LLM est en cours d'exécution et accessible.
+        - Assurez-vous que toutes les dépendances sont installées via `pip install -r requirements.txt`.
+        """)
+        
+        # Afficher l'heure actuelle dans différents fuseaux horaires
+        st.subheader("Heure actuelle")
+        selected_timezone = st.selectbox(
+            "Choisissez un fuseau horaire",
+            ["Europe/Paris", "America/New_York", "Asia/Tokyo", "Australia/Sydney"]
+        )
+        
+        tz = pytz.timezone(selected_timezone)
+        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+        st.write(f"L'heure actuelle à {selected_timezone} est: {local_time}")
+
+if __name__ == "__main__":
+    main() 

tools/create_file_tool.py

@@ -0,0 +1,33 @@
+from typing import Any, Optional
+from smolagents.tools import Tool
+import os
+import sys
+
+class CreateFileTool(Tool):
+    name = "create_file"
+    description = "Creates a new file with the specified content."
+    inputs = {
+        'path': {'type': 'string', 'description': 'The path of the file to create.'},
+        'content': {'type': 'string', 'description': 'The content to write in the file.'}
+    }
+    output_type = "string"
+
+    def __init__(self, **kwargs):
+        super().__init__()
+        # Detect the operating system
+        self.is_windows = sys.platform.startswith('win')
+
+    def forward(self, path: str, content: str) -> str:
+        try:
+            # Ensure the parent directory exists
+            directory = os.path.dirname(path)
+            if directory and not os.path.exists(directory):
+                os.makedirs(directory)
+            
+            # Write the content to the file
+            with open(path, 'w', encoding='utf-8') as file:
+                file.write(content)
+                
+            return f"File created successfully: {path}"
+        except Exception as e:
+            return f"Error while creating the file: {str(e)}" 

tools/modify_file_tool.py

@@ -0,0 +1,37 @@
+from typing import Any, Optional
+from smolagents.tools import Tool
+import os
+import sys
+
+class ModifyFileTool(Tool):
+    name = "modify_file"
+    description = "Modify an existing file."
+    inputs = {
+        'path': {'type': 'string', 'description': 'The path of the file to modify.'},
+        'content': {'type': 'string', 'description': 'The new content of the file.'},
+        'append': {'type': 'boolean', 'description': 'If true, append the content to the end of the file instead of replacing it.', 'nullable': True}
+    }
+    output_type = "string"
+
+    def __init__(self, **kwargs):
+        super().__init__()
+        # Detect the operating system
+        self.is_windows = sys.platform.startswith('win')
+
+    def forward(self, path: str, content: str, append: bool = False) -> str:
+        try:
+            # Check if the file exists
+            if not os.path.exists(path):
+                return f"Error: The file {path} does not exist."
+            
+            # Open mode based on the append option
+            mode = 'a' if append else 'w'
+            
+            # Modify the file
+            with open(path, mode, encoding='utf-8') as file:
+                file.write(content)
+                
+            action = "modified" if not append else "updated (content added)"
+            return f"File {action} successfully: {path}"
+        except Exception as e:
+            return f"Error while modifying the file: {str(e)}" 

tools/shell_tool.py

@@ -0,0 +1,54 @@
+from typing import Any, Optional
+from smolagents.tools import Tool
+import duckduckgo_search
+import subprocess
+import sys
+
+class ShellCommandTool(Tool):
+    name = "shell_command"
+    description = "Executes a shell command and returns the result."
+    inputs = {'command': {'type': 'string', 'description': 'The shell command to execute.'}}
+    output_type = "string"
+
+    def __init__(self, timeout=60, **kwargs):
+        super().__init__()
+        self.timeout = timeout
+        # Detect the operating system
+        self.is_windows = sys.platform.startswith('win')
+
+    def forward(self, command: str) -> str:
+        try:
+            # Use shell=True for complex commands
+            # Use different configurations based on the OS
+            if self.is_windows:
+                process = subprocess.run(
+                    command,
+                    capture_output=True,
+                    text=True,
+                    shell=True,
+                    timeout=self.timeout,
+                    executable="cmd.exe" if self.is_windows else None
+                )
+            else:
+                process = subprocess.run(
+                    command,
+                    capture_output=True,
+                    text=True,
+                    shell=True,
+                    timeout=self.timeout
+                )
+            
+            # Return stdout and stderr if present
+            result = ""
+            if process.stdout:
+                result += f"## Standard Output\n```\n{process.stdout}\n```\n\n"
+            if process.stderr:
+                result += f"## Standard Error\n```\n{process.stderr}\n```\n\n"
+            
+            result += f"Exit Code: {process.returncode}"
+            return result
+            
+        except subprocess.TimeoutExpired:
+            return "The command has timed out."
+        except Exception as e:
+            return f"Error while executing the command: {str(e)}"

tools/visit_webpage.py

@@ -3,6 +3,7 @@ from smolagents.tools import Tool
 import requests
 import markdownify
 import smolagents
+import re 
 
 class VisitWebpageTool(Tool):
     name = "visit_webpage"

toto.py

@@ -0,0 +1 @@
+# This is a newly created Python file named toto.py