Microsoft Agent Framework Email Integration

Coming from AutoGen or Semantic Kernel? Microsoft Agent Framework reached 1.0 GA in April 2026 and is the official successor absorbing both projects — their READMEs now redirect new work to it. If you have existing AutoGen code, our legacy AutoGen adapter keeps working. For new projects, use the Agent Framework setup on this page.

How It Works

Agent Framework treats MCP servers as first-class tool sources. Dead Simple Email runs a hosted MCP server at https://api.deadsimple.email/mcp that authenticates with your API key in an Authorization header. Point MCPStreamableHTTPTool at it and your agent discovers all 14 email tools automatically — no tool schemas, no API glue code.

To be clear about what ships where: we do not publish a dedicated agent-framework adapter package as of August 2026. You don't need one — MCP is the integration surface Microsoft built for exactly this, and it works with both the Python and .NET versions of Agent Framework. If you prefer explicit code over MCP, the custom function tool section below wraps our Python SDK directly.

Quick Start: MCP

Install Agent Framework, then connect the hosted MCP server:

pip install agent-framework

import asyncio
from agent_framework import ChatAgent, MCPStreamableHTTPTool
from agent_framework.openai import OpenAIChatClient

async def main():
    email_tools = MCPStreamableHTTPTool(
        name="deadsimple-email",
        url="https://api.deadsimple.email/mcp",
        headers={"Authorization": "Bearer dse_your_api_key"},
    )

    async with email_tools:
        agent = ChatAgent(
            chat_client=OpenAIChatClient(model_id="gpt-4o"),
            name="email_agent",
            instructions="You manage email with Dead Simple Email.",
            tools=email_tools,
        )
        result = await agent.run("Create an inbox and send a hello email to team@example.com")
        print(result)

asyncio.run(main())

The async with block opens the MCP connection, discovers the tools, and closes cleanly when done. The agent decides which tools to call — here it will chain create_inbox and send_email on its own.

Available Tools

The MCP server exposes 14 tools covering the full agent email workflow:

If you run agents locally and prefer a subprocess over a remote connection, the same server runs over stdio: python -m deadsimple.mcp with the DSE_API_KEY environment variable set (requires pip install deadsimple-email[mcp]).

Alternative: Custom Function Tool

Agent Framework converts plain Python functions into tool schemas from type annotations. If you want tighter control than MCP — one narrowly-scoped tool instead of fourteen — wrap the Python SDK yourself:

# pip install agent-framework deadsimple-email
from typing import Annotated
from pydantic import Field
from agent_framework import ChatAgent
from agent_framework.openai import OpenAIChatClient
from deadsimple import DeadSimple

client = DeadSimple(api_key="dse_your_api_key")

def send_email(
    inbox_id: Annotated[str, Field(description="ID of the sending inbox")],
    to: Annotated[str, Field(description="Recipient email address")],
    subject: Annotated[str, Field(description="Subject line")],
    body: Annotated[str, Field(description="Plain-text body")],
) -> str:
    """Send an email from a Dead Simple Email inbox."""
    result = client.messages.send(inbox_id, to, subject, text_body=body)
    return f"Sent ({result.message_id})"

agent = ChatAgent(
    chat_client=OpenAIChatClient(model_id="gpt-4o"),
    instructions="You send email follow-ups for the team.",
    tools=[send_email],
)

The same pattern works for any SDK call — client.inboxes.create(), client.messages.wait_for(), client.messages.reply(), and so on. Mix custom function tools and the MCP toolset freely in the same tools list.

Frequently Asked Questions