How to integrate Miro MCP with OpenAI Agents SDK

Connect OpenAI Agents SDK to Miro MCP. Create a new board for marketing brainstorm, list all boards owned by your team, and more using natural language, with authentication handled for you.

Miro logoMiro
Oauth2

Miro is a collaborative online whiteboard platform for teams to brainstorm, design, and manage projects visually. It streamlines teamwork by enabling real-time idea sharing, diagramming, and workflow planning in a single space.

85 Tools

Introduction

This guide walks you through connecting Miro to the OpenAI Agents SDK using the Composio tool router. By the end, you'll have a working Miro agent that can create boards, add sticky notes and shapes, connect items, manage frames and tags, and share boards through natural language commands.

This guide will help you understand how to give your OpenAI Agents SDK agent real control over a Miro account through Composio's Miro MCP server.

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

For exact tool slugs and parameter tables, see the tool catalog in the Composio docs.

Also integrate Miro with

TL;DR

Here's what you'll learn:
  • Get and set up your OpenAI and Composio API keys
  • Install the necessary dependencies
  • Initialize Composio and create a Tool Router session for Miro
  • Configure an AI agent that can use Miro as a tool
  • Run a live chat session where you can ask the agent to perform Miro operations

What is OpenAI Agents SDK?

The OpenAI Agents SDK is a lightweight framework for building AI agents that can use tools and maintain conversation state. It provides a simple interface for creating agents with hosted MCP tool support.

Key features include:

  • Hosted MCP Tools: Connect to external services through hosted MCP endpoints
  • SQLite Sessions: Persist conversation history across interactions
  • Simple API: Clean interface with Agent, Runner, and tool configuration
  • Streaming Support: Real-time response streaming for interactive applications

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

The Miro MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Miro account. It provides structured and secure access to your whiteboards, so your agent can create new boards, manage board content, organize workflows, and collaborate visually—all on your behalf.

  • Automated board creation and setup: Instantly instruct your agent to create new Miro boards with specific names and descriptions for projects, brainstorming, or workshops.
  • Visual content management: Ask your agent to add, retrieve, or delete items such as shapes, sticky notes, app cards, or document items from any board, keeping your workspace tidy and up to date.
  • Efficient team and member management: Have your agent fetch and list all members of a board so you can easily track collaborators and manage access.
  • Seamless board organization and retrieval: Let your agent search and retrieve boards by team, owner, or keyword to keep your workspace organized and easy to navigate.
  • Connector and tag insights: Direct your agent to get details on connectors and tags used within boards, helping you map relationships and categorize content visually.

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 step09 STEPS
1

Prerequisites

Before starting, make sure you have:
  • Composio API Key and OpenAI API Key
  • Primary know-how of OpenAI Agents SDK
  • A live Miro project
  • Some knowledge of Python or Typescript
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
3

Install dependencies

npm install @composio/openai-agents @openai/agents dotenv

Install the Composio SDK and the OpenAI Agents SDK.

4

Set up environment variables

bash
OPENAI_API_KEY=sk-...your-api-key
COMPOSIO_API_KEY=your-api-key
USER_ID=composio_user@gmail.com

Create a .env file and add your OpenAI and Composio API keys.

5

Import dependencies

import 'dotenv/config';
import { Composio } from '@composio/core';
import { OpenAIAgentsProvider } from '@composio/openai-agents';
import { Agent, hostedMcpTool, run, OpenAIConversationsSession } from '@openai/agents';
import * as readline from 'readline';
What's happening:
  • You're importing all necessary libraries.
  • The Composio and OpenAIAgentsProvider classes are imported to connect your OpenAI agent to Composio tools like Miro.
6

Set up the Composio instance

dotenv.config();

const composioApiKey = process.env.COMPOSIO_API_KEY;
const userId = process.env.USER_ID;

if (!composioApiKey) {
  throw new Error('COMPOSIO_API_KEY is not set. Create a .env file with COMPOSIO_API_KEY=your_key');
}
if (!userId) {
  throw new Error('USER_ID is not set');
}

// Initialize Composio
const composio = new Composio({
  apiKey: composioApiKey,
  provider: new OpenAIAgentsProvider(),
});
What's happening:
  • dotenv.config() loads your .env file so COMPOSIO_API_KEY and USER_ID are available as environment variables.
  • Creating a Composio instance using the API Key and OpenAIAgentsProvider class.
7

Create a Tool Router session

// Create Tool Router session for Miro
const session = await composio.create(userId as string, {
  toolkits: ['miro'],
});
const mcpUrl = session.mcp.url;

What is happening:

  • You give the Tool Router the user id and the toolkits you want available. Here, it is only miro.
  • The router checks the user's Miro connection and prepares the MCP endpoint.
  • The returned session.mcp.url is the MCP URL that your agent will use to access Miro.
  • This approach keeps things lightweight and lets the agent request Miro tools only when needed during the conversation.
8

Configure the agent

// Configure agent with MCP tool
const agent = new Agent({
  name: 'Assistant',
  model: 'gpt-5',
  instructions:
    'You are a helpful assistant that can access Miro. Help users perform Miro operations through natural language.',
  tools: [
    hostedMcpTool({
      serverLabel: 'tool_router',
      serverUrl: mcpUrl,
      headers: { 'x-api-key': composioApiKey },
      requireApproval: 'never',
    }),
  ],
});
What's happening:
  • We're creating an Agent instance with a name, model (gpt-5), and clear instructions about its purpose.
  • The agent's instructions tell it that it can access Miro and help with queries, inserts, updates, authentication, and fetching database information.
  • The tools array includes a hostedMcpTool that connects to the MCP server URL we created earlier.
  • The headers object includes the Composio API key for secure authentication with the MCP server.
  • requireApproval: 'never' means the agent can execute Miro operations without asking for permission each time, making interactions smoother.
9

Start chat loop and handle conversation

// Keep conversation state across turns
const conversationSession = new OpenAIConversationsSession();

// Simple CLI
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: 'You: ',
});

console.log('\nComposio Tool Router session created.');
console.log('\nChat started. Type your requests below.');
console.log("Commands: 'exit', 'quit', or 'q' to end\n");

try {
  const first = await run(agent, 'What can you help me with?', { session: conversationSession });
  console.log(`Assistant: ${first.finalOutput}\n`);
} catch (e) {
  console.error('Error:', e instanceof Error ? e.message : e, '\n');
}

rl.prompt();

rl.on('line', async (userInput) => {
  const text = userInput.trim();

  if (['exit', 'quit', 'q'].includes(text.toLowerCase())) {
    console.log('Goodbye!');
    rl.close();
    process.exit(0);
  }

  if (!text) {
    rl.prompt();
    return;
  }

  try {
    const result = await run(agent, text, { session: conversationSession });
    console.log(`\nAssistant: ${result.finalOutput}\n`);
  } catch (e) {
    console.error('Error:', e instanceof Error ? e.message : e, '\n');
  }

  rl.prompt();
});

rl.on('close', () => {
  console.log('\n👋 Session ended.');
  process.exit(0);
});
What's happening:
  • The program prints a session URL that you visit to authorize Miro.
  • After authorization, the chat begins.
  • Each message you type is processed by the agent using run().
  • The responses are printed to the console.
  • Typing exit, quit, or q cleanly ends the chat.

Complete Code

Here's the complete code to get you started with Miro and OpenAI Agents SDK:

import 'dotenv/config';
import { Composio } from '@composio/core';
import { OpenAIAgentsProvider } from '@composio/openai-agents';
import { Agent, hostedMcpTool, run, OpenAIConversationsSession } from '@openai/agents';
import * as readline from 'readline';

const composioApiKey = process.env.COMPOSIO_API_KEY;
const userId = process.env.USER_ID;

if (!composioApiKey) {
  throw new Error('COMPOSIO_API_KEY is not set. Create a .env file with COMPOSIO_API_KEY=your_key');
}
if (!userId) {
  throw new Error('USER_ID is not set');
}

// Initialize Composio
const composio = new Composio({
  apiKey: composioApiKey,
  provider: new OpenAIAgentsProvider(),
});

async function main() {
  // Create Tool Router session
  const session = await composio.create(userId as string, {
    toolkits: ['miro'],
  });
  const mcpUrl = session.mcp.url;

  // Configure agent with MCP tool
  const agent = new Agent({
    name: 'Assistant',
    model: 'gpt-5',
    instructions:
      'You are a helpful assistant that can access Miro. Help users perform Miro operations through natural language.',
    tools: [
      hostedMcpTool({
        serverLabel: 'tool_router',
        serverUrl: mcpUrl,
        headers: { 'x-api-key': composioApiKey },
        requireApproval: 'never',
      }),
    ],
  });

  // Keep conversation state across turns
  const conversationSession = new OpenAIConversationsSession();

  // Simple CLI
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: 'You: ',
  });

  console.log('\nComposio Tool Router session created.');
  console.log('\nChat started. Type your requests below.');
  console.log("Commands: 'exit', 'quit', or 'q' to end\n");

  try {
    const first = await run(agent, 'What can you help me with?', { session: conversationSession });
    console.log(`Assistant: ${first.finalOutput}\n`);
  } catch (e) {
    console.error('Error:', e instanceof Error ? e.message : e, '\n');
  }

  rl.prompt();

  rl.on('line', async (userInput) => {
    const text = userInput.trim();

    if (['exit', 'quit', 'q'].includes(text.toLowerCase())) {
      console.log('Goodbye!');
      rl.close();
      process.exit(0);
    }

    if (!text) {
      rl.prompt();
      return;
    }

    try {
      const result = await run(agent, text, { session: conversationSession });
      console.log(`\nAssistant: ${result.finalOutput}\n`);
    } catch (e) {
      console.error('Error:', e instanceof Error ? e.message : e, '\n');
    }

    rl.prompt();
  });

  rl.on('close', () => {
    console.log('\nSession ended.');
    process.exit(0);
  });
}

main().catch((err) => {
  console.error('Fatal error:', err);
  process.exit(1);
});

Conclusion

This was a starter code for integrating Miro MCP with OpenAI Agents SDK to build a functional AI agent that can interact with Miro.

Key features:

  • Hosted MCP tool integration through Composio's Tool Router
  • SQLite session persistence for conversation history
  • Simple async chat loop for interactive testing
You can extend this by adding more toolkits, implementing custom business logic, or building a web interface around the agent.
TOOLS

Supported Tools

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

Attach Tag To Item

Tool to attach an existing tag to a specific item on a Miro board.

Copy Board

Create a copy of an existing Miro board, optionally changing its name, description, policies, or destination team.

Create App Card Item

Creates an app card on a Miro board, with optional custom preview fields.

Create Board

Tool to create a new board.

Create Card Item

Tool to create a card item on a Miro board.

Create Connector

Tool to create a connector (edge/arrow) that links two existing board items.

Create Doc Format Item

Create a structured Markdown doc on a Miro board.

Create Document Item

Tool to create a document item on a Miro board by providing a URL to the document.

Create Document Item Using File From Device

Create a document item on a Miro board by uploading a document file, with optional title, position, geometry, and parent frame.

Create Embed Item

Tool to create an embed item on a Miro board by providing a URL to embed content (YouTube videos, websites, etc.).

Create Frame Item

Tool to add a frame item to a Miro board.

Create Group

Tool to create a group on a Miro board by grouping multiple items together.

Create Image Item from URL

Creates an image item on a Miro board by providing a URL to a publicly accessible image.

Create Image Item Using Local File

Tool to create an image item on a Miro board by uploading a local image file.

Create Items in Bulk

Tool to create multiple items on a Miro board in a single request.

Create Mind Map Node (Experimental)

Tool to create a mind map node on a Miro board.

Create Shape Item

Tool to create a shape item on a Miro board.

Create Sticky Note Item

Tool to create a sticky note item on a Miro board.

Create Tag

Tool to create a new tag on a Miro board.

Create Text Item

Tool to create a text item on a Miro board.

Delete App Card Item

Tool to delete an app card item from a board.

Delete Board

Delete a Miro board.

Delete Card Item

Tool to delete a card item from a board.

Delete Connector

Tool to delete a specific connector from a board.

Delete Doc Format Item

Delete a structured Miro doc format item from a board.

Delete Document Item

Tool to delete a document item from a board.

Delete Embed Item

Tool to delete an embed item from a board.

Delete Frame Item

Tool to delete a frame item from a Miro board.

Delete Group

Tool to delete a group from a board.

Delete Image Item

Tool to delete an image item from a board.

Delete Item

Tool to delete a specific item from a board.

Delete Mind Map Node (Experimental)

Tool to delete a mind map node from a board.

Delete Shape Item

Tool to delete a shape item from a board.

Delete Sticky Note Item

Tool to delete a sticky note item from a board.

Delete Tag

Tool to delete a specific tag from a board.

Delete Text Item

Tool to delete a text item from a board.

Download Document Resource

Retrieve signed URL metadata for a Miro document resource.

Download Image Resource

Retrieve a Miro image resource as signed URL metadata or a downloaded file.

Get All Groups

Tool to retrieve all groups on a Miro board with cursor-based pagination.

Get App Card Item 2

Tool to retrieve a specific app card item by its ID from a Miro board.

Get Board Items

Tool to list items on a Miro board (shapes, stickies, cards, etc.) with pagination.

Get Board Members

Tool to retrieve a list of members for a board.

Get Boards V2

Tool to retrieve accessible boards with optional filters.

Get Card Item

Tool to retrieve a specific card item from a Miro board.

Get Connector

Tool to retrieve a specific connector by its ID.

Get Connectors

Tool to retrieve a list of connectors on a board.

Get Doc Format Item

Retrieve a structured Miro doc as Markdown or HTML.

Get Document Item

Tool to retrieve a specific document item from a Miro board by its ID.

Get Embed Item

Tool to retrieve a specific embed item from a board by its ID.

Get Frame Item

Tool to retrieve a specific frame item from a Miro board.

Get Group By ID

Tool to retrieve a specific group by its ID.

Get Image Item

Tool to retrieve a specific image item from a board.

Get Items by Group ID

Tool to retrieve items of a specific group by its ID on a Miro board.

Get Items Within Frame

Get items within a specific frame on a Miro board.

Get Item Tags

Tool to retrieve tags attached to a specific item on a Miro board.

Get Mind Map Node

Tool to retrieve a specific mind map node from a board.

Get Mind Map Nodes (Experimental)

Tool to retrieve mind map nodes from a Miro board.

Get oEmbed Data

Tool to retrieve oEmbed data for a Miro board.

Get Shape Item

Tool to retrieve a specific shape item from a Miro board by its ID.

Get Specific Board

Tool to retrieve detailed information about a specific board by its ID.

Get Specific Board Member

Tool to retrieve details of a specific board member.

Get Specific Item

Tool to retrieve a specific item from a Miro board by its ID.

Get Sticky Note Item

Tool to retrieve a specific sticky note item from a board by its ID.

Get Tag

Tool to retrieve details of a specific tag on a board.

Get Text Item

Tool to retrieve a specific text item from a Miro board by its ID.

List Board Tags

Tool to list all tags on a Miro board.

Get Organization Context

Retrieves the organization associated with the current access token.

Remove Board Member

Remove a member's direct board membership.

Remove Tag From Item

Requests removal of a tag from a specified item on a Miro board.

Share Board

Tool to share a board by inviting users via email.

Update App Card Item 2

Tool to update an app card item on a Miro board.

Update Board

Tool to update properties of a specific board.

Update Board Member

Updates a specific board member's role using the board and member IDs.

Update Card Item

Tool to update a card item on a Miro board.

Update Connector

Tool to update an existing connector on a Miro board.

Update Document Item

Tool to update a document item on a Miro board.

Update Embed Item

Tool to update an embed item on a board.

Update Frame Item

Tool to update a frame item on a Miro board.

Update Group

Tool to update a group on a Miro board with new items.

Update Image Item

Tool to update an existing image item on a board.

Update Item Position or Parent

Tool to update an item's position or parent frame on a Miro board.

Update Shape Item

Tool to update an existing shape item on a Miro board.

Update Sticky Note Item

Tool to update a sticky note item on a Miro board.

Update Tag

Tool to update a tag on a board.

Update Text Item

Tool to update a text item on a Miro board.

FAQ

Frequently asked questions

Start with Miro.It takes 30 seconds.

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

Start building