Upload agent

agent.json

@@ -9,9 +9,12 @@
         "final_answer"
     ],
     "model": {
-        "class": "InferenceClientModel",
+        "class": "LiteLLMModel",
         "data": {
-            "model_id": "Qwen/Qwen3-Next-80B-A3B-Thinking"
+            "max_tokens": 2048,
+            "num_ctx": 8192,
+            "model_id": "ollama_chat/qwen2.5-coder:7b",
+            "api_base": "http://127.0.0.1:11434"
         }
     },
     "managed_agents": {},
@@ -37,6 +40,7 @@
     "name": null,
     "description": null,
     "requirements": [
+        "ddgs",
         "markdownify",
         "requests",
         "smolagents"

app.py

@@ -1,11 +1,11 @@
 import yaml
 import os
-from smolagents import GradioUI, CodeAgent, InferenceClientModel
+from smolagents import GradioUI, CodeAgent, LiteLLMModel
 
 # Get current directory path
 CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
 
-from tools.web_search import WebSearchTool as WebSearch
+from tools.web_search import DuckDuckGoSearchTool as WebSearch
 from tools.visit_webpage import VisitWebpageTool as VisitWebpage
 from tools.suggest_menu import SimpleTool as SuggestMenu
 from tools.catering_service_tool import SimpleTool as CateringServiceTool
@@ -14,8 +14,11 @@ from tools.final_answer import FinalAnswerTool as FinalAnswer
 
 
 
-model = InferenceClientModel(
-model_id='Qwen/Qwen3-Next-80B-A3B-Thinking',
+model = LiteLLMModel(
+max_tokens=2048,
+num_ctx=8192,
+model_id='ollama_chat/qwen2.5-coder:7b',
+api_base='http://127.0.0.1:11434',
 )
 
 web_search = WebSearch()

requirements.txt

@@ -1,3 +1,4 @@
+ddgs
 markdownify
 requests
 smolagents

tools/catering_service_tool.py

@@ -3,13 +3,13 @@ from typing import Any, Optional
 
 class SimpleTool(Tool):
     name = "catering_service_tool"
-    description = "This tool returns the highest-rated catering service in Gotham City."
+    description = "This tool returns the highest-rated catering services in Gotham City."
     inputs = {'query': {'type': 'string', 'description': 'A search term for finding catering services.'}}
     output_type = "string"
 
     def forward(self, query: str) -> str:
         """
-        This tool returns the highest-rated catering service in Gotham City.
+        This tool returns the highest-rated catering services in Gotham City.
 
         Args:
             query: A search term for finding catering services.
@@ -18,7 +18,7 @@ class SimpleTool(Tool):
         services = {
             "Gotham Catering Co.": 4.9,
             "Wayne Manor Catering": 4.8,
-            "Gotham City Events": 4.7,
+            "Gotham City Events": 4.7
         }
 
         # Find the highest rated catering service (simulating search query filtering)

tools/suggest_menu.py

@@ -3,21 +3,23 @@ from typing import Any, Optional
 
 class SimpleTool(Tool):
     name = "suggest_menu"
-    description = "Suggests a menu based on the occasion."
-    inputs = {'occasion': {'type': 'string', 'description': 'The type of occasion for the party.'}}
+    description = "Suggests a menu based on occasion"
+    inputs = {'occasion': {'type': 'string', 'description': 'The of occasion for the party'}}
     output_type = "string"
 
     def forward(self, occasion: str) -> str:
         """
-        Suggests a menu based on the occasion.
+        Suggests a menu based on occasion
+
         Args:
-            occasion: The type of occasion for the party.
+            occasion: The of occasion for the party
         """
+
         if occasion == "casual":
             return "Pizza, snacks, and drinks."
-        elif occasion == "formal":
+        elif occasion == 'formal':
             return "3-course dinner with wine and dessert."
-        elif occasion == "superhero":
+        elif occasion == 'superhero':
             return "Buffet with high-energy and healthy food."
         else:
             return "Custom menu for the butler."

tools/superhero_party_theme_generator.py

@@ -5,7 +5,7 @@ class SuperheroPartyThemeTool(Tool):
     name = "superhero_party_theme_generator"
     description = """
     This tool suggests creative superhero-themed party ideas based on a category.
-    It returns a unique party theme idea."""
+    It returns a unique party them idea."""
     inputs = {'category': {'type': 'string', 'description': "The type of superhero party (e.g., 'classic heroes', 'villain masquerade', 'futuristic gotham')."}}
     output_type = "string"
 
@@ -13,10 +13,10 @@ class SuperheroPartyThemeTool(Tool):
         themes = {
             "classic heroes": "Justice League Gala: Guests come dressed as their favorite DC heroes with themed cocktails like 'The Kryptonite Punch'.",
             "villain masquerade": "Gotham Rogues' Ball: A mysterious masquerade where guests dress as classic Batman villains.",
-            "futuristic gotham": "Neo-Gotham Night: A cyberpunk-style party inspired by Batman Beyond, with neon decorations and futuristic gadgets."
+            "futuristic Gotham": "Neo-Gotham Night: A cyberpunk-style party inspired by Batman Beyond, with neon decorations and futuristic gadgets."
         }
 
-        return themes.get(category.lower(), "Themed party idea not found. Try 'classic heroes', 'villain masquerade', or 'futuristic gotham'.")
+        return themes.get(category.lower(), "Themed party idea not found. try 'classic heroes', 'villain masquerade', or 'futuristic Gotham'.")
 
     def __init__(self, *args, **kwargs):
         self.is_initialized = False

tools/visit_webpage.py

@@ -1,8 +1,8 @@
 from typing import Any, Optional
 from smolagents.tools import Tool
-import requests
 import re
 import markdownify
+import requests
 
 class VisitWebpageTool(Tool):
     name = "visit_webpage"

tools/web_search.py

@@ -1,116 +1,60 @@
 from typing import Any, Optional
 from smolagents.tools import Tool
-import requests
-import html
-import xml
-
-class WebSearchTool(Tool):
+import time
+import ddgs
+
+class DuckDuckGoSearchTool(Tool):
+    """Web search tool that performs searches using the DuckDuckGo search engine.
+
+Args:
+    max_results (`int`, default `10`): Maximum number of search results to return.
+    rate_limit (`float`, default `1.0`): Maximum queries per second. Set to `None` to disable rate limiting.
+    **kwargs: Additional keyword arguments for the `DDGS` client.
+
+Examples:
+    ```python
+    >>> from smolagents import DuckDuckGoSearchTool
+    >>> web_search_tool = DuckDuckGoSearchTool(max_results=5, rate_limit=2.0)
+    >>> results = web_search_tool("Hugging Face")
+    >>> print(results)
+    ```
+"""
     name = "web_search"
-    description = "Performs a web search for a query and returns a string of the top search results formatted as markdown with titles, links, and descriptions."
+    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.'}}
     output_type = "string"
 
-    def __init__(self, max_results: int = 10, engine: str = "duckduckgo"):
+    def __init__(self, max_results: int = 10, rate_limit: float | None = 1.0, **kwargs):
         super().__init__()
         self.max_results = max_results
-        self.engine = engine
+        self.rate_limit = rate_limit
+        self._min_interval = 1.0 / rate_limit if rate_limit else 0.0
+        self._last_request_time = 0.0
+        try:
+            from ddgs import DDGS
+        except ImportError as e:
+            raise ImportError(
+                "You must install package `ddgs` to run this tool: for instance run `pip install ddgs`."
+            ) from e
+        self.ddgs = DDGS(**kwargs)
 
     def forward(self, query: str) -> str:
-        results = self.search(query)
+        self._enforce_rate_limit()
+        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.")
-        return self.parse_results(results)
-
-    def search(self, query: str) -> list:
-        if self.engine == "duckduckgo":
-            return self.search_duckduckgo(query)
-        elif self.engine == "bing":
-            return self.search_bing(query)
-        else:
-            raise ValueError(f"Unsupported engine: {self.engine}")
-
-    def parse_results(self, results: list) -> str:
-        return "## Search Results\n\n" + "\n\n".join(
-            [f"[{result['title']}]({result['link']})\n{result['description']}" for result in results]
-        )
-
-    def search_duckduckgo(self, query: str) -> list:
-        import requests
-
-        response = requests.get(
-            "https://lite.duckduckgo.com/lite/",
-            params={"q": query},
-            headers={"User-Agent": "Mozilla/5.0"},
-        )
-        response.raise_for_status()
-        parser = self._create_duckduckgo_parser()
-        parser.feed(response.text)
-        return parser.results
-
-    def _create_duckduckgo_parser(self):
-        from html.parser import HTMLParser
-
-        class SimpleResultParser(HTMLParser):
-            def __init__(self):
-                super().__init__()
-                self.results = []
-                self.current = {}
-                self.capture_title = False
-                self.capture_description = False
-                self.capture_link = False
-
-            def handle_starttag(self, tag, attrs):
-                attrs = dict(attrs)
-                if tag == "a" and attrs.get("class") == "result-link":
-                    self.capture_title = True
-                elif tag == "td" and attrs.get("class") == "result-snippet":
-                    self.capture_description = True
-                elif tag == "span" and attrs.get("class") == "link-text":
-                    self.capture_link = True
-
-            def handle_endtag(self, tag):
-                if tag == "a" and self.capture_title:
-                    self.capture_title = False
-                elif tag == "td" and self.capture_description:
-                    self.capture_description = False
-                elif tag == "span" and self.capture_link:
-                    self.capture_link = False
-                elif tag == "tr":
-                    # Store current result if all parts are present
-                    if {"title", "description", "link"} <= self.current.keys():
-                        self.current["description"] = " ".join(self.current["description"])
-                        self.results.append(self.current)
-                        self.current = {}
-
-            def handle_data(self, data):
-                if self.capture_title:
-                    self.current["title"] = data.strip()
-                elif self.capture_description:
-                    self.current.setdefault("description", [])
-                    self.current["description"].append(data.strip())
-                elif self.capture_link:
-                    self.current["link"] = "https://" + data.strip()
-
-        return SimpleResultParser()
+        postprocessed_results = [f"[{result['title']}]({result['href']})\n{result['body']}" for result in results]
+        return "## Search Results\n\n" + "\n\n".join(postprocessed_results)
 
-    def search_bing(self, query: str) -> list:
-        import xml.etree.ElementTree as ET
+    def _enforce_rate_limit(self) -> None:
+        import time
 
-        import requests
+        # No rate limit enforced
+        if not self.rate_limit:
+            return
 
-        response = requests.get(
-            "https://www.bing.com/search",
-            params={"q": query, "format": "rss"},
-        )
-        response.raise_for_status()
-        root = ET.fromstring(response.text)
-        items = root.findall(".//item")
-        results = [
-            {
-                "title": item.findtext("title"),
-                "link": item.findtext("link"),
-                "description": item.findtext("description"),
-            }
-            for item in items[: self.max_results]
-        ]
-        return results
+        now = time.time()
+        elapsed = now - self._last_request_time
+        if elapsed < self._min_interval:
+            time.sleep(self._min_interval - elapsed)
+        self._last_request_time = time.time()