SIGN UPLOG IN
X (Twitter)LinkedInGitHubDiscordYouTube

How to integrate Monday MCP with Autogen

Connect Autogen to Monday MCP. Create a new project board for q3, add users to the design review board, and more using natural language, with authentication handled for you.

Get started for freeGet a demo
Monday logoMonday
Oauth2

Monday.com is a customizable work management platform for project planning and collaboration. It helps teams organize tasks, automate workflows, and track progress in real time.

122 Tools17 Triggers

Introduction

This guide walks you through connecting Monday to AutoGen using the Composio tool router. By the end, you'll have a working Monday agent that can create and update items, set board column values, organize boards and groups, post updates, and write docs through natural language commands.

This guide will help you understand how to give your AutoGen agent real control over a Monday account through Composio's Monday 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 Monday with

Claude CodeCursorChatGPTClaude CoworkAntigravityOpenAI Agents SDKClaude Agent SDKGrok BotMuseCodexGrok BuildVS CodeOpenCodeOpenClawHermesAtomic 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 Monday
  • Wire that MCP URL into Autogen using McpWorkbench and StreamableHttpServerParams
  • Configure an Autogen AssistantAgent that can call Monday tools
  • Run a live chat loop where you ask the agent to perform Monday 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 Monday MCP server, and what's possible with it?

The Monday MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Monday account. It provides structured and secure access to your boards, items, columns, users, sprints, and docs, so your agent can create projects, manage work items, update board details, track sprints, and organize teams on your behalf.

  • Board and project creation: Have your agent create boards, convert existing boards into projects, connect projects to portfolios, and update board settings.
  • Item and workflow management: Let the agent create items from your instructions, find work by column values, move items between groups, and update text, status, or dropdown fields.
  • Board structure and access: Direct your agent to create columns, add users to boards, and set default board roles and permissions.
  • Sprint and work tracking: Instruct your agent to review sprint data, retrieve board items, and check item details, status, and group placement.
  • Workspace content and organization: Have your agent retrieve Monday docs, list account users, update folder details, and confirm which Monday account is connected.

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 Monday 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 Monday 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 Monday 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 Monday session
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))
    session = composio.create(
        user_id=os.getenv("USER_ID"),
        toolkits=["monday"]
    )
    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 Monday 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 Monday assistant agent with MCP tools
    agent = AssistantAgent(
        name="monday_assistant",
        description="An AI assistant that helps with Monday 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 Monday 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 Monday 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 Monday 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 Monday 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 Monday session
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))
    session = composio.create(
        user_id=os.getenv("USER_ID"),
        toolkits=["monday"]
    )
    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 Monday assistant agent with MCP tools
        agent = AssistantAgent(
            name="monday_assistant",
            description="An AI assistant that helps with Monday 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 Monday 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 Monday 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 Monday, you can reuse the same structure for other MCP-enabled apps with minimal code changes.
TOOLS & TRIGGERS

Supported Tools and Triggers

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

Get account trigger statistics

Tool to retrieve statistics about account-level triggers and automations.

Activate users

Tool to activate or reactivate users in a Monday.

Add subscribers to object

Tool to add subscribers or owners to a monday.

Add teams to board

Tool to add teams to a Monday.

Add users to board

Adds users to a Monday.

Add users to team

Adds users to a Monday.

Add users to workspace

Adds existing users to a workspace.

Aggregate board data

Aggregate data from a Monday.

Get app subscription

Tool to retrieve current app subscription data for the account.

Archive board

Archives a specified, existing, and unarchived board in Monday.

Archive item

Archives an existing Monday.

Archive object

Archives a Monday.

Archive workspace

Delete a Monday.

Get audit logs

Tool to retrieve detailed security-related activity records for a Monday.

Get document blocks

Tool to retrieve document block data from workdocs via the API.

Get boards

Retrieves metadata for one or multiple monday.

Change simple column value

Changes a monday.

Get board columns

Retrieves column metadata from monday.

Get connection board IDs

Tool to retrieve board IDs associated with connection columns.

Get connections

Tool to retrieve connection data for integrations with external services.

Connect project to portfolio

Links an existing project board to a portfolio board for centralized management.

Convert board to project

Converts a regular Monday.

Create a Monday board

Creates a Monday.

Create column

Creates a new column with a specified type and title on a monday.

Create custom activity

Tool to create a custom activity in the Monday.

Create a Monday dashboard

Tool to create a Monday.

Create doc

Tool to create a new doc in Monday.

Create a folder

Tool to create a new folder in a Monday.

Create group

Creates a new group with the given `group_name` on an existing Monday.

Create item

Creates a new item on a Monday.

Create Item From Natural Language

Creates a new item on a Monday.

Create notification

Tool to send a notification to a user.

Create object

Execute a custom Monday.

Create tag

Tool to create a new tag or return an existing tag.

Create timeline item

Tool to create a new timeline item in the Emails & Activities app on a Monday.

Create update

Tool to create a new update for an item or reply to an existing update.

Invite and create a Monday user

Tool to invite and create a new user.

Create a Monday workspace

Tool to create a Monday.

Get custom activity

Tool to retrieve custom activity data from the Emails & Activities app.

Deactivate users

Deactivates up to 200 users per request from a monday.

Delete asset

Remove uploaded files by deleting an enclosing update or clearing all files from an item's File column; the required asset ID does not select which file is removed.

Delete board

Tool to permanently delete a board from your Monday.

Delete column

Deletes a specified column from a Monday.

Delete Custom Activity

Tool to delete a custom activity from the Emails & Activities app.

Delete doc

Deletes a Monday.

Delete folder

Tool to permanently delete a folder and all its contents from a Monday.

Delete group

Permanently deletes an existing group (and its items) from an existing board in Monday.

Delete item

Permanently deletes an existing Monday.

Delete object

Tool to permanently delete a Monday.

Delete subscribers from board

Tool to remove subscribers from a Monday.

Delete tag

Tool to remove a tag from an item in Monday.

Delete team

Delete an existing Monday.

Delete teams from board

Remove teams from a Monday.

Delete teams from workspace

Tool to remove teams from a workspace.

Delete timeline item

Tool to delete a timeline item from the Emails & Activities app.

Delete update

Tool to delete an update by its ID.

Delete workspace

Tool to permanently delete a workspace by its ID.

Retrieve Monday docs

Tool to retrieve Monday.

Duplicate board

Tool to duplicate a Monday.

Duplicate item

Duplicates an item on a Monday.

Edit update

Tool to modify the text content of an existing update on an item.

Get account info

Retrieve account metadata and settings for the authenticated Monday.

Get board activity logs

Tool to retrieve activity logs from a specific Monday.

Get API version

Tool to retrieve the Monday.

Get assets

Tool to retrieve file/asset metadata from monday.

Get board views

Tool to retrieve board view data via GraphQL API.

Get favorites

Tool to retrieve all favorited items for the authenticated user.

Get folders

Tool to retrieve folder data from workspaces with filtering and pagination options.

Get form details

Tool to retrieve form metadata via the API using the form's unique token from the URL.

Get items by IDs

Tool to retrieve specific items by their IDs from Monday.

Get current user

Tool to fetch the current authenticated user's profile and permissions.

Execute GraphQL and get mutation complexity

Execute a caller-provided Monday.

Get query complexity

Retrieve Monday.

Get tags

Tool to retrieve tags from the account.

Get teams

Tool to retrieve teams from Monday.

Get update replies

Retrieves updates and their replies for a specific Monday.

Get item updates

Tool to retrieve updates for a specific item.

Get API versions

Tool to retrieve data about available API versions.

Get view schema by type

Tool to retrieve type-specific board view configuration schemas via GraphQL API.

Get webhooks

Tool to retrieve webhooks for a board.

Get workspaces

Tool to retrieve workspaces.

Import doc from HTML

Tool to import HTML content into a new Monday.

Get items page

Retrieve a page of items from a Monday.

Like update

Tool to like an update on an item.

List groups

Retrieves groups from a specified Monday.

List items

Retrieve specified Monday.

List items by column values

Tool to search for items on a Monday.

List subitems by parent

Tool to retrieve subitems nested under parent items via GraphQL API.

List team members

List members of Monday.

List users

Retrieves a list of users from Monday.

Move item to board

Moves a Monday.

Move item to group

Moves an item to a different group on the same Monday.

Query board mute settings

Tool to query a board's notification mute settings.

Pin update to top

Tool to pin an update to the top of an item.

Publish object

Tool to publish a Monday.

Query dashboards

Query Monday.

Query sprints

Tool to query sprint data for agile project management from Monday.

Remove users from team

Removes users from a Monday.

Remove users from workspace

Tool to remove users from a workspace.

Set board permission

Sets or updates a board's default role and permissions.

Get item timeline

Tool to retrieve an item's Email & Activities (E&A) timeline data from Monday.

Get timeline item

Tool to retrieve a specific timeline item from the Emails & Activities app by ID.

Unlike update

Tool to remove a like from an update on an item.

Unpin update from top

Tool to unpin an update from the top of an item.

Unpublish object

Unpublish a Monday.

Update board

Updates a specified attribute of an existing board on Monday.

Update board hierarchy

Updates a board's position, workspace, or product in Monday.

Update column

Tool to update column title or description.

Update a doc

Updates a doc's title and/or adds Markdown content, optionally after a specified block.

Update email domain

Tool to update users' email domains.

Update a Monday folder

Tool to update a Monday.

Update group

Tool to update an existing group on a board.

Update item

Tool to update an existing item's column value on Monday.

Update multiple users

Tool to update one or multiple users' attributes on Monday.

Update mute board settings

Tool to update a board's notification mute settings.

Update tag

Tool to return a tag's details or best-effort "rename" by creating or getting a tag with the requested name.

Update team

Add users to a Monday.

Update users role

Updates users' roles to custom or default roles; this admin-only operation cannot update your own role.

Update a Monday workspace

Tool to update a Monday.

Upload Asset

Tool to upload a file to an update or file column.

Get user connections

Tool to query user-specific connection data from Monday.

Who Am I

Return the identity (name, email, account) of the connected monday.

FRAMEWORKS

How to build Monday MCP Agent with another framework

Claude Code logo

Claude Code

Use Monday MCP with Claude Code

Cursor logo

Cursor

Use Monday MCP with Cursor

ChatGPT logo

ChatGPT

Use Monday MCP with ChatGPT

Claude Cowork logo

Claude Cowork

Use Monday MCP with Claude Cowork

Antigravity logo

Antigravity

Use Monday MCP with Antigravity

OpenAI Agents SDK logo

OpenAI Agents SDK

Use Monday MCP with OpenAI Agents SDK

Claude Agent SDK logo

Claude Agent SDK

Use Monday MCP with Claude Agent SDK

Grok Bot logo

Grok Bot

Use Monday MCP with Grok Bot

Muse logo

Muse

Use Monday MCP with Muse

Codex logo

Codex

Use Monday MCP with Codex

Grok Build logo

Grok Build

Use Monday MCP with Grok Build

VS Code logo

VS Code

Use Monday MCP with VS Code

OpenCode logo

OpenCode

Use Monday MCP with OpenCode

OpenClaw logo

OpenClaw

Use Monday MCP with OpenClaw

Hermes logo

Hermes

Use Monday MCP with Hermes

Atomic Agent logo

Atomic Agent

Use Monday MCP with Atomic Agent

Google ADK logo

Google ADK

Use Monday MCP with Google ADK

LangChain logo

LangChain

Use Monday MCP with LangChain

Vercel AI SDK logo

Vercel AI SDK

Use Monday MCP with Vercel AI SDK

Mastra AI logo

Mastra AI

Use Monday MCP with Mastra AI

LlamaIndex logo

LlamaIndex

Use Monday MCP with LlamaIndex

CrewAI logo

CrewAI

Use Monday MCP with CrewAI

Pydantic AI logo

Pydantic AI

Use Monday MCP with Pydantic AI

FAQ

Frequently asked questions

Start with Monday.It takes 30 seconds.

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

Start building