init

.gitignore

@@ -0,0 +1,171 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc

.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-----

app.py

@@ -0,0 +1,202 @@
+# Copyright 2024-2025 Akihito Miyazaki.
+# This code is derived from the DuckDuckGoSearchTool class,
+# originally part of the HuggingFace smolagents library.
+# https://github.com/huggingface/smolagents
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import os
+import threading
+from typing import Optional
+
+from dotenv import load_dotenv
+import gradio as gr
+from smolagents import (
+    CodeAgent,
+    LiteLLMModel,
+    DuckDuckGoSearchTool,
+)
+from smolagents.agent_types import AgentText, AgentImage, AgentAudio
+from smolagents.gradio_ui import pull_messages_from_step, handle_agent_output_types
+from huggingface_hub import InferenceClient
+
+
+from extra_search_tools import (
+    PrioritySearchTool,
+    BraveSearchTool,
+    GoogleCustomSearchTool,
+)
+
+
+def hf_chat(api_key, model, text):
+    client = InferenceClient(api_key=api_key)
+    messages = [
+        {
+            "role": "user",
+            "content": text,
+        }
+    ]
+
+    stream = client.chat.completions.create(
+        model=model, messages=messages, max_tokens=6000, stream=False
+    )
+
+    return stream.choices[0].message.content
+
+
+load_dotenv(override=True)
+# login(os.getenv("HF_TOKEN"))
+
+append_answer_lock = threading.Lock()
+
+# without below chat will duplicate
+custom_role_conversions = {"tool-call": "assistant", "tool-response": "user"}
+
+model = LiteLLMModel(
+    "groq/llama3-8b-8192",
+    api_base="https://api.groq.com/openai/v1",
+    max_completion_tokens=500,
+    api_key=os.getenv("GROQ_API_KEY"),  # Groq API
+)
+
+search_tool = PrioritySearchTool(
+    [
+        DuckDuckGoSearchTool(),
+        GoogleCustomSearchTool("YOUR_ENGINE_KEY"),
+        BraveSearchTool(),
+    ],
+    "history.json",
+)
+WEB_TOOLS = [search_tool]
+
+max_steps = 1
+
+
+# Agent creation in a factory function
+def create_agent():
+    print("create agent")
+    """Creates a fresh agent instance for each session"""
+    return CodeAgent(
+        model=model,
+        tools=WEB_TOOLS,
+        max_steps=max_steps,
+        verbosity_level=1,
+    )
+
+
+def stream_to_gradio(
+    agent,
+    task: str,
+    reset_agent_memory: bool = False,
+    additional_args: Optional[dict] = None,
+):
+    """Runs an agent with the given task and streams the messages from the agent as gradio ChatMessages."""
+    steps = 0
+    for step_log in agent.run(
+        task, stream=True, reset=reset_agent_memory, additional_args=additional_args
+    ):
+        # I dont know the reason but call more steps
+        steps += 1
+        if steps <= max_steps:
+            for message in pull_messages_from_step(
+                step_log,
+            ):
+                yield message
+
+    final_answer = step_log  # Last log is the run's final_answer
+    final_answer = handle_agent_output_types(final_answer)
+    # print(final_answer)
+    if isinstance(final_answer, AgentText):
+        yield gr.ChatMessage(
+            role="assistant",
+            content=f"**Final answer:**\n{final_answer.to_string()}",
+        )
+    elif isinstance(final_answer, AgentImage):
+        yield gr.ChatMessage(
+            role="assistant",
+            content={"path": final_answer.to_string(), "mime_type": "image/png"},
+        )
+    elif isinstance(final_answer, AgentAudio):
+        yield gr.ChatMessage(
+            role="assistant",
+            content={"path": final_answer.to_string(), "mime_type": "audio/wav"},
+        )
+    else:
+        yield gr.ChatMessage(
+            role="assistant", content=f"**Final answer:** {str(final_answer)}"
+        )
+
+
+class GradioUI:
+    """A one-line interface to launch your agent in Gradio"""
+
+    def __init__(self, file_upload_folder: str | None = None):
+        self.file_upload_folder = file_upload_folder
+        if self.file_upload_folder is not None:
+            if not os.path.exists(file_upload_folder):
+                os.mkdir(file_upload_folder)
+
+    def interact_with_agent(self, prompt, messages, session_state):
+        # Get or create session-specific agent
+        if "agent" not in session_state:
+            session_state["agent"] = create_agent()
+
+        messages.append(gr.ChatMessage(role="user", content=prompt))
+        yield messages
+
+        # Use session's agent instance
+        for msg in stream_to_gradio(
+            session_state["agent"], task=prompt, reset_agent_memory=False
+        ):
+            messages.append(msg)
+            pass
+            yield messages
+        yield messages
+
+    def launch(self, **kwargs):
+        with gr.Blocks(theme="ocean", fill_height=True) as demo:
+            gr.Markdown("""# Smolagents - ExtraSearchtools!
+- [Google Custom Search](https://developers.google.com/custom-search/v1/overview) tool
+- [Brave Search](https://brave.com/search/api/) tool
+- PrioritySearchTool - try duckduckgo fist and then use google
+- PrioritySearchTool - json-save function
+                        
+Built with [smolagents](https://github.com/huggingface/smolagents).This Demo only work duckduckgo if it's not rate-limited.Duplicate and set your own secret key 
+""")
+            # Add session state to store session-specific data
+            session_state = gr.State({})  # Initialize empty state for each session
+
+            chatbot = gr.Chatbot(
+                label="ExtraSearchtools",
+                type="messages",
+                avatar_images=(
+                    None,
+                    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/smolagents/mascot_smol.png",
+                ),
+                scale=1,
+            )
+            text_input = gr.Textbox(
+                lines=1, label="Your request", value="What is smolagents?"
+            )
+            text_input.submit(
+                self.interact_with_agent,
+                # Include session_state in function calls
+                [text_input, chatbot, gr.State({})],
+                [chatbot],
+            )
+
+        demo.launch(debug=True, share=True, **kwargs)
+
+
+if __name__ == "__main__":
+    GradioUI().launch()  # not support auto update restart by yourself :AttributeError: module '__main__' has no attribute 'demo'

extra_search_tools.py

@@ -0,0 +1,215 @@
+# Copyright 2024-2025 Akihito Miyazaki.
+# This code is derived from the DuckDuckGoSearchTool class,
+# originally part of the HuggingFace smolagents library.
+# https://github.com/huggingface/smolagents
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from smolagents import Tool
+import json
+import os
+from datetime import datetime
+
+"""This module provides search tools.  The tools share a common name
+because they are designed to be mutually exclusive (only one is used per query).
+
+This code is derived from the DuckDuckGoSearchTool class in the HuggingFace
+smolagents library.
+
+TODO:
+GoogleCustomSearchTool and BraveSearchTool are not using kwarg in init.
+
+requires:
+google-api-python-client
+brave-search
+"""
+
+
+class PrioritySearchTool(Tool):
+    """A tool that executes searches using multiple search tools in a prioritized order.
+
+    This tool takes a list of search tools and executes a query using them. It returns
+    the first successful result.  Results are optionally cached and saved to a JSON file.
+
+    Attributes:
+        name (str): The name of the tool.
+        description (str): A description of the tool.
+        inputs (dict): The input schema for the tool.
+        output_type (str): The output type of the tool.
+        search_tools (list[Tool]): A list of search tools to use for searching.
+        save_json_path (str, optional): The path to a JSON file where search results
+            will be saved. Defaults to None.
+        history_results (dict): A dictionary storing past search results.
+
+    """
+
+    name = "web_search"
+    description = """Performs a google-custom 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,
+        search_tools: list[Tool],
+        save_json_path: str = None,
+        **kwargs,
+    ):
+        super().__init__()
+        self.search_tools = search_tools
+        self.save_json_path = save_json_path
+        self.history_results = {}
+
+    def forward(self, query: str) -> str:
+        if os.path.exists(self.save_json_path):
+            with open(self.save_json_path, "r") as file:
+                self.history_results = json.load(file)
+                if query in self.history_results:
+                    return self.history_results[query]["data"]
+
+        for search_tool in self.search_tools:
+            try:
+                result = search_tool(query=query)
+                if self.save_json_path:
+                    class_name = search_tool.__class__.__name__
+                    self.history_results[query] = {
+                        "cdate": str(datetime.now()),
+                        "name": class_name,
+                        "data": result,
+                    }
+                    with open(self.save_json_path, "w") as file:
+                        json.dump(self.history_results, file)
+                return result
+
+            except Exception as e:
+                print(f"{e}")
+        raise Exception("All search tools failed.")
+
+
+class GoogleCustomSearchTool(Tool):
+    """
+    use
+    https://github.com/googleapis/google-api-python-client/
+
+    parameter
+    https://developers.google.com/custom-search/v1/reference/rest/v1/cse/list
+
+    Exp:another language
+    search = GoogleCustomSearchTool("33ec073e195bc4fcf", cr="countryJP", lr="lang_ja")
+    """
+
+    name = "web_search"
+    description = """Performs a google-custom 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, cx, max_results=10, **kwargs):
+        super().__init__()
+        if cx is None:
+            raise ValueError(
+                "Need CX(Search Engine ID) need create in custom-search controlpanel"
+            )
+        self.cx = cx
+        self.max_results = max_results
+        api_key_env_name = "GOOGLE_CUSTOM_SEARCH_KEY"
+        self.kwargs = kwargs
+        try:
+            from googleapiclient.discovery import build
+        except ImportError as e:
+            raise ImportError(
+                "You must install package `google-api-python-client` to run this tool: for instance run `pip install google-api-python-client`."
+            ) from e
+        import os
+
+        self.key = os.getenv(api_key_env_name)
+
+        self.custom_search = build("customsearch", "v1")
+
+    def forward(self, query: str) -> str:
+        results = (
+            self.custom_search.cse()
+            .list(
+                key=self.key, q=query, cx=self.cx, num=self.max_results, **self.kwargs
+            )
+            .execute()
+        )
+
+        results = results["items"]
+
+        if len(results) == 0:
+            raise Exception("No results found! Try a less restrictive/shorter query.")
+        postprocessed_results = [
+            f"[{result['title']}]({result['link']})\n{result['snippet']}"
+            for result in results
+        ]
+        return "## Search Results\n\n" + "\n\n".join(postprocessed_results)
+
+
+from smolagents import Tool
+import json
+
+
+class BraveSearchTool(Tool):
+    """
+    Use
+    https://github.com/kayvane1/brave-api
+
+    query parameter
+    https://api-dashboard.search.brave.com/app/documentation/web-search/query
+
+    Exp:another language
+    search = BraveSearchTool(country="JP", search_lang="jp")
+    """
+
+    name = "web_search"
+    description = """Performs a google-custom 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=10, **kwargs):
+        super().__init__()
+        self.max_results = max_results
+        api_key_env_name = "BRAVE_SEARCH_KEY"
+        self.kwargs = kwargs
+        try:
+            from brave import Brave
+        except ImportError as e:
+            raise ImportError(
+                # there are another lib.but this one work one python-3.10
+                "You must install package `brave-search` to run this tool: for instance run `pip install pip install brave-search`."
+            ) from e
+        import os
+
+        self.brave = Brave(api_key=os.getenv(api_key_env_name))
+
+    def clean(text):
+        return text.replace("<STRING>", "").replace("</STRONG>")
+
+    def forward(self, query: str) -> str:
+        search_results = self.brave.search(
+            q=query, count=self.max_results, **self.kwargs
+        )
+        # pprint.pprint(search_results, indent=4)
+        results = search_results.web_results
+        # pprint.pprint(search_results.web_results, indent=4)
+        if len(results) == 0:
+            raise Exception("No results found! Try a less restrictive/shorter query.")
+        postprocessed_results = [
+            f"[{result['title']}]({result['url']._url})\n{self.clean(result['description'])}"
+            for result in results
+        ]
+        return "## Search Results\n\n" + "\n\n".join(postprocessed_results)

history.json

@@ -0,0 +1 @@
+{"smolagents": {"cdate": "2025-03-14 16:04:17.000743", "name": "DuckDuckGoSearchTool", "data": "## Search Results\n\n[smolagents: a barebones library for agents. Agents write ... - GitHub](https://github.com/huggingface/smolagents)\nsmolagents is a library that enables you to run powerful agents in a few lines of code. It supports CodeAgents that write actions as Python code snippets, and integrates with various tools and models from Hugging Face Hub and other providers.\n\n[smolagents - Hugging Face](https://huggingface.co/docs/smolagents/index)\nsmolagents is a library that lets you create powerful agents with any LLM, including Code Agents. Learn how to use it with guides, tutorials and examples on the Hugging Face documentation.\n\n[Smolagents : Huggingface AI Agent Framework](https://smolagents.org/)\nSmolagents is a minimalist and efficient framework for creating and running AI agents with large language models. Learn how to use code agents, tools, and the Hugging Face Hub to build powerful and versatile agents for various tasks.\n\n[Agents - Guided tour - Smolagents](https://smolagents.org/docs/agents-guided-tour/)\nSmolagents lets you create agents that can use text-generation models and tools to solve tasks. Learn how to initialize, run, and customize agents with different models, tools, and options.\n\n[Building good Smolagents - Smolagents](https://smolagents.org/docs/building-good-smolagents/)\nSmolagents is a framework for creating agents that can perform tasks using natural language and external tools. Learn best practices for simplifying workflows, improving information flow, and debugging agents with LLMs.\n\n[Introducing smolagents , a simple library to build agents - Hugging Face](https://huggingface.co/blog/smolagents)\nsmolagents is a simple library that unlocks agentic capabilities for language models. It allows LLMs to write actions in code, such as calling external tools or executing loops, to solve real-world tasks.\n\n[Introduction to Agents - Hugging Face](https://huggingface.co/docs/smolagents/conceptual_guides/intro_agents)\nsmolagents documentation Introduction to Agents. smolagents Search documentation. Get started. \ud83e\udd17 Agents Guided tour. Tutorials. Building good agents \ud83d\udcca Inspect your agent runs using telemetry \ud83d\udee0\ufe0f Tools - in-depth guide \ud83d\udee1\ufe0f Secure code execution \ud83d\udcda Manage your agent's memory. Conceptual guides ...\n\n[smolagents/README.md at main \u00b7 huggingface/smolagents - GitHub](https://github.com/huggingface/smolagents/blob/main/README.md)\nsmolagents is a Python library that lets you create agents that can perform tasks using natural language and various tools. It supports code agents, model-agnostic agents, modality-agnostic agents, and tool-agnostic agents.\n\n[smolagents \u00b7 PyPI](https://pypi.org/project/smolagents/)\nsmolagents is a library that enables you to run powerful agents in a few lines of code. It offers: Simplicity: the logic for agents fits in ~1,000 lines of code (see agents.py).We kept abstractions to their minimal shape above raw code! \ud83e\uddd1\u200d\ud83d\udcbb First-class support for Code Agents.Our CodeAgent writes its actions in code (as opposed to \"agents being used to write code\").\n\n[SmolAgents. SmolAgents from HuggingFace | by Cobus Greyling | Feb, 2025 ...](https://cobusgreyling.medium.com/smolagents-7a4bf7712814)\nHugging Face launched SmolAgents with a clear mission: to democratise the creation of sophisticated agentic systems by prioritising simplicity and reducing technical overhead.. Unlike more complex frameworks, which often involve intricate architectures, SmolAgents intentionally strips away unnecessary layers of abstraction. The library emphasises lightweight efficiency without sacrificing ..."}, "What is smolagents?": {"cdate": "2025-03-14 18:08:58.593568", "name": "DuckDuckGoSearchTool", "data": "## Search Results\n\n[smolagents - Hugging Face](https://huggingface.co/docs/smolagents/index)\nsmolagents. This library is the simplest framework out there to build powerful agents! By the way, wtf are \"agents\"? We provide our definition in this page, where you'll also find tips for when to use them or not (spoilers: you'll often be better off without agents).\n\n[Smolagents : Huggingface AI Agent Framework](https://smolagents.org/)\n\ud83e\udd17 Smolagents is a minimalist AI agent framework developed by the Hugging Face team, crafted to enable developers to deploy robust agents with just a few lines of code. Embracing simplicity and efficiency, smolagents empowers large language models (LLMs) to interact seamlessly with the real world.\n\n[Introducing smolagents , a simple library to build agents - Hugging Face](https://huggingface.co/blog/smolagents)\nsmolagents is the successor to transformers.agents, and will be replacing it as transformers.agents gets deprecated in the future. Building an agent To build an agent, you need at least two elements: tools: a list of tools the agent has access to;\n\n[smolagents: a barebones library for agents. Agents write ... - GitHub](https://github.com/huggingface/smolagents)\nsmolagents is a library that enables you to run powerful agents in a few lines of code. It offers: Simplicity: the logic for agents fits in ~1,000 lines of code (see agents.py).We kept abstractions to their minimal shape above raw code! \ud83e\uddd1\u200d\ud83d\udcbb First-class support for Code Agents.Our CodeAgent writes its actions in code (as opposed to \"agents being used to write code\").\n\n[What are SmolAgents?: A Easy Guide With Code Examples](https://analyticsiksha.com/smolagents-by-hugging-face-a-comprehensive-guide/)\nIn the evolving world of artificial intelligence, Hugging Face has once again pushed the boundaries of innovation with its latest release: SmolAgents. SmolAgents - This lightweight, efficient, and versatile framework for building and running AI agents is designed to simplify complex workflows, making AI-powered solutions more accessible than ...\n\n[SmolAgents by Hugging Face: Build AI Agents in Under 30 Lines](https://www.analyticsvidhya.com/blog/2025/01/smolagents/)\nSmolAgents is an innovative library designed to simplify the creation and execution of powerful agents. Developed by Hugging Face, it stands out for its minimalist approach, with the entire agent logic encapsulated in approximately 1,000 lines of code. This streamlined design ensures ease of use while maintaining robust functionality.\n\n[Agents - Guided tour - Smolagents](https://smolagents.org/docs/agents-guided-tour/)\nfrom smolagents import tool @tool def model_download_tool(task: str) -> str: \"\"\" This is a tool that returns the most downloaded model of a given task on the Hugging Face Hub. It returns the name of the checkpoint.\n\n[HuggingFace smolagents: The best Multi-Agent framework so far?](https://medium.com/data-science-in-your-pocket/huggingface-smolagents-the-best-multi-agent-framework-so-far-313178ef3c2e)\nWhat are smolagents? Smolagents is a newly launched agent framework by Hugging Face, designed to simplify the creation of intelligent agents that leverage large language models (LLMs).\n\n[smolagents\u2014Simplifying AI Agent Development](https://smolagents.org/smolagents-simplifying-ai-agent-development/)\nWhat is smolagents? smolagents is an open-source, lightweight AI agent library that allows developers to create powerful agents with minimal code. With a core codebase of approximately 1,000 lines in agents.py, smolagents reduces unnecessary abstractions, making the development process straightforward and accessible.By focusing on simplicity and efficiency, smolagents enables LLMs to interact ...\n\n[Getting Started with Smolagents](https://debuggercafe.com/smolagents/)\nWe have three Python files: app.py, tool.py, tool_config.py. The primary code resides in the tool.py file. This contains a class to generate the image and is a subclass of the Tool class.. The app.py file just imports the class and launches the Gradio demo.. And finally, the tool_config.py file is what tells the load_tool function that this is a tool and how to use it."}}

requirements.txt

@@ -0,0 +1,42 @@
+smolagents==1.9.1
+anthropic>=0.37.1
+beautifulsoup4>=4.12.3
+datasets>=2.21.0
+google_search_results>=2.4.2
+huggingface_hub>=0.23.4
+mammoth>=1.8.0
+markdownify>=0.13.1
+numexpr>=2.10.1
+numpy>=2.1.2
+openai>=1.52.2
+openpyxl
+pandas>=2.2.3
+pathvalidate>=3.2.1
+pdfminer>=20191125
+pdfminer.six>=20240706
+Pillow>=11.0.0
+puremagic>=1.28
+pypdf>=5.1.0
+python-dotenv>=1.0.1
+python_pptx>=1.0.2
+Requests>=2.32.3
+serpapi>=0.1.5
+tqdm>=4.66.4
+torch>=2.2.2
+torchvision>=0.17.2
+transformers>=4.46.0
+youtube_transcript_api>=0.6.2
+chess
+sympy
+pubchempy
+Bio
+scikit-learn
+scipy
+pydub
+PyPDF2
+python-pptx
+torch
+xlrd
+SpeechRecognition
+litellm
+duckduckgo-search