Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.iru.com/llms.txt

Use this file to discover all available pages before exploring further.

Introduction

The Model Context Protocol (MCP) is an open standard for connecting client applications (hosts) to MCP servers. Servers expose tools, resources, and prompts so AI assistants can take allowed actions in your environment through one consistent pattern—instead of building and maintaining a separate custom integration for every assistant or workflow you add. The Iru Model Context Protocol (MCP) server exposes the Iru Enterprise API surface, structured as MCP tools for AI assistants. Connect Cursor, Claude Desktop, OpenAI Codex, or other MCP-enabled clients to query devices, Blueprints, Library Items, and take allowed actions in natural language, without building your own Iru API integration. You can also combine Iru’s tools with tools from other vendors (for example ticketing, chat, or IAM) to create end-to-end workflows orchestrated in natural language. When Iru adds additional Enterprise API capabilities, those capabilities become available through MCP on the same permission model.
The Enterprise API (and MCP backed by it) applies across Iru areas that surface that API, including Endpoint and other products such as Vulnerability Management and Endpoint Detection and Response, depending on your tenant and entitlements.
For REST usage (HTTP APIs and bearer tokens outside MCP), see the Iru API Overview.

Before you begin

  • You need an Iru admin account with permission to create and manage API tokens in Access, as described in the Iru API Overview.
  • You need a supported MCP client (such as Claude Desktop, Cursor, or Codex).

Create an API token with MCP

Use Generate an API Token in the Iru API Overview for the full UI walkthrough (screenshots, Copy Token, Next, Configure / Skip, permission grids). The steps here match that article; you must turn on Enable MCP before Create so Iru issues MCP configuration for this token.
1

Open Access

Click your name at the bottom of the left navigation, then select Access.
2

Open the API tokens tab

In Access, click the API tokens tab.
3

Create new API token

Click Add Token to create a new API token.
4

Configure token details

Provide a Name and a Description for your API token.
5

Enable MCP

Turn on Enable MCP before you click Create. For MCP, this step is required; if Enable MCP is off, you get an Enterprise API token without MCP access or MCP configuration.
6

Create the token

Click Create.
API rate limits: The Iru Endpoint Management API enforces 10,000 requests per hour per customer. MCP calls use your API token and count toward the same tenant hourly limit as direct REST usage and other integrations. All API tokens in your tenant share that limit. For background and troubleshooting, see Considerations in the Iru API Overview and the Iru Endpoint Management API documentation.

Copy your token and MCP configuration

After you create the token, Iru shows a one-time success screen. The headline is Your token has been successfully created! The body tells you to copy your token and MCP configuration now, store them safely, and that you will not be able to see these details again.
1

Copy the API token (optional for non-MCP API use)

Copy the API token using Copy next to the token value if needed for scenarios outside of MCP usage.
2

Copy MCP configuration

In MCP configuration, review the JSON, then copy it using Copy MCP configuration. It includes your MCP URL and how to authenticate. Iru uses env names such as IRU_TOKEN, or IRU_MCP_API_KEY / IRU_MCP_PROFILE_ID. Those map to HTTP headers (X-API-Key, X-MCP-Profile) when a client connects. The Claude Desktop helper scripts below expect you to set IRU_MCP_SERVER, IRU_MCP_API_KEY, and IRU_MCP_PROFILE_ID from the values in your copied snippet (or the equivalent from a different env shape). Use the host, path, and secrets Iru provides.One illustration of the URL-plus-env shape is below (placeholders only; copy the live JSON from Iru).
mcp.json
{
  "mcpServers": {
    "iru": {
      "url": "https://YOUR_TENANT.connect.iru.dev/mcp-server/connector/YOUR_CONNECTOR_SLUG/tools",
      "env": {
        "IRU_MCP_API_KEY": "YOUR_API_KEY",
        "IRU_MCP_PROFILE_ID": "YOUR_PROFILE_ID"
      }
    }
  }
}
3

Select the confirmation checkbox

Select the confirmation checkbox: I have copied the token and MCP configuration and understand that I will not be able to see these details again.
4

Click Next

Click Next.
If you lose the token or configuration, revoke the token and create a new one.

Configure API permissions

After you click Next, you’ll see a Manage API Permissions screen. These permissions control which Enterprise API endpoints the MCP can access.
1

Configure now or skip

Choose one of the following:
  • Configure to set permissions now (recommended).
  • Skip to set permissions later.
2

Select endpoints (if you chose Configure)

If you clicked Configure, use the permissions list to select what this token can do:
  • Expand a category (for example Blueprints) to see individual endpoints.
  • Check the boxes for the endpoints you want to allow.
3

Save

When you’re done, click Save.
4

Verify

Verify the token shows MCP enabled: Yes (if you enabled MCP during creation) and that the permissions you selected are enabled.
5

Configure permissions later (if you skipped)

If you skipped permission setup, you can configure later by opening the token, clicking Edit, then selecting the permissions and clicking Save.

Revoke an API token

Revoke the token in Access like any other API token. Use Revoke a Token in Iru API Overview for the steps and Activity notes.

Considerations

The full token string and MCP configuration block are only available on the success screen at creation time.
Revoking the token stops API and MCP access that relied on it.
For destructive operations (for example erase, delete, lock), your assistant should summarize the impact and require your explicit approval before executing, unless you’ve added that action to an allowlist for the MCP. Follow your organization’s change-management rules.
Host applications parse MCP configuration differently. Always follow the snippet from Iru first; if a client requires HTTP headers instead of env, adapt using that vendor’s documentation.

Best practices

Use least privilege

Create a token with only the Enterprise API scopes your automation needs, then enable MCP on that token.

Separate tokens by team or use case

For example, use a read-focused token for reporting assistants and a narrower operational token for remediation workflows.

Rotate on suspicion

If a token may have leaked, revoke it in Iru and issue a new one; update every MCP client configuration that referenced the old secret.

Prefer environment variables

Keep IRU_TOKEN (or the variable names from your copied snippet) out of source control; load from OS or IDE secrets where supported.

Protect MCP and API secrets

Treat API tokens and the token in the MCP configuration like secrets. Store them in a password manager or secure vault, not in chat logs or screenshots.

Troubleshooting

Confirm you copied the token and MCP snippet from the one-time screen without extra spaces. Verify the MCP URL and environment variable names match the snippet from Iru. If the token was rotated or revoked, create a new token and update each client configuration.
The Enterprise API scopes on the token may exclude those operations. Edit the token’s API permissions in Iru (where supported) or create a new token with the required scopes.
Fully quit and restart the client application. Many hosts only load MCP configuration at startup.
Custom connectors reach your MCP server from Anthropic’s infrastructure. Confirm the URL is correct, the service is on the public internet, and any corporate firewall allows Anthropic’s IP ranges. See Get started with custom connectors using remote MCP and Anthropic IP addresses.

Add the Iru MCP to Claude Desktop

Claude Desktop often expects stdio configuration while Iru may give you an HTTP URL and headers (similar to Cursor). The setup scripts below merge an iru entry into Claude’s claude_desktop_config.json using npx and mcp-remote as a bridge.
1

Install Node.js

Install Node.js 20+ from https://nodejs.org so npx works.
2

Install jq

Install jq (for example Terminal: brew install jq if you use Homebrew).
3

Open Terminal

Open Terminal.
4

Set environment variables

Set your values from the Iru MCP configuration (replace the pasted placeholders):
Terminal
export IRU_MCP_SERVER="PASTE_MCP_URL_FROM_IRU"
export IRU_MCP_API_KEY="PASTE_API_KEY_FROM_IRU"
export IRU_MCP_PROFILE_ID="PASTE_PROFILE_FROM_IRU"
5

Run the script

Run the script (change the path to where iru-mcp-claude-desktop-macos.sh is saved):
Terminal
bash ~/Downloads/iru-mcp-claude-desktop-macos.sh
6

Restart Claude Desktop

Quit Claude Desktop completely (Claude → Quit Claude), reopen it, and start a new chat.
The following script is provided as a reference. Save it as iru-mcp-claude-desktop-macos.sh, make it executable if needed (chmod +x), then run it after exporting the variables above.
iru-mcp-claude-desktop-macos.sh
#!/usr/bin/env bash

################################################################################################
# Version
################################################################################################
# 1.0.0
################################################################################################
# Copyright (c) 2026 Iru, Inc. — MIT License (see License Information below).
################################################################################################
# Documentation
################################################################################################
# Claude Desktop — add Iru MCP via mcp-remote (macOS).
# Public Iru docs (prerequisites, env vars, and setup context):
# https://docs.iru.com/en/endpoint/api/model-context-protocol/iru-mcp
################################################################################################
# License Information
################################################################################################
#
# Copyright 2026 Iru, Inc.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of this
# software and associated documentation files (the "Software"), to deal in the Software
# without restriction, including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
# to whom the Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all copies or
# substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
# FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
#
################################################################################################

set -euo pipefail

# ── Configuration ────────────────────────────────────────────────────
# Export these BEFORE running; do not put secrets directly in this file.
#
# Match the MCP URL and secrets from Iru’s copied snippet (same URL as in Cursor ~/.cursor/mcp.json → mcpServers.iru).
#
# Example exports (tenant hostname and connector slug come from your tenant; copy from **Copy MCP configuration**):
#   export IRU_MCP_SERVER="https://YOUR_TENANT.connect.iru.dev/mcp-server/connector/YOUR_CONNECTOR_SLUG/tools"
#   export IRU_MCP_API_KEY="YOUR_API_KEY"
#   export IRU_MCP_PROFILE_ID="YOUR_PROFILE_ID"
#
# Cursor uses HTTP MCP (URL + headers). Claude Desktop uses this stdio bridge via npx + mcp-remote.
# Override the bridge package if needed:
IRU_MCP_REMOTE_PKG="${IRU_MCP_REMOTE_PKG:-mcp-remote@0.1.13}"

IRU_MCP_API_KEY="${IRU_MCP_API_KEY:?Set IRU_MCP_API_KEY before running this script}"
IRU_MCP_PROFILE_ID="${IRU_MCP_PROFILE_ID:?Set IRU_MCP_PROFILE_ID before running this script}"
IRU_MCP_SERVER="${IRU_MCP_SERVER:?Set IRU_MCP_SERVER before running this script}"

# ── Detect config path by OS ────────────────────────────────────────
case "$(uname -s)" in
  Darwin)  CONFIG_DIR="$HOME/Library/Application Support/Claude" ;;
  Linux)   CONFIG_DIR="$HOME/.config/Claude" ;;
  MINGW*|MSYS*|CYGWIN*)
           CONFIG_DIR="$APPDATA/Claude" ;;
  *)       echo "Unsupported OS: $(uname -s)" >&2; exit 1 ;;
esac

CONFIG_FILE="$CONFIG_DIR/claude_desktop_config.json"

# ── Ensure dependencies ─────────────────────────────────────────────
if ! command -v npx &>/dev/null; then
  echo "Error: npx not found. Install Node.js (v20+) first." >&2
  exit 1
fi

if ! command -v jq &>/dev/null; then
  echo "Error: jq not found. Install it (brew install jq / apt install jq)." >&2
  exit 1
fi

# ── Build the server entry (stdio → mcp-remote → same URL/headers as Cursor) ───
SERVER_ENTRY=$(jq -n \
  --arg pkg "$IRU_MCP_REMOTE_PKG" \
  --arg url "$IRU_MCP_SERVER" \
  --arg key "$IRU_MCP_API_KEY" \
  --arg profile "$IRU_MCP_PROFILE_ID" \
  '{
    command: "npx",
    args: [
      "-y",
      $pkg,
      $url,
      "--header",
      ("X-API-Key: " + $key),
      "--header",
      ("X-MCP-Profile: " + $profile)
    ]
  }')

# ── Merge into existing config (or create new) ─────────────────────
mkdir -p "$CONFIG_DIR"

if [[ -f "$CONFIG_FILE" ]]; then
  cp "$CONFIG_FILE" "$CONFIG_FILE.bak"
  echo "Backed up existing config to $(basename "$CONFIG_FILE").bak"

  UPDATED=$(jq --argjson entry "$SERVER_ENTRY" \
    '.mcpServers.iru = $entry' "$CONFIG_FILE")
else
  UPDATED=$(jq -n --argjson entry "$SERVER_ENTRY" \
    '{ mcpServers: { iru: $entry } }')
fi

echo "$UPDATED" > "$CONFIG_FILE"

# ── Done ────────────────────────────────────────────────────────────
echo ""
echo "✓ IRU MCP server added to Claude Desktop config."
echo "  Config: $CONFIG_FILE"
echo "  Bridge package: ${IRU_MCP_REMOTE_PKG}"
echo ""
echo "Next steps:"
echo "  1. Fully quit Claude Desktop (Cmd+Q / right-click tray → Quit)"
echo "  2. Reopen it"
echo "  3. Look for the hammer/tools icon at the bottom of a new chat"
echo ""
echo "Sanity check:"
echo "  IRU MCP URL matches your working Cursor ~/.cursor/mcp.json (mcpServers.iru URL; host .iru.dev,"
echo "  connector path must match your tenant’s snippet. Avoid typos such as wrong subdomain or connector slug)."
echo ""
echo "(Credentials not echoed; verify in $CONFIG_FILE if needed)"
1

Install Node.js

Install Node.js 20+ from https://nodejs.org so npx works.
2

Open PowerShell

Open PowerShell. You don’t need to run as administrator for these steps unless your environment requires it for another reason.
3

Allow scripts for this session

In that same window, run this so local scripts can execute only in this PowerShell session. It does not change machine-wide or user-wide policy; when you close the window, your normal execution policy applies again.
Terminal
Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope Process -Force
4

Go to the script folder

Go to the folder where iru-mcp-claude-desktop-windows.ps1 is:
Terminal
cd "FULL\PATH\TO\FOLDER_WITH_THE_SCRIPT"
5

Run the script

Run the script:
Terminal
$env:IRU_MCP_SERVER = "PASTE_MCP_URL_FROM_IRU"
$env:IRU_MCP_API_KEY = "PASTE_API_KEY_FROM_IRU"
$env:IRU_MCP_PROFILE_ID = "PASTE_PROFILE_FROM_IRU"
.\iru-mcp-claude-desktop-windows.ps1
6

Restart Claude Desktop

Quit Claude Desktop from the tray (Quit), reopen it, and start a new chat.
The following script is provided as a reference. Save it as iru-mcp-claude-desktop-windows.ps1 in the folder you cd into, then run it after setting the environment variables.
iru-mcp-claude-desktop-windows.ps1
#Requires -Version 5.1

<#
.SYNOPSIS
    Add Iru’s hosted MCP URL to Claude Desktop on Windows via mcp-remote (stdio bridge).

.DESCRIPTION
    Merges an iru MCP server entry into Claude Desktop's claude_desktop_config.json using npx
    and mcp-remote as a stdio-to-HTTP bridge (same MCP URL and headers as Iru's MCP snippet for
    Cursor-style HTTP MCP).

.NOTES
    Version            : 1.0.0
    Copyright          : (c) 2026 Iru, Inc.
    License            : MIT License — full text in the License Information block in this script file.

    Compatible with    : Windows PowerShell 5.1 and PowerShell 7+
    Prerequisites      : Node.js 20+ (npx on PATH); Claude Desktop for Windows

    Config path        : %APPDATA%\Claude\claude_desktop_config.json

    For prerequisites, env vars, and full setup context, see Related Links (Get-Help -Full).

.PARAMETER Interactive
    Prompts for MCP URL, X-API-Key value, and X-MCP-Profile ID instead of using process env vars only.

.EXAMPLE
    $env:IRU_MCP_SERVER='https://YOUR_TENANT.connect.iru.dev/mcp-server/connector/YOUR_CONNECTOR_SLUG/tools'
    $env:IRU_MCP_API_KEY='YOUR_API_KEY'
    $env:IRU_MCP_PROFILE_ID='YOUR_PROFILE_ID'
    .\iru-mcp-claude-desktop-windows.ps1

.LINK
    https://docs.iru.com/en/endpoint/api/model-context-protocol/iru-mcp
#>

################################################################################################
# License Information
################################################################################################
#
# Copyright 2026 Iru, Inc.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of this
# software and associated documentation files (the "Software"), to deal in the Software
# without restriction, including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
# to whom the Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all copies or
# substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
# FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
#
################################################################################################

[CmdletBinding()]
param (
    [switch] $Interactive
)

Set-StrictMode -Version Latest
$ErrorActionPreference = 'Stop'

function Resolve-IruSecrets {
    if ($Interactive) {
        [string]$s = Read-Host 'IRU MCP server URL (HTTPS, from Iru MCP snippet)'
        if ([string]::IsNullOrWhiteSpace($s)) { throw 'IRU_MCP_SERVER URL is required.' }
        $env:IRU_MCP_SERVER = $s.Trim()

        [string]$k = Read-Host 'X-API-Key value (paste the exact value from your Iru MCP configuration snippet)'
        if ([string]::IsNullOrWhiteSpace($k)) { throw 'IRU_MCP_API_KEY is required.' }
        $env:IRU_MCP_API_KEY = $k.Trim()

        [string]$p = Read-Host 'X-MCP-Profile ID'
        if ([string]::IsNullOrWhiteSpace($p)) { throw 'IRU_MCP_PROFILE_ID is required.' }
        $env:IRU_MCP_PROFILE_ID = $p.Trim()
    }

    foreach ($pair in @(
            @{ Var = 'IRU_MCP_API_KEY';     Msg = 'Set IRU_MCP_API_KEY (or pass -Interactive)' },
            @{ Var = 'IRU_MCP_PROFILE_ID'; Msg = 'Set IRU_MCP_PROFILE_ID (or pass -Interactive)' },
            @{ Var = 'IRU_MCP_SERVER';     Msg = 'Set IRU_MCP_SERVER (or pass -Interactive)' }
        )) {
        $v = [Environment]::GetEnvironmentVariable($pair.Var, 'Process')
        if (-not [string]::IsNullOrWhiteSpace($v)) { continue }

        throw $pair.Msg
    }
}

Resolve-IruSecrets

$iruServer = ($env:IRU_MCP_SERVER).Trim().TrimEnd('/')
$iruKey = $env:IRU_MCP_API_KEY
$iruProfile = $env:IRU_MCP_PROFILE_ID

$remotePkg = if (-not [string]::IsNullOrWhiteSpace($env:IRU_MCP_REMOTE_PKG)) {
    $env:IRU_MCP_REMOTE_PKG.Trim()
} else {
    'mcp-remote@0.1.13'
}

if (-not (Get-Command npx -ErrorAction SilentlyContinue)) {
    throw 'npx not found. Install Node.js 20+ and ensure npm is on PATH, then rerun.'
}

$configDir = Join-Path $env:APPDATA 'Claude'
$configPath = Join-Path $configDir 'claude_desktop_config.json'
$bakPath = "$configPath.bak"

$newIruArgs = New-Object System.Collections.ArrayList
[void]$newIruArgs.AddRange(@(
        '-y',
        $remotePkg,
        $iruServer,
        '--header',
        "X-API-Key: $iruKey",
        '--header',
        "X-MCP-Profile: $iruProfile"
    ))

$newIruEntry = New-Object PSCustomObject -Property @{
    command = 'npx'
    args    = $newIruArgs.ToArray()
}

[System.IO.Directory]::CreateDirectory($configDir) | Out-Null

if (Test-Path -LiteralPath $configPath) {
    Copy-Item -LiteralPath $configPath -Destination $bakPath -Force
    Write-Host "Backed up existing config to $(Split-Path $bakPath -Leaf)" -ForegroundColor DarkGray

    try {
        $raw = Get-Content -LiteralPath $configPath -Raw -Encoding UTF8
        $cfg = $raw | ConvertFrom-Json

        # Avoid $cfg.mcpServers when StrictMode hides missing-member access
        $msMember = @( $cfg.PSObject.Properties.Match('mcpServers') )

        $needNewServers = (($msMember.Count -eq 0) -or ($null -eq $msMember[0].Value))

        if ($needNewServers) {
            $mcpServersOnlyIru = New-Object PSCustomObject
            $mcpServersOnlyIru | Add-Member -MemberType NoteProperty -Name iru -Value $newIruEntry -Force
            $cfg | Add-Member -MemberType NoteProperty -Name mcpServers -Value $mcpServersOnlyIru -Force
        }
        else {
            $msMember[0].Value | Add-Member -MemberType NoteProperty -Name iru -Value $newIruEntry -Force
        }
    }
    catch {
        throw @"
Failed to read or merge $configPath :

$($_)

Repair the JSON manually, restore from $($bakPath), or rename the corrupt file aside and rerun.

"@
    }
}
else {
    $mcpServers = New-Object PSCustomObject
    $mcpServers | Add-Member -MemberType NoteProperty -Name iru -Value $newIruEntry -Force

    $cfg = New-Object PSCustomObject
    $cfg | Add-Member -MemberType NoteProperty -Name mcpServers -Value $mcpServers -Force
}

# -Depth avoids truncating nested args (ConvertTo-Json default depth is shallow on 5.x)
$payload = $cfg | ConvertTo-Json -Depth 20

$utf8 = New-Object System.Text.UTF8Encoding -ArgumentList $false
[System.IO.File]::WriteAllText($configPath, $payload, $utf8)

Write-Host ''
Write-Host 'IRU MCP (iru) merged into Claude Desktop config.' -ForegroundColor Green
Write-Host "Config: $configPath"
Write-Host "Bridge : npx $remotePkg -> $iruServer"

Write-Host @'

Next steps:
  1. Fully exit Claude Desktop (tray icon -> Quit)
  2. Reopen Claude Desktop
  3. Open a new chat and confirm tools attach

'@

Add the Iru MCP to Cursor

Official reference: Model Context Protocol (MCP) in Cursor. Use Cursor’s built-in MCP Settings UI first. You add Iru like any other MCP server (URL, transport, secrets) without hand-building folders or JSON unless you deliberately open or edit mcp.json from Cursor. Some flows open mcp.json in an editor pane; still treat that as Cursor-guided setup, not “create this file manually in Finder/File Explorer.”
1

Prepare values from Iru

Finish Copy your token and MCP configuration in Iru so you know the MCP URL and how Cursor should authenticate (often env or header-based secrets).
2

Open MCP settings

Open Cursor MCP Settings:
  • macOS: Cursor → Settings → Cursor Settings, then Tools & MCP.
  • Windows: File → Preferences → Cursor Settings, then Tools & MCP.
3

New MCP Server

Click New MCP Server.
4

Paste MCP configuration

Paste or import Iru’s MCP configuration using Cursor’s MCP UI when you can, so Cursor keeps the JSON valid.If Cursor opens mcp.json and you are editing by hand, what you paste depends on whether mcpServers is already there:
  • This is your first MCP server (new file, empty file, or no mcpServers yet): Use the full object Iru gives you, including the outer mcpServers wrapper and the iru entry inside it.
  • You already have other servers under mcpServers: Add only the iru entry—the inner block Iru shows for iru—as another property alongside your existing servers. Do not paste a second top-level mcpServers or a loose fragment; either one tends to produce invalid JSON.
5

Restart Cursor

Fully quit Cursor, then reopen. Cursor loads MCP on startup.
6

Confirm

Return to Tools & MCP. Confirm iru appears and the toggle shows enabled.
Cursor’s Composer / Agent exposes tools when MCP is healthy (Using MCP in chat).

Add the Iru MCP to OpenAI Codex

Via the Codex IDE extension UX

Complete Copy your token and MCP configuration in Iru first. macOS / Windows / Linux IDE host (same flow; menus follow VS Code)
1

Open Codex

Open VS Code, or another editor running the Codex extension, and open Codex activity.
2

Open Codex settings

Click the Codex extension gear menu.
3

Add server

Go to MCP servers → Add server.
4

Name

Enter “iru” for Name.
5

Transport

Click Streamable HTTP.
6

URL

Enter the URL from the MCP configuration you copied in Iru.
7

Header for X-API-Key

Under Headers, enter X-API-Key for the Key, and the API key from your MCP configuration as the Value.
8

Header for X-MCP-Profile

Under Headers, enter X-MCP-Profile for the Key, and the profile ID from your MCP configuration as the Value.
9

Save

Click Save.
10

Enable

Make sure the toggle for iru is set to enabled.

Iru API Overview

REST APIs, tokens, permissions, and Activity for the Enterprise API that MCP exposes as tools.

How to Set Up the Iru Endpoint API in Postman

Import the published collection and send authenticated requests outside MCP.

Iru Endpoint Management API reference

Browse endpoints, parameters, and request and response examples for the underlying API.

Integrating Third-Party Apps Using the Iru Endpoint API

Connect third-party products and map the API permissions each integration needs.