my first ai agent

.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.pyw
+*.pyz
+
+.venv/
+.gradio/

Gradio_UI.py

@@ -19,21 +19,26 @@ import re
 import shutil
 from typing import Optional
 
-from smolagents.agent_types import AgentAudio, AgentImage, AgentText, handle_agent_output_types
+from smolagents.agent_types import (
+    AgentAudio,
+    AgentImage,
+    AgentText,
+    handle_agent_output_types,
+)
 from smolagents.agents import ActionStep, MultiStepAgent
 from smolagents.memory import MemoryStep
 from smolagents.utils import _is_package_available
 
 
-def pull_messages_from_step(
-    step_log: MemoryStep,
-):
+def pull_messages_from_step(step_log: MemoryStep):
     """Extract ChatMessage objects from agent steps with proper nesting"""
     import gradio as gr
 
     if isinstance(step_log, ActionStep):
         # Output the step number
-        step_number = f"Step {step_log.step_number}" if step_log.step_number is not None else ""
+        step_number = (
+            f"Step {step_log.step_number}" if step_log.step_number is not None else ""
+        )
         yield gr.ChatMessage(role="assistant", content=f"**{step_number}**")
 
         # First yield the thought/reasoning from the LLM
@@ -41,9 +46,15 @@ def pull_messages_from_step(
             # Clean up the LLM output
             model_output = step_log.model_output.strip()
             # Remove any trailing <end_code> and extra backticks, handling multiple possible formats
-            model_output = re.sub(r"```\s*<end_code>", "```", model_output)  # handles ```<end_code>
-            model_output = re.sub(r"<end_code>\s*```", "```", model_output)  # handles <end_code>```
-            model_output = re.sub(r"```\s*\n\s*<end_code>", "```", model_output)  # handles ```\n<end_code>
+            model_output = re.sub(
+                r"```\s*<end_code>", "```", model_output
+            )  # handles ```<end_code>
+            model_output = re.sub(
+                r"<end_code>\s*```", "```", model_output
+            )  # handles <end_code>```
+            model_output = re.sub(
+                r"```\s*\n\s*<end_code>", "```", model_output
+            )  # handles ```\n<end_code>
             model_output = model_output.strip()
             yield gr.ChatMessage(role="assistant", content=model_output)
 
@@ -63,8 +74,12 @@ def pull_messages_from_step(
 
             if used_code:
                 # Clean up the content by removing any end code tags
-                content = re.sub(r"```.*?\n", "", content)  # Remove existing code blocks
-                content = re.sub(r"\s*<end_code>\s*", "", content)  # Remove end_code tags
+                content = re.sub(
+                    r"```.*?\n", "", content
+                )  # Remove existing code blocks
+                content = re.sub(
+                    r"\s*<end_code>\s*", "", content
+                )  # Remove end_code tags
                 content = content.strip()
                 if not content.startswith("```python"):
                     content = f"```python\n{content}\n```"
@@ -90,7 +105,11 @@ def pull_messages_from_step(
                     yield gr.ChatMessage(
                         role="assistant",
                         content=f"{log_content}",
-                        metadata={"title": "📝 Execution Logs", "parent_id": parent_id, "status": "done"},
+                        metadata={
+                            "title": "📝 Execution Logs",
+                            "parent_id": parent_id,
+                            "status": "done",
+                        },
                     )
 
             # Nesting any errors under the tool call
@@ -98,7 +117,11 @@ def pull_messages_from_step(
                 yield gr.ChatMessage(
                     role="assistant",
                     content=str(step_log.error),
-                    metadata={"title": "💥 Error", "parent_id": parent_id, "status": "done"},
+                    metadata={
+                        "title": "💥 Error",
+                        "parent_id": parent_id,
+                        "status": "done",
+                    },
                 )
 
             # Update parent message metadata to done status without yielding a new message
@@ -106,17 +129,25 @@ def pull_messages_from_step(
 
         # Handle standalone errors but not from tool calls
         elif hasattr(step_log, "error") and step_log.error is not None:
-            yield gr.ChatMessage(role="assistant", content=str(step_log.error), metadata={"title": "💥 Error"})
+            yield gr.ChatMessage(
+                role="assistant",
+                content=str(step_log.error),
+                metadata={"title": "💥 Error"},
+            )
 
         # Calculate duration and token information
         step_footnote = f"{step_number}"
-        if hasattr(step_log, "input_token_count") and hasattr(step_log, "output_token_count"):
-            token_str = (
-                f" | Input-tokens:{step_log.input_token_count:,} | Output-tokens:{step_log.output_token_count:,}"
-            )
+        if hasattr(step_log, "input_token_count") and hasattr(
+            step_log, "output_token_count"
+        ):
+            token_str = f" | Input-tokens:{step_log.input_token_count:,} | Output-tokens:{step_log.output_token_count:,}"
             step_footnote += token_str
         if hasattr(step_log, "duration"):
-            step_duration = f" | Duration: {round(float(step_log.duration), 2)}" if step_log.duration else None
+            step_duration = (
+                f" | Duration: {round(float(step_log.duration), 2)}"
+                if step_log.duration
+                else None
+            )
             step_footnote += step_duration
         step_footnote = f"""<span style="color: #bbbbc2; font-size: 12px;">{step_footnote}</span> """
         yield gr.ChatMessage(role="assistant", content=f"{step_footnote}")
@@ -139,7 +170,9 @@ def stream_to_gradio(
     total_input_tokens = 0
     total_output_tokens = 0
 
-    for step_log in agent.run(task, stream=True, reset=reset_agent_memory, additional_args=additional_args):
+    for step_log in agent.run(
+        task, stream=True, reset=reset_agent_memory, additional_args=additional_args
+    ):
         # Track tokens if model provides them
         if hasattr(agent.model, "last_input_token_count"):
             total_input_tokens += agent.model.last_input_token_count
@@ -172,7 +205,9 @@ def stream_to_gradio(
             content={"path": final_answer.to_string(), "mime_type": "audio/wav"},
         )
     else:
-        yield gr.ChatMessage(role="assistant", content=f"**Final answer:** {str(final_answer)}")
+        yield gr.ChatMessage(
+            role="assistant", content=f"**Final answer:** {str(final_answer)}"
+        )
 
 
 class GradioUI:
@@ -242,10 +277,14 @@ class GradioUI:
         sanitized_name = "".join(sanitized_name)
 
         # Save the uploaded file to the specified folder
-        file_path = os.path.join(self.file_upload_folder, os.path.basename(sanitized_name))
+        file_path = os.path.join(
+            self.file_upload_folder, os.path.basename(sanitized_name)
+        )
         shutil.copy(file.name, file_path)
 
-        return gr.Textbox(f"File uploaded: {file_path}", visible=True), file_uploads_log + [file_path]
+        return gr.Textbox(
+            f"File uploaded: {file_path}", visible=True
+        ), file_uploads_log + [file_path]
 
     def log_user_message(self, text_input, file_uploads_log):
         return (
@@ -277,7 +316,9 @@ class GradioUI:
             # If an upload folder is provided, enable the upload feature
             if self.file_upload_folder is not None:
                 upload_file = gr.File(label="Upload a file")
-                upload_status = gr.Textbox(label="Upload Status", interactive=False, visible=False)
+                upload_status = gr.Textbox(
+                    label="Upload Status", interactive=False, visible=False
+                )
                 upload_file.change(
                     self.upload_file,
                     [upload_file, file_uploads_log],
@@ -293,4 +334,4 @@ class GradioUI:
         demo.launch(debug=True, share=True, **kwargs)
 
 
-__all__ = ["stream_to_gradio", "GradioUI"]
+__all__ = ["stream_to_gradio", "GradioUI"]

agent.json

@@ -1,8 +1,8 @@
 {
     "tools": [
-        "web_search",
-        "visit_webpage",
-        "final_answer"
+        "final_answer",
+        "get_current_time_in_timezone",
+        "get_news_from_place"
     ],
     "model": {
         "class": "HfApiModel",
@@ -48,6 +48,7 @@
         "queue",
         "time",
         "collections",
-        "re"
+        "re",
+        "pytz"
     ]
 }

app.py

@@ -1,22 +1,28 @@
-from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
 import datetime
-import requests
+
 import pytz
 import yaml
-from tools.final_answer import FinalAnswerTool
+from smolagents import CodeAgent, HfApiModel, tool
 
 from Gradio_UI import GradioUI
+from tools.final_answer import FinalAnswerTool
+from tools.visit_webpage import VisitWebpageTool
+
 
-# Below is an example of a tool that does nothing. Amaze us with your creativity !
 @tool
-def my_custom_tool(arg1:str, arg2:int)-> 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 does nothing yet 
+def get_news_from_place(place: str) -> str:
+    """
+    Fetches the top 5 news headlines from Google News for a specified place.
+
     Args:
-        arg1: the first argument
-        arg2: the second argument
+        place: The place to search news for (e.g., 'London').
     """
-    return "What magic will you build ?"
+    url = f"https://news.google.com/rss/search?q={place}&hl=en-US&gl=US&ceid=US:en"
+    visit_webpage_tool = VisitWebpageTool()
+    xml_content = visit_webpage_tool.forward(url=url)
+    # TODO: parse the xml content and return the top 5 headlines
+    return xml_content
+
 
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
@@ -25,9 +31,7 @@ def get_current_time_in_timezone(timezone: str) -> str:
         timezone: A string representing a valid timezone (e.g., 'America/New_York').
     """
     try:
-        # Create timezone object
         tz = pytz.timezone(timezone)
-        # Get current time in that timezone
         local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
         return f"The current local time in {timezone} is: {local_time}"
     except Exception as e:
@@ -36,34 +40,27 @@ 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 = 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,
+    max_tokens=2096,
+    temperature=0.5,
+    model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
+    custom_role_conversions=None,
 )
 
-
-# Import tool from Hub
-image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
-
-with open("prompts.yaml", 'r') as stream:
+with open("prompts.yaml", "r") as stream:
     prompt_templates = yaml.safe_load(stream)
-    
+
 agent = CodeAgent(
     model=model,
-    tools=[final_answer], ## add your tools here (don't remove final answer)
+    tools=[final_answer, get_current_time_in_timezone, get_news_from_place],
     max_steps=6,
     verbosity_level=1,
     grammar=None,
     planning_interval=None,
     name=None,
     description=None,
-    prompt_templates=prompt_templates
+    prompt_templates=prompt_templates,
+    additional_authorized_imports=["pytz"],
 )
 
-
-GradioUI(agent).launch()
+GradioUI(agent).launch()

prompts.yaml

@@ -42,7 +42,7 @@
   Task:
   "Answer the question in the variable `question` about the image stored in the variable `image`. The question is in French.
   You have been provided with these additional arguments, that you can access using the keys as variables in your python code:
-  {'question': 'Quel est l'animal sur l'image?', 'image': 'path/to/image.jpg'}"
+  {'question': 'Quel est l\'animal sur l\'image?', 'image': 'path/to/image.jpg'}"
 
   Thought: I will use the following tools: `translator` to translate the question into English and then `image_qa` to answer the question on the input image.
   Code:
@@ -141,6 +141,58 @@
   final_answer(pope_current_age)
   ```<end_code>
 
+  ---
+  Task: "What is the current time and news in Tokyo?"
+
+  Thought: I will use the `get_current_time_in_timezone` and `get_news_from_place` tools to get the time and news for Tokyo.
+  Code:
+  ```py
+  time_in_tokyo = get_current_time_in_timezone(timezone="Asia/Tokyo")
+  print(time_in_tokyo)
+  news_in_tokyo = get_news_from_place(timezone="Asia/Tokyo")
+  print(news_in_tokyo)
+  ```<end_code>
+  Observation:
+  The current local time in Asia/Tokyo is: 2024-07-15 17:43:34
+  Top News Headlines for Asia/Tokyo:
+  - Headline 1
+  - Headline 2
+  - Headline 3
+  - Headline 4
+  - Headline 5
+
+  Thought: I have the current time and news headlines for Tokyo. I will now combine them and provide the final answer.
+  Code:
+  ```py
+  final_answer(f"{time_in_tokyo}\\n{news_in_tokyo}")
+  ```<end_code>
+
+  ---
+  Task: "Get me the news from London and tell me what time it is there."
+
+  Thought: I will use `get_current_news_in_timezone` and `get_current_time_in_timezone` tools, specifying 'Europe/London' as the timezone.
+  Code:
+  ```python
+  news = get_current_news_in_timezone(timezone="Europe/London")
+  print(news)
+  time = get_current_time_in_timezone(timezone="Europe/London")
+  print(time)
+  ```<end_code>
+  Observation:
+  Top News Headlines for Europe/London:
+  - Headline 1
+  - Headline 2
+  - Headline 3
+  - Headline 4
+  - Headline 5
+  The current local time in Europe/London is: 2024-07-15 09:45:12
+
+  Thought: I will now provide the final answer.
+  Code:
+  ```python
+  final_answer(f"{time}\\n{news}")
+  ```<end_code>
+
   Above example were using notional tools that might not exist for you. On top of performing computations in the Python code snippets that you create, you only have access to these tools:
   {%- for tool in tools.values() %}
   - {{ tool.name }}: {{ tool.description }}

requirements.txt

@@ -1,5 +1,5 @@
 markdownify
-smolagents
+smolagents[gradio]
 requests
 duckduckgo_search
 pandas

tools/final_answer.py

@@ -1,10 +1,17 @@
-from typing import Any, Optional
+from typing import Any
+
 from smolagents.tools import Tool
 
+
 class FinalAnswerTool(Tool):
     name = "final_answer"
     description = "Provides a final answer to the given problem."
-    inputs = {'answer': {'type': 'any', 'description': 'The final answer to the problem'}}
+    inputs = {
+        "answer": {
+            "type": "any",
+            "description": "The final answer to the problem",
+        }
+    }
     output_type = "any"
 
     def forward(self, answer: Any) -> Any:

tools/visit_webpage.py

@@ -1,13 +1,17 @@
-from typing import Any, Optional
+import re
+
 from smolagents.tools import Tool
-import requests
-import markdownify
-import smolagents
+
 
 class VisitWebpageTool(Tool):
     name = "visit_webpage"
     description = "Visits a webpage at the given url and reads its content as a markdown string. Use this to browse webpages."
-    inputs = {'url': {'type': 'string', 'description': 'The url of the webpage to visit.'}}
+    inputs = {
+        "url": {
+            "type": "string",
+            "description": "The url of the webpage to visit.",
+        }
+    }
     output_type = "string"
 
     def forward(self, url: str) -> str:
@@ -15,7 +19,6 @@ class VisitWebpageTool(Tool):
             import requests
             from markdownify import markdownify
             from requests.exceptions import RequestException
-
             from smolagents.utils import truncate_content
         except ImportError as e:
             raise ImportError(

tools/web_search.py

@@ -1,11 +1,15 @@
-from typing import Any, Optional
 from smolagents.tools import Tool
-import duckduckgo_search
+
 
 class DuckDuckGoSearchTool(Tool):
     name = "web_search"
     description = "Performs a duckduckgo web search based on your query (think a Google search) then returns the top search results."
-    inputs = {'query': {'type': 'string', 'description': 'The search query to perform.'}}
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "The search query to perform.",
+        }
+    }
     output_type = "string"
 
     def __init__(self, max_results=10, **kwargs):
@@ -23,5 +27,8 @@ class DuckDuckGoSearchTool(Tool):
         results = self.ddgs.text(query, max_results=self.max_results)
         if len(results) == 0:
             raise Exception("No results found! Try a less restrictive/shorter query.")
-        postprocessed_results = [f"[{result['title']}]({result['href']})\n{result['body']}" for result in results]
+        postprocessed_results = [
+            f"[{result['title']}]({result['href']})\n{result['body']}"
+            for result in results
+        ]
         return "## Search Results\n\n" + "\n\n".join(postprocessed_results)