smolagents Email Integration

How It Works

smolagents has shipped MCP support since v1.14.0: MCPClient (and the equivalent ToolCollection.from_mcp) connects to an MCP server, discovers its tools, and hands them to your agent as ordinary smolagents tools. Dead Simple Email runs a hosted MCP server over streamable HTTP, authenticated with your API key in an Authorization header — so the integration is a connection dict, not an adapter package.

We don't ship a dedicated smolagents package, and you won't miss it: MCP covers the full toolset, and for narrow use cases the @tool decorator wraps our Python SDK in a few lines.

Quick Start: MCPClient

pip install "smolagents[mcp]"

import os
from smolagents import MCPClient, CodeAgent, InferenceClientModel

server = {
    "url": "https://api.deadsimple.email/mcp",
    "transport": "streamable-http",
    "headers": {"Authorization": f"Bearer {os.environ['DSE_API_KEY']}"},
}

with MCPClient(server) as tools:
    agent = CodeAgent(tools=tools, model=InferenceClientModel())
    agent.run("Create an inbox and send a hello email to team@example.com")

The context manager keeps the MCP connection open for the agent run and closes it cleanly afterwards. All 14 tools load: create_inbox, list_inboxes, delete_inbox, send_email, read_messages, read_message, reply_to_message, forward_message, wait_for_email, get_verification_code, get_verification_link, list_threads, read_thread, and get_usage.

Prefer the ToolCollection idiom? Same dict, same result:

from smolagents import ToolCollection, CodeAgent, InferenceClientModel

with ToolCollection.from_mcp(server, trust_remote_code=True) as tc:
    agent = CodeAgent(tools=[*tc.tools], model=InferenceClientModel())
    agent.run("Check the support inbox and summarize unanswered threads.")

Running local and offline-ish? The same server runs over stdio as a subprocess: python -m deadsimple.mcp with DSE_API_KEY set (pip install deadsimple-email[mcp]), connected via StdioServerParameters.

Alternative: A Hand-Written @tool

If your agent only needs one email capability, skip MCP and wrap the SDK directly. smolagents builds the tool schema from the signature and the Args docstring:

# pip install smolagents deadsimple-email
from smolagents import tool, CodeAgent, InferenceClientModel
from deadsimple import DeadSimple

client = DeadSimple(api_key="dse_your_api_key")

@tool
def send_email(inbox_id: str, to: str, subject: str, body: str) -> str:
    """Send an email from a Dead Simple Email inbox.

    Args:
        inbox_id: ID of the inbox to send from.
        to: Recipient email address.
        subject: Subject line.
        body: Plain-text body of the email.
    """
    result = client.messages.send(inbox_id, to, subject, text_body=body)
    return f"Sent: {result.message_id}"

agent = CodeAgent(tools=[send_email], model=InferenceClientModel())
agent.run("Email team@example.com from inbox inb_123 to confirm the deploy.")

The same pattern wraps any SDK call — client.inboxes.create(), client.messages.wait_for(), client.messages.get_verification(). Because CodeAgent writes Python to chain its tools, a single run can create an inbox, send outreach, and wait for the reply in one generated snippet.

Frequently Asked Questions