#
Agents on the Hub

This page compiles all the libraries and tools Hugging Face offers for agentic workflows: huggingface.js mcp-client, Gradio MCP Server and smolagents.

##
smolagents

smolagents is a lightweight library to cover all agentic use cases, from code-writing agents to computer use, in few lines of code. It is model agnostic, supporting local models served with Hugging Face Transformers, as well as models offered with Inference Providers, and proprietary model providers.

It offers a unique kind of agent :`CodeAgent`, an agent that writes its actions in Python code. It also supports the standard agent that writes actions in JSON blobs as most other agentic frameworks do, called `ToolCallingAgent`. To learn more about write actions in code vs JSON, check out our new short course on DeepLearning.AI.

If you want to avoid defining agents yourself, the easiest way to start an agent is through the CLI, using the `smolagent` command.

    smolagent "Plan a trip to Tokyo, Kyoto and Osaka between Mar 28 and Apr 7." \
    --model-type "InferenceClientModel" \
    --model-id "Qwen/Qwen2.5-Coder-32B-Instruct" \
    --imports "pandas numpy" \
    --tools "web_search"

Agents can be pushed to Hugging Face Hub as Spaces. Check out all the cool agents people have built here.

smolagents also supports MCP servers as tools, as follows:

    # pip install --upgrade smolagents mcp
    from smolagents import MCPClient, CodeAgent
    from mcp import StdioServerParameters
    import os

    server_parameters = StdioServerParameters(
        command="uvx",  # Using uvx ensures dependencies are available
        args=["--quiet", "pubmedmcp@0.1.3"],
        env={"UV_PYTHON": "3.12", **os.environ},
    )

    with MCPClient(server_parameters) as tools:
        agent = CodeAgent(tools=tools, model=model, add_base_tools=True)
        agent.run("Please find the latest research on COVID-19 treatment.")

Learn more in the documentation.

##
huggingface.js mcp-client

Huggingface.js offers an MCP client served with Inference Providers or local LLMs. Getting started with them is as simple as running `pnpm agent`. You can plug and play different models and providers by setting `PROVIDER` and `MODEL_ID` environment variables.

    export HF_TOKEN="hf_..."
    export MODEL_ID="Qwen/Qwen2.5-72B-Instruct"
    export PROVIDER="nebius"
    npx @huggingface/mcp-client

or, you can use any Local LLM (for example via lmstudio):

    ENDPOINT_URL=http://localhost:1234/v1 \
    MODEL_ID=lmstudio-community/Qwen3-14B-GGUF \
    npx @huggingface/mcp-client

You can get more information about mcp-client here.

##
Gradio MCP Server / Tools

You can build an MCP server in just a few lines of Python with Gradio. If you have an existing Gradio app or Space you’d like to use as an MCP server / tool, it’s just a single-line change.

To make a Gradio application an MCP server, simply pass in `mcp_server=True` when launching your demo like follows.

    # pip install gradio

    import gradio as gr

    def generate_image(prompt: str):
       """
       Generate an image based on a text prompt

       Args:
           prompt: a text string describing the image to generate
       """
       pass

    demo = gr.Interface(
        fn=generate_image,
        inputs="text",
        outputs="image",
        title="Image Generator"
    )

    demo.launch(mcp_server=True)

The MCP server will be available at `http://your-space-id.hf.space/gradio_api/mcp/sse` where your application is served. It will have a tool corresponding to each function in your Gradio app, with the tool description automatically generated from the docstrings of your functions.

Lastly, add this to the settings of the MCP Client of your choice (e.g. Cursor).

    {
      "mcpServers": {
        "gradio": {
          "url": "http://your-server:port/gradio_api/mcp/sse"
        }
      }
    }

This is very powerful because it lets the LLM use any Gradio application as a tool. You can find thousands of them on Spaces. Learn more here.

< > Update on GitHub