SIGN UPLOG IN
X (Twitter)LinkedInGitHubDiscordYouTube

How to integrate Monday MCP with LlamaIndex

Connect LlamaIndex 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 LlamaIndex 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 LlamaIndex 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.

Also integrate Monday with

Claude CodeCursorChatGPTClaude CoworkAntigravityOpenAI Agents SDKClaude Agent SDKGrok BotMuseCodexGrok BuildVS CodeOpenCodeOpenClawHermesAtomic AgentGoogle ADKLangChainVercel AI SDKMastra AICrewAIPydantic AIAutoGen

TL;DR

Here's what you'll learn:
  • Set your OpenAI and Composio API keys
  • Install LlamaIndex and Composio packages
  • Create a Composio Tool Router session for Monday
  • Connect LlamaIndex to the Monday MCP server
  • Build a Monday-powered agent using LlamaIndex
  • Interact with Monday through natural language

What is LlamaIndex?

LlamaIndex is a data framework for building LLM applications. It provides tools for connecting LLMs to external data sources and services through agents and tools.

Key features include:

  • ReAct Agent: Reasoning and acting pattern for tool-using agents
  • MCP Tools: Native support for Model Context Protocol
  • Context Management: Maintain conversation context across interactions
  • Async Support: Built for async/await patterns

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

Prerequisites

Before you begin, make sure you have:
  • Python 3.8/Node 16 or higher installed
  • A Composio account with the API key
  • An OpenAI API key
  • A Monday account and project
  • Basic familiarity with async Python/Typescript
2

Getting API Keys for OpenAI, Composio, and Monday

OpenAI API key (OPENAI_API_KEY)
  • Go to the OpenAI dashboard
  • Create an API key if you don't have one
  • Assign it to OPENAI_API_KEY in .env
Composio API key and user ID
  • Log into the Composio dashboard
  • Copy your API key from Settings
    • Use this as COMPOSIO_API_KEY
  • Pick a stable user identifier (email or ID)
    • Use this as COMPOSIO_USER_ID
3

Installing dependencies

npm install @composio/llamaindex @llamaindex/openai @llamaindex/tools @llamaindex/workflow dotenv

Create a new Typescript project and install the necessary dependencies:

  • @composio/llamaindex: Composio's LlamaIndex integration
  • @llamaindex/openai: OpenAI LLM integration
  • @llamaindex/tools: MCP client for LlamaIndex
  • @llamaindex/workflow: Workflow framework for LlamaIndex
  • dotenv: Environment variable management
4

Set environment variables

bash
OPENAI_API_KEY=your-openai-api-key
COMPOSIO_API_KEY=your-composio-api-key
COMPOSIO_USER_ID=your-user-id

Create a .env file in your project root:

These credentials will be used to:

  • Authenticate with OpenAI's GPT-5 model
  • Connect to Composio's Tool Router
  • Identify your Composio user session for Monday access
5

Import modules

import "dotenv/config";
import readline from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";

import { Composio } from "@composio/core";

import { mcp } from "@llamaindex/tools";
import { agent as createAgent } from "@llamaindex/workflow";
import { openai } from "@llamaindex/openai";

dotenv.config();

Create a new file called monday_llamaindex_agent.ts and import the required modules:

Key imports:

  • dotenv.config loads .env at runtime
  • readline gives us a simple CLI chat loop
  • Composio is the main Composio SDK client
  • mcp connects to an MCP endpoint
  • createAgent builds a LlamaIndex agent
  • openai configures the LLM backend
6

Load environment variables and initialize Composio

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const COMPOSIO_API_KEY = process.env.COMPOSIO_API_KEY;
const COMPOSIO_USER_ID = process.env.COMPOSIO_USER_ID;

if (!OPENAI_API_KEY) throw new Error("OPENAI_API_KEY is not set");
if (!COMPOSIO_API_KEY) throw new Error("COMPOSIO_API_KEY is not set");
if (!COMPOSIO_USER_ID) throw new Error("COMPOSIO_USER_ID is not set");

What's happening:

This ensures missing credentials cause early, clear errors before the agent attempts to initialise.

7

Create a Tool Router session and build the agent function

async function buildAgent() {

  console.log(`Initializing Composio client...${COMPOSIO_USER_ID!}...`);
  console.log(`COMPOSIO_USER_ID: ${COMPOSIO_USER_ID!}...`);

  const composio = new Composio({
    apiKey: COMPOSIO_API_KEY,
    provider: new LlamaindexProvider(),
  });

  const session = await composio.create(
    COMPOSIO_USER_ID!,
    {
      toolkits: ["monday"],
    },
  );

  const mcpUrl = session.mcp.url;
  console.log(`Composio Tool Router MCP URL: ${mcpUrl}`);

  const server = mcp({
    url: mcpUrl,
    clientName: "composio_tool_router_with_llamaindex",
    requestInit: {
      headers: {
        "x-api-key": COMPOSIO_API_KEY!,
      },
    },
    // verbose: true,
  });

  const tools = await server.tools();

  const llm = openai({ apiKey: OPENAI_API_KEY, model: "gpt-5" });

  const agent = createAgent({
    name: "composio_tool_router_with_llamaindex",
        description : "An agent that uses Composio Tool Router MCP tools to perform actions.",
    systemPrompt:
      "You are a helpful assistant connected to Composio Tool Router."+
"Use the available tools to answer user queries and perform Monday actions." ,
    llm,
    tools,
  });

  return agent;
}

What's happening here:

  • We create a Composio client using your API key and configure it with the LlamaIndex provider
  • We then create a tool router MCP session for your user, specifying the toolkits we want to use (in this case, monday)
  • The session returns an MCP HTTP endpoint URL that acts as a gateway to all your configured tools
  • LlamaIndex will connect to this endpoint to dynamically discover and use the available Monday tools.
  • The MCP tools are mapped to LlamaIndex-compatible tools and plug them into the Agent.
8

Create an interactive chat loop

async function chatLoop(agent: ReturnType<typeof createAgent>) {
  const rl = readline.createInterface({ input, output });

  console.log("Type 'quit' or 'exit' to stop.");

  while (true) {
    let userInput: string;

    try {
      userInput = (await rl.question("\nYou: ")).trim();
    } catch {
      console.log("\nAgent: Bye!");
      break;
    }

    if (!userInput) {
      continue;
    }

    const lower = userInput.toLowerCase();
    if (lower === "quit" || lower === "exit") {
      console.log("Agent: Bye!");
      break;
    }

    try {
      process.stdout.write("Agent: ");

      const stream = agent.runStream(userInput);
      let finalResult: any = null;

      for await (const event of stream) {
        // The event.data contains the streamed content
        const data: any = event.data;

        // Check for streaming delta content
        if (data?.delta) {
          process.stdout.write(data.delta);
        }

        // Store final result for fallback
        if (data?.result || data?.message) {
          finalResult = data;
        }
      }

      // If no streaming happened, show the final result
      if (finalResult) {
        const answer =
          finalResult.result ??
          finalResult.message?.content ??
          finalResult.message ??
          "";
        if (answer && typeof answer === "string" && !answer.includes("[object")) {
          process.stdout.write(answer);
        }
      }

      console.log(); // New line after streaming completes
    } catch (err: any) {
      console.error("\nAgent error:", err?.message ?? err);
    }
  }

  rl.close();
}

What's happening:

  • We're creating a direct terminal interface to chat with Monday
  • The LLM's responses are streamed to the CLI for faster interaction.
  • The agent uses context to maintain conversation history
  • The agent processes the request, selects appropriate Monday tools, and returns a result
  • We extract the answer from the result data structure and display it to the user
  • You can type 'quit' or 'exit' to stop the chat loop gracefully
  • Agent responses and any errors are streamed in a clear, readable format
9

Define the main entry point

async function main() {
  try {
    const agent = await buildAgent();
    await chatLoop(agent);
  } catch (err) {
    console.error("Failed to start agent:", err);
    process.exit(1);
  }
}

main();

What's happening here:

  • We're orchestrating the entire application flow
  • The agent gets built with proper error handling
  • Then we kick off the interactive chat loop so you can start talking to Monday
10

Run the agent

npx ts-node llamaindex-agent.ts

When prompted, authenticate and authorise your agent with Monday, then start asking questions.

Complete Code

Here's the complete code to get you started with Monday and LlamaIndex:

import "dotenv/config";
import readline from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";

import { Composio } from "@composio/core";
import { LlamaindexProvider } from "@composio/llamaindex";

import { mcp } from "@llamaindex/tools";
import { agent as createAgent } from "@llamaindex/workflow";
import { openai } from "@llamaindex/openai";

dotenv.config();

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const COMPOSIO_API_KEY = process.env.COMPOSIO_API_KEY;
const COMPOSIO_USER_ID = process.env.COMPOSIO_USER_ID;

if (!OPENAI_API_KEY) {
    throw new Error("OPENAI_API_KEY is not set in the environment");
  }
if (!COMPOSIO_API_KEY) {
    throw new Error("COMPOSIO_API_KEY is not set in the environment");
  }
if (!COMPOSIO_USER_ID) {
    throw new Error("COMPOSIO_USER_ID is not set in the environment");
  }

async function buildAgent() {

  console.log(`Initializing Composio client...${COMPOSIO_USER_ID!}...`);
  console.log(`COMPOSIO_USER_ID: ${COMPOSIO_USER_ID!}...`);

  const composio = new Composio({
    apiKey: COMPOSIO_API_KEY,
    provider: new LlamaindexProvider(),
  });

  const session = await composio.create(
    COMPOSIO_USER_ID!,
    {
      toolkits: ["monday"],
    },
  );

  const mcpUrl = session.mcp.url;
  console.log(`Composio Tool Router MCP URL: ${mcpUrl}`);

  const server = mcp({
    url: mcpUrl,
    clientName: "composio_tool_router_with_llamaindex",
    requestInit: {
      headers: {
        "x-api-key": COMPOSIO_API_KEY!,
      },
    },
    // verbose: true,
  });

  const tools = await server.tools();

  const llm = openai({ apiKey: OPENAI_API_KEY, model: "gpt-5" });

  const agent = createAgent({
    name: "composio_tool_router_with_llamaindex",
    description:
      "An agent that uses Composio Tool Router MCP tools to perform actions.",
    systemPrompt:
      "You are a helpful assistant connected to Composio Tool Router."+
"Use the available tools to answer user queries and perform Monday actions." ,
    llm,
    tools,
  });

  return agent;
}

async function chatLoop(agent: ReturnType<typeof createAgent>) {
  const rl = readline.createInterface({ input, output });

  console.log("Type 'quit' or 'exit' to stop.");

  while (true) {
    let userInput: string;

    try {
      userInput = (await rl.question("\nYou: ")).trim();
    } catch {
      console.log("\nAgent: Bye!");
      break;
    }

    if (!userInput) {
      continue;
    }

    const lower = userInput.toLowerCase();
    if (lower === "quit" || lower === "exit") {
      console.log("Agent: Bye!");
      break;
    }

    try {
      process.stdout.write("Agent: ");

      const stream = agent.runStream(userInput);
      let finalResult: any = null;

      for await (const event of stream) {
        // The event.data contains the streamed content
        const data: any = event.data;

        // Check for streaming delta content
        if (data?.delta) {
          process.stdout.write(data.delta);
        }

        // Store final result for fallback
        if (data?.result || data?.message) {
          finalResult = data;
        }
      }

      // If no streaming happened, show the final result
      if (finalResult) {
        const answer =
          finalResult.result ??
          finalResult.message?.content ??
          finalResult.message ??
          "";
        if (answer && typeof answer === "string" && !answer.includes("[object")) {
          process.stdout.write(answer);
        }
      }

      console.log(); // New line after streaming completes
    } catch (err: any) {
      console.error("\nAgent error:", err?.message ?? err);
    }
  }

  rl.close();
}

async function main() {
  try {
    const agent = await buildAgent();
    await chatLoop(agent);
  } catch (err: any) {
    console.error("Failed to start agent:", err?.message ?? err);
    process.exit(1);
  }
}

main();

Conclusion

You've successfully connected Monday to LlamaIndex through Composio's Tool Router MCP layer. Key takeaways:
  • Tool Router dynamically exposes Monday tools through an MCP endpoint
  • LlamaIndex's ReActAgent handles reasoning and orchestration; Composio handles integrations
  • The agent becomes more capable without increasing prompt size
  • Async Python provides clean, efficient execution of agent workflows
You can easily extend this to other toolkits like Gmail, Notion, Stripe, GitHub, and more by adding them to the toolkits parameter.
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

CrewAI logo

CrewAI

Use Monday MCP with CrewAI

Pydantic AI logo

Pydantic AI

Use Monday MCP with Pydantic AI

AutoGen logo

AutoGen

Use Monday MCP with AutoGen

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