SIGN UPLOG IN
X (Twitter)LinkedInGitHubDiscordYouTube

How to integrate Missive MCP with Autogen

Connect Autogen to Missive MCP. List all team members for marketing, create a draft email for client follow-up, and more using natural language, with authentication handled for you.

Get started for freeGet a demo
Missive logoMissive
Api Key

Missive is a collaborative email and chat app for teams to manage conversations and tasks together. It helps streamline team inboxes, shared labels, and internal discussion in one place.

40 Tools

Introduction

This guide walks you through connecting Missive to AutoGen using the Composio tool router. By the end, you'll have a working Missive agent that can create drafts and posts, list conversations and messages, manage contacts, create tasks, and organize shared labels through natural language commands.

This guide will help you understand how to give your AutoGen agent real control over a Missive account through Composio's Missive MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

Also integrate Missive with

Claude CodeClaude CoworkOpenAI Agents SDKClaude Agent SDKCodexOpenClawHermesAtomic AgentGoogle ADKLangChainVercel AI SDKMastra AILlamaIndexCrewAIPydantic AI

TL;DR

Here's what you'll learn:
  • Get and set up your OpenAI and Composio API keys
  • Install the required dependencies for Autogen and Composio
  • Initialize Composio and create a Tool Router session for Missive
  • Wire that MCP URL into Autogen using McpWorkbench and StreamableHttpServerParams
  • Configure an Autogen AssistantAgent that can call Missive tools
  • Run a live chat loop where you ask the agent to perform Missive operations

What is AutoGen?

Autogen is a framework for building multi-agent conversational AI systems from Microsoft. It enables you to create agents that can collaborate, use tools, and maintain complex workflows.

Key features include:

  • Multi-Agent Systems: Build collaborative agent workflows
  • MCP Workbench: Native support for Model Context Protocol tools
  • Streaming HTTP: Connect to external services through streamable HTTP
  • AssistantAgent: Pre-built agent class for tool-using assistants

What is the Missive MCP server, and what's possible with it?

The Missive MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Missive account. It provides structured and secure access to your team's shared inboxes and chat threads, so your agent can perform actions like drafting emails, sending messages, generating reports, and managing team communication on your behalf.

  • Automated message drafting and scheduling: Let your agent create and save email, SMS, WhatsApp, or live chat drafts for later editing or scheduled sending.
  • Instant message sending in conversations: Have your agent send new messages directly to any Missive conversation, keeping your team in the loop in real time.
  • Team and user management: Effortlessly list all teams and their members, or pull a full directory of users in your Missive organization for easy coordination and task assignment.
  • Analytics report generation: Direct your agent to create detailed analytics reports across time ranges and filters, helping your team track productivity and engagement.
  • Webhook automation setup: Enable your agent to create or delete webhook subscriptions, so you can automate notifications and integrations with other tools as needed.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step08 STEPS
1

Prerequisites

You will need:

  • A Composio API key
  • An OpenAI API key (used by Autogen's OpenAIChatCompletionClient)
  • A Missive account you can connect to Composio
  • Some basic familiarity with Autogen and Python async
2

Getting API Keys for OpenAI and Composio

OpenAI API Key
  • Go to the OpenAI dashboard and create an API key. You'll need credits to use the models, or you can connect to another model provider.
  • Keep the API key safe.
Composio API Key
  • Log in to the Composio dashboard.
  • Navigate to your API settings and generate a new API key.
  • Store this key securely as you'll need it for authentication.
3

Install dependencies

bash
pip install composio python-dotenv
pip install autogen-agentchat autogen-ext-openai autogen-ext-tools

Install Composio, Autogen extensions, and dotenv.

What's happening:

  • composio connects your agent to Missive via MCP
  • autogen-agentchat provides the AssistantAgent class
  • autogen-ext-openai provides the OpenAI model client
  • autogen-ext-tools provides MCP workbench support

4

Set up environment variables

bash
COMPOSIO_API_KEY=your-composio-api-key
OPENAI_API_KEY=your-openai-api-key
USER_ID=your-user-identifier@example.com

Create a .env file in your project folder.

What's happening:

  • COMPOSIO_API_KEY is required to talk to Composio
  • OPENAI_API_KEY is used by Autogen's OpenAI client
  • USER_ID is how Composio identifies which user's Missive connections to use
5

Import dependencies and create Tool Router session

python
import asyncio
import os
from dotenv import load_dotenv
from composio import Composio

from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import McpWorkbench, StreamableHttpServerParams

load_dotenv()

async def main():
    # Initialize Composio and create a Missive session
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))
    session = composio.create(
        user_id=os.getenv("USER_ID"),
        toolkits=["missive"]
    )
    url = session.mcp.url
What's happening:
  • load_dotenv() reads your .env file
  • Composio(api_key=...) initializes the SDK
  • create(...) creates a Tool Router session that exposes Missive tools
  • session.mcp.url is the MCP endpoint that Autogen will connect to
6

Configure MCP parameters for Autogen

python
# Configure MCP server parameters for Streamable HTTP
server_params = StreamableHttpServerParams(
    url=url,
    timeout=30.0,
    sse_read_timeout=300.0,
    terminate_on_close=True,
    headers={"x-api-key": os.getenv("COMPOSIO_API_KEY")}
)

Autogen expects parameters describing how to talk to the MCP server. That is what StreamableHttpServerParams is for.

What's happening:

  • url points to the Tool Router MCP endpoint from Composio
  • timeout is the HTTP timeout for requests
  • sse_read_timeout controls how long to wait when streaming responses
  • terminate_on_close=True cleans up the MCP server process when the workbench is closed
7

Create the model client and agent

python
# Create model client
model_client = OpenAIChatCompletionClient(
    model="gpt-5",
    api_key=os.getenv("OPENAI_API_KEY")
)

# Use McpWorkbench as context manager
async with McpWorkbench(server_params) as workbench:
    # Create Missive assistant agent with MCP tools
    agent = AssistantAgent(
        name="missive_assistant",
        description="An AI assistant that helps with Missive operations.",
        model_client=model_client,
        workbench=workbench,
        model_client_stream=True,
        max_tool_iterations=10
    )

What's happening:

  • OpenAIChatCompletionClient wraps the OpenAI model for Autogen
  • McpWorkbench connects the agent to the MCP tools
  • AssistantAgent is configured with the Missive tools from the workbench
8

Run the interactive chat loop

python
print("Chat started! Type 'exit' or 'quit' to end the conversation.\n")
print("Ask any Missive related question or task to the agent.\n")

# Conversation loop
while True:
    user_input = input("You: ").strip()

    if user_input.lower() in ["exit", "quit", "bye"]:
        print("\nGoodbye!")
        break

    if not user_input:
        continue

    print("\nAgent is thinking...\n")

    # Run the agent with streaming
    try:
        response_text = ""
        async for message in agent.run_stream(task=user_input):
            if hasattr(message, "content") and message.content:
                response_text = message.content

        # Print the final response
        if response_text:
            print(f"Agent: {response_text}\n")
        else:
            print("Agent: I encountered an issue processing your request.\n")

    except Exception as e:
        print(f"Agent: Sorry, I encountered an error: {str(e)}\n")
What's happening:
  • The script prompts you in a loop with You:
  • Autogen passes your input to the model, which decides which Missive tools to call via MCP
  • agent.run_stream(...) yields streaming messages as the agent thinks and calls tools
  • Typing exit, quit, or bye ends the loop

Complete Code

Here's the complete code to get you started with Missive and AutoGen:

python
import asyncio
import os
from dotenv import load_dotenv
from composio import Composio

from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import McpWorkbench, StreamableHttpServerParams

load_dotenv()

async def main():
    # Initialize Composio and create a Missive session
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))
    session = composio.create(
        user_id=os.getenv("USER_ID"),
        toolkits=["missive"]
    )
    url = session.mcp.url

    # Configure MCP server parameters for Streamable HTTP
    server_params = StreamableHttpServerParams(
        url=url,
        timeout=30.0,
        sse_read_timeout=300.0,
        terminate_on_close=True,
        headers={"x-api-key": os.getenv("COMPOSIO_API_KEY")}
    )

    # Create model client
    model_client = OpenAIChatCompletionClient(
        model="gpt-5",
        api_key=os.getenv("OPENAI_API_KEY")
    )

    # Use McpWorkbench as context manager
    async with McpWorkbench(server_params) as workbench:
        # Create Missive assistant agent with MCP tools
        agent = AssistantAgent(
            name="missive_assistant",
            description="An AI assistant that helps with Missive operations.",
            model_client=model_client,
            workbench=workbench,
            model_client_stream=True,
            max_tool_iterations=10
        )

        print("Chat started! Type 'exit' or 'quit' to end the conversation.\n")
        print("Ask any Missive related question or task to the agent.\n")

        # Conversation loop
        while True:
            user_input = input("You: ").strip()

            if user_input.lower() in ['exit', 'quit', 'bye']:
                print("\nGoodbye!")
                break

            if not user_input:
                continue

            print("\nAgent is thinking...\n")

            # Run the agent with streaming
            try:
                response_text = ""
                async for message in agent.run_stream(task=user_input):
                    if hasattr(message, 'content') and message.content:
                        response_text = message.content

                # Print the final response
                if response_text:
                    print(f"Agent: {response_text}\n")
                else:
                    print("Agent: I encountered an issue processing your request.\n")

            except Exception as e:
                print(f"Agent: Sorry, I encountered an error: {str(e)}\n")

if __name__ == "__main__":
    asyncio.run(main())

Conclusion

You now have an Autogen assistant wired into Missive through Composio's Tool Router and MCP. From here you can:
  • Add more toolkits to the toolkits list, for example notion or hubspot
  • Refine the agent description to point it at specific workflows
  • Wrap this script behind a UI, Slack bot, or internal tool
Once the pattern is clear for Missive, you can reuse the same structure for other MCP-enabled apps with minimal code changes.
TOOLS

Supported Tools

Every Missive action and event your agent gets out of the box.

Create Analytics Report

Tool to create an analytics report.

Create Missive Contacts

Tool to create one or more contacts in a Missive contact book.

Create Draft

Create a Missive draft for email, SMS, WhatsApp, or Live Chat, for later editing or scheduling.

Create Missive Post

Create a post in an existing Missive conversation, optionally closing it, assigning users, applying labels, or moving it to the inbox.

Create Canned Response

Tool to create one or more canned responses (templates) in Missive.

Create Shared Label

Tool to create one or more shared labels at the organization level.

Create Missive Task

Tool to create a task in Missive.

Create Team

Create a team in an organization with active members and optional observers.

Create Webhook

Tool to create a webhook subscription.

Delete Draft

Tool to delete a draft from a conversation by draft ID.

Delete Post

Delete a post from a conversation by post ID.

Delete Saved Responses

Delete one or more saved responses by ID; responses created by external integrations cannot be deleted through this endpoint.

Delete Webhook

Tool to delete a webhook subscription by webhook ID.

Get Analytics Report

Fetch a completed analytics report by ID.

Get Missive Contact

Tool to fetch a specific contact using the contact ID.

Get Missive Conversation

Fetch conversation metadata by ID, including assignees, users, labels, team and organization.

List Conversation Messages

Tool to list messages belonging to a Missive conversation (newest first).

Get Missive Message

Fetch message details by ID, including headers, HTML body and attachment download URLs when available.

Get Missive Response

Tool to fetch a specific saved response using the response ID.

Get Missive Task

Tool to get a single task by ID with full details including assignees, team, and conversation info.

List Missive Contact Books

Tool to list contact books the authenticated user has access to.

List Missive Contact Groups

Tool to list contact groups or organizations linked to a contact book.

List Missive Contacts

Tool to list contacts from a contact book.

List Conversation Comments

Tool to list comments in a Missive conversation ordered from newest to oldest.

List Conversation Drafts

Tool to list draft messages in a Missive conversation (newest first).

List Conversation Posts

List posts in a Missive conversation, newest first.

List Missive Conversations

List conversations visible to the authenticated user, ordered by newest activity first, using a required mailbox, shared label, or team filter.

List Messages by Message-ID

Tool to fetch messages matching an email Message-ID header.

List Missive Organizations

Tool to list organizations the authenticated user is part of.

List Missive Saved Responses

Tool to list saved responses (canned responses/templates) for the authenticated user.

List Missive Shared Labels

List shared labels accessible to the authenticated user, optionally filtered by organization.

List Missive Tasks

Tool to list tasks accessible to the authenticated user.

List Missive Teams

List teams accessible to the authenticated user in their organizations.

List Missive Users

List users in organizations the authenticated user belongs to.

Merge Missive Conversations

Merge a source Missive conversation into a target, combining their messages, posts, and other entries.

Update Missive Contact

Tool to update one or more contacts in Missive.

Update Saved Response

Update one or more saved response templates, including their title, body, subject, and other attributes; externally integrated responses cannot be updated.

Update Shared Labels

Update the names and colors of one or more Missive shared labels and return the updated labels.

Update Missive Task

Update an existing Missive task by ID.

Update Missive Team

Tool to update one or more teams in Missive.

FRAMEWORKS

How to build Missive MCP Agent with another framework

Claude Code logo

Claude Code

Use Missive MCP with Claude Code

Claude Cowork logo

Claude Cowork

Use Missive MCP with Claude Cowork

OpenAI Agents SDK logo

OpenAI Agents SDK

Use Missive MCP with OpenAI Agents SDK

Claude Agent SDK logo

Claude Agent SDK

Use Missive MCP with Claude Agent SDK

Codex logo

Codex

Use Missive MCP with Codex

OpenClaw logo

OpenClaw

Use Missive MCP with OpenClaw

Hermes logo

Hermes

Use Missive MCP with Hermes

Atomic Agent logo

Atomic Agent

Use Missive MCP with Atomic Agent

Google ADK logo

Google ADK

Use Missive MCP with Google ADK

LangChain logo

LangChain

Use Missive MCP with LangChain

Vercel AI SDK logo

Vercel AI SDK

Use Missive MCP with Vercel AI SDK

Mastra AI logo

Mastra AI

Use Missive MCP with Mastra AI

LlamaIndex logo

LlamaIndex

Use Missive MCP with LlamaIndex

CrewAI logo

CrewAI

Use Missive MCP with CrewAI

Pydantic AI logo

Pydantic AI

Use Missive MCP with Pydantic AI

FAQ

Frequently asked questions

Start with Missive.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Missive tool your agent needs.Free to start.

Start building