Skip to main content
Glama
Sign In
uipath-orchestrator-mcp

uipath-orchestrator-mcp

by adamstuber
OverviewSchemaSourceRelated ServersDiscussionsAdmin
Python
Hybrid

UiPath Orchestrator MCP Server

An MCP (Model Context Protocol) server that exposes UiPath Orchestrator operations as tools, enabling AI assistants like Claude to interact with your UiPath tenant directly.

Features

23 tools spanning the core Orchestrator APIs:

Category

Tools

Overview

get_orchestrator_summary

Folders

list_folders

Jobs

list_jobs, get_job, start_job, stop_job, get_jobs_across_folders, get_job_logs

Processes

list_releases

Queues

list_queue_definitions, get_queue_items, count_queue_items, add_queue_item, bulk_add_queue_items, delete_queue_item, retry_queue_item

Schedules

list_schedules, enable_schedule, disable_schedule

Robots & Machines

list_robots, list_machines

Assets

list_assets, get_asset

Related MCP server: Jira & Confluence MCP Server

Prerequisites

  • Python 3.12+

  • A UiPath Cloud account with an external application (OAuth client credentials)

  • The following OAuth scopes: OR.Jobs OR.Folders OR.Queues OR.Robots OR.Execution OR.Machines OR.Assets

Creating a UiPath External Application

  1. In UiPath Automation Cloud, go to Admin > External Applications

  2. Create a new application with Application Scopes (not user scopes)

  3. Grant the scopes listed above

  4. Copy the Client ID and Client Secret

Installation

Option 1: pip (stdio transport — recommended for local use)

pip install uipath-orchestrator-mcp

Option 2: Run from source

git clone https://github.com/adamstuber/uipath-orchestrator-mcp.git
cd uipath-orchestrator-mcp
pip install .

Option 3: Docker (SSE transport — for remote/shared use)

docker build -t uipath-orchestrator-mcp .
docker run -p 8000:8000 \
  -e UIPATH_CLIENT_ID=your_client_id \
  -e UIPATH_CLIENT_SECRET=your_client_secret \
  -e UIPATH_TENANT_NAME=your_tenant \
  -e UIPATH_ORG_NAME=your_org \
  uipath-orchestrator-mcp

Configuration

Copy .env.example to .env and fill in your credentials:

cp .env.example .env

Variable

Required

Description

UIPATH_CLIENT_ID

Yes

OAuth client ID from your external application

UIPATH_CLIENT_SECRET

Yes

OAuth client secret

UIPATH_TENANT_NAME

Yes

Your UiPath tenant name (e.g. DefaultTenant)

UIPATH_ORG_NAME

Yes

Your UiPath organization name (from the cloud URL)

UIPATH_SCOPES

No

Space-separated OAuth scopes (default: all required scopes)

MCP_TRANSPORT

No

stdio (default), streamable-http (recommended for HTTP), or sse (legacy HTTP)

MCP_HOST

No

Host to bind when using an HTTP transport (default: 0.0.0.0)

MCP_PORT

No

Port to bind when using an HTTP transport (default: 8000)

MCP_LOG_LEVEL

No

Logging level: DEBUG, INFO, WARN, ERROR (default: INFO)

Usage

Claude Desktop

Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json on macOS, %APPDATA%\Claude\claude_desktop_config.json on Windows):

{
  "mcpServers": {
    "uipath-orchestrator": {
      "command": "uipath-orchestrator-mcp",
      "env": {
        "UIPATH_CLIENT_ID": "your_client_id",
        "UIPATH_CLIENT_SECRET": "your_client_secret",
        "UIPATH_TENANT_NAME": "your_tenant",
        "UIPATH_ORG_NAME": "your_org"
      }
    }
  }
}

Alternatively, if you use a .env file:

{
  "mcpServers": {
    "uipath-orchestrator": {
      "command": "uipath-orchestrator-mcp"
    }
  }
}

Claude Code (CLI)

claude mcp add uipath-orchestrator uipath-orchestrator-mcp

HTTP transports (Docker or remote server)

Two HTTP-based transports are supported for remote or containerised deployments:

Transport

MCP_TRANSPORT value

Endpoint

Notes

Streamable HTTP

streamable-http

http://host:8000/mcp

Recommended — newer MCP spec standard

SSE

sse

http://host:8000/sse

Legacy, kept for older client compatibility

Example with streamable HTTP:

docker run -p 8000:8000 \
  -e MCP_TRANSPORT=streamable-http \
  -e UIPATH_CLIENT_ID=... \
  -e UIPATH_CLIENT_SECRET=... \
  -e UIPATH_TENANT_NAME=... \
  -e UIPATH_ORG_NAME=... \
  uipath-orchestrator-mcp

Then connect your MCP client to http://your-host:8000/mcp.

Example prompts

Once connected, you can ask Claude things like:

  • "Show me all faulted jobs from the last 24 hours across all folders."

  • "Start the InvoiceProcessing process in the Finance folder."

  • "How many Failed items are in the BillingQueue queue?"

  • "Retry all failed queue items in the Accounts folder."

  • "Disable the nightly schedule for the ReportGenerator process."

  • "What robots are available in the Production folder?"

Development

git clone https://github.com/adamstuber/uipath-orchestrator-mcp.git
cd uipath-orchestrator-mcp
pip install poetry
poetry install
cp .env.example .env  # fill in your credentials

Run the server locally (stdio):

poetry run uipath-orchestrator-mcp

Project structure

uipath_orchestrator_mcp/
  __init__.py     # package init
  api.py          # UiPath Orchestrator API client (authentication, OData, retries)
  server.py       # MCP tool definitions (FastMCP)
Dockerfile        # SSE transport container
pyproject.toml

Contributing

Contributions are welcome. Please open an issue before submitting a pull request for significant changes.

  1. Fork the repository

  2. Create a feature branch (git checkout -b feature/my-feature)

  3. Commit your changes

  4. Open a pull request

License

MIT — see LICENSE.

Available Tools

24 tools
add_queue_itemB

Add a new item to a queue.

Args: folder_name: The display name of the folder. queue_name: The name of the queue. specific_content: Key-value pairs of data to store with the queue item. priority: Item priority — 'Low', 'Normal', or 'High' (default 'Normal'). reference: Optional reference string for tracking purposes.

Inputs: queue_name (required), folder_name (required), specific_content (required), priority, +1 more.

bulk_add_queue_itemsA

Add multiple items to a queue in a single API call.

Args: folder_name: The display name of the folder. queue_name: The name of the queue. items: List of item objects. Each item may contain: - specific_content (dict, required) — the data payload - priority (str, optional) — 'Low', 'Normal', or 'High' - reference (str, optional) — tracking reference commit_type: 'AllOrNothing' (default) — rolls back everything if any item fails; 'ProcessAllIndependently' — commits each item individually.

Inputs: items (required), queue_name (required), folder_name (required), commit_type.

count_queue_itemsA

Return the total number of queue items matching the given criteria — without fetching the items.

Call this before get_queue_items to check volume and decide on batch_size / pagination strategy. Also useful for health checks (e.g. how many New items are waiting?).

Args: folder_name: The display name of the folder. queue_name: Queue name to scope the count. If omitted, counts across all queues in the folder. filter_query: Optional OData filter string (e.g. "Status eq 'Failed'").

Inputs: folder_name (required), queue_name, filter_query. Returns: result

delete_queue_itemA

Delete a queue item by its ID.

Args: queue_item_id: The ID of the queue item to delete. folder_name: The display name of the folder containing the item.

Inputs: folder_name (required), queue_item_id (required).

diagnose_jobA

Return a focused diagnostic report for a job — the first tool to call when asked 'what went wrong?' or 'why did this job fail?'.

Combines job metadata and error logs in one call, avoiding the need to chain get_job + get_job_logs. Only use get_job_logs afterward if you need more log history than tail provides or need to paginate through all entries.

Returns:

  • job: metadata (state, process, start/end time, duration, robot, error fields)

  • error_logs: all Error and Fatal log entries for the job

  • combined_log_view: deduplicated, time-sorted merge of error logs + last tail entries

Args: job_id: The ID of the job to diagnose. folder_name: The display name of the folder containing the job. tail: Number of most-recent log entries to include for context (default 15).

Inputs: job_id (required), folder_name (required), tail.

disable_scheduleB

Disable a process schedule.

Args: schedule_id: The ID of the schedule to disable. folder_name: The display name of the folder containing the schedule.

Inputs: folder_name (required), schedule_id (required).

enable_scheduleB

Enable a process schedule.

Args: schedule_id: The ID of the schedule to enable. folder_name: The display name of the folder containing the schedule.

Inputs: folder_name (required), schedule_id (required).

get_assetA

Get a specific asset by name from a folder.

Args: folder_name: The display name of the folder. asset_name: The name of the asset to retrieve.

Inputs: asset_name (required), folder_name (required). Returns: result

get_jobA

Get the full details for a specific job by ID (raw API response).

Returns all job fields. If you need to understand why a job failed, use diagnose_job instead — it also fetches error logs and returns a structured summary.

Args: job_id: The ID of the job. folder_name: The display name of the folder containing the job.

Inputs: job_id (required), folder_name (required).

get_job_logsA

Retrieve paginated robot execution logs for a specific job.

Use diagnose_job instead when the goal is to understand a failure — it combines job metadata with error logs and recent context in a single focused response. Use get_job_logs when you need full log pagination, specific time ranges, or log levels that diagnose_job doesn't surface.

Log levels (lowest to highest): Trace, Info, Warn, Error, Fatal.

Args: job_id: The ID of the job. folder_name: The display name of the folder containing the job. batch_size: Number of log entries to return (default 100). skip: Number of entries to skip for pagination. min_level: Minimum log level to return — 'Trace', 'Info', 'Warn', 'Error', or 'Fatal'. Ignored if log_levels is provided. log_levels: Exact levels to include, e.g. ['Error', 'Fatal']. Takes priority over min_level. start_time: Return logs at or after this ISO 8601 datetime string. end_time: Return logs at or before this ISO 8601 datetime string.

Inputs: job_id (required), folder_name (required), skip, end_time, +4 more. Returns: result

get_jobs_across_foldersA

Query jobs across multiple folders in a single call — the preferred tool for tenant-wide or multi-folder job queries.

Use list_jobs instead only when you already know the single folder and need advanced OData filtering or job_priority filtering.

Returns a trimmed set of fields per job (same as list_jobs). Results from all folders are merged and optionally sorted by StartTime.

Args: state: Filter by execution state — 'Faulted', 'Successful', 'Pending', 'Running', 'Stopped', 'Stopping'. folder_names: Folders to check. If omitted, checks all non-workspace folders. hours_back: Return jobs started within the last N hours. Takes priority over days_back. days_back: Return jobs started within the last N days. release_name: Filter jobs by release name. source: Filter by how the job was triggered — 'Manual', 'Schedule', 'Agent', 'Queue'. most_recent_first: If True, return most recently started jobs first per folder, then sort combined results. Use with batch_size to efficiently find the last N jobs across folders. batch_size: Max jobs to return per folder (default 50).

Inputs: state, source, days_back, batch_size, +4 more. Returns: result

get_orchestrator_summaryA

Return all non-workspace folders with their deployed processes and queue names.

This is the primary discovery tool. Call it once at the start of any session or whenever the folder name, process name, or queue name is unknown. The names returned here are the exact values expected by folder_name, process_name, and queue_name parameters in all other tools.

Returns a list of objects: {folder, processes: [...], queues: [...]}. Personal workspace folders are excluded automatically.

Inputs: no named parameters.

get_queue_itemsA

Retrieve a batch of queue items from a specific queue.

Queue item statuses: New, InProgress, Successful, Failed, Abandoned, Retried, Deleted.

Before calling this on a large queue, use count_queue_items to check volume. Use most_recent_first=True with a small batch_size to efficiently get the latest items.

OData filter examples:

  • "Status eq 'Failed'"

  • "Status eq 'New' and Priority eq 'High'"

  • "Reference eq 'ORDER-123'"

Args: folder_name: The display name of the folder. queue_name: The name of the queue. batch_size: Number of items to return (default 100). skip: Number of items to skip for pagination (default 0). filter_query: Optional OData filter string. most_recent_first: If True, return newest items first.

Inputs: queue_name (required), folder_name (required), skip, batch_size, +2 more. Returns: result

list_assetsA

List all assets in a folder.

Args: folder_name: The display name of the folder.

Inputs: folder_name (required). Returns: result

list_foldersA

List all folders in UiPath Orchestrator (raw API response).

Prefer get_orchestrator_summary over this tool — it also returns processes and queues per folder and filters out personal workspaces. Use list_folders only when you need the raw folder metadata (IDs, types, parent hierarchy).

Inputs: no named parameters. Returns: result

list_jobsA

List and filter jobs within a single folder.

Use this when the user asks about jobs in a specific, known folder. Use get_jobs_across_folders instead when querying multiple folders or the entire tenant.

Returns a trimmed set of fields per job: Id, ReleaseName, State, StartTime, EndTime, Info, JobError, HostMachineName, Source, and _folder.

Args: folder_name: The display name of the folder. batch_size: Number of jobs to return (default 50). skip: Number of jobs to skip for pagination (default 0). state: Filter by job state — 'Faulted', 'Successful', 'Pending', 'Running', 'Stopped', 'Stopping'. job_priority: Filter by priority — 'Low', 'Normal', or 'High'. start_time: Filter jobs that started at or after this ISO 8601 datetime string. end_time: Filter jobs that ended at or before this ISO 8601 datetime string. release_name: Filter jobs by release (process) name. source: Filter by how the job was triggered — 'Manual', 'Schedule', 'Agent', 'Queue'. most_recent_first: If True, return most recently started jobs first.

Inputs: folder_name (required), skip, state, source, +6 more. Returns: result

list_machinesA

List machines, optionally scoped to a specific folder.

Args: folder_name: The display name of the folder (optional). If omitted, returns all machines.

Inputs: folder_name. Returns: result

list_queue_definitionsA

List all queue definitions (metadata) in a folder.

Returns queue names, IDs, and configuration — but not the queue items themselves. To retrieve actual work items, use get_queue_items. To count items matching a filter before fetching, use count_queue_items.

Args: folder_name: The display name of the folder.

Inputs: folder_name (required). Returns: result

list_releasesA

List all releases (deployed automations) in a folder with full metadata.

In UiPath, a "release" is a specific version of a process package deployed to a folder. get_orchestrator_summary returns just the process names; use list_releases when you need release keys (GUIDs), package versions, entry points, or other deployment metadata.

Args: folder_name: The display name of the folder.

Inputs: folder_name (required). Returns: result

list_robotsA

List robots, optionally scoped to a specific folder.

Args: folder_name: The display name of the folder (optional). If omitted, returns all robots.

Inputs: folder_name. Returns: result

list_schedulesA

List all process schedules (time-based triggers) in a folder.

Returns schedule metadata including cron expression, enabled/disabled state, and the associated release name. Use enable_schedule / disable_schedule to toggle them.

Args: folder_name: The display name of the folder.

Inputs: folder_name (required). Returns: result

retry_queue_itemA

Retry a Failed or Abandoned queue item, resetting it to New so robots will pick it up again.

Only applicable to items with status Failed or Abandoned — retrying items in other states will return an API error. The row_version field is returned with each queue item from get_queue_items and is required for optimistic concurrency control.

Args: queue_item_id: The ID of the queue item to retry. row_version: The RowVersion value from the queue item (prevents stale retries). folder_name: The display name of the folder containing the item.

Inputs: folder_name (required), row_version (required), queue_item_id (required).

start_jobA

Start a new execution of a process (release) in a folder.

Provide process_name (as returned by get_orchestrator_summary) and folder_name — the release key is looked up automatically. Only provide release_key if you already have the exact GUID and want to skip that lookup.

Strategy options:

  • 'All' (default): run on all connected robots in the folder.

  • 'Specific': run only on the robots listed in robot_ids.

  • 'JobsCount': start exactly jobs_count parallel job instances.

Args: folder_name: The display name of the folder containing the process. process_name: The process name as returned by get_orchestrator_summary. release_key: GUID of the release. Omit to auto-resolve from process_name. strategy: Robot allocation strategy — 'All', 'Specific', or 'JobsCount'. robot_ids: List of robot IDs to target (required when strategy is 'Specific'). jobs_count: Number of job instances to start (required when strategy is 'JobsCount'). input_arguments: Dictionary of input argument name→value pairs to pass to the process.

Inputs: folder_name (required), strategy, robot_ids, jobs_count, +3 more. Returns: result

stop_jobA

Stop a running job.

Args: job_id: The ID of the job to stop. folder_name: The display name of the folder containing the job. strategy: Stop strategy — 'SoftStop' (graceful, waits for current transaction) or 'Kill' (immediate).

Inputs: job_id (required), folder_name (required), strategy.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Deploy Server
    One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

    TDQS

    A3.8/5.0

    Scored across 24 tools

    Disambiguation4/5

    Most tools have clearly distinct purposes, and overlapping pairs like list_jobs vs get_jobs_across_folders or get_job vs diagnose_job are explicitly differentiated in their descriptions. The guidance to prefer get_orchestrator_summary over list_folders reduces ambiguity. However, the sheer number of tools and some close functional similarities (e.g., count_queue_items vs get_queue_items) create minor potential for misselection.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern with lowercase and underscores (list_folders, get_queue_items, start_job, diagnose_job). Even multi-word names like get_jobs_across_folders and bulk_add_queue_items maintain the pattern. There are no stylistic deviations or mixed conventions.

    Tool Count3/5

    With 24 tools, this sits at the high end of the 'borderline' range (16-25). The coverage spans multiple resource types (queues, jobs, schedules, robots, assets), so the count is justified for a broad Orchestrator domain, but it feels heavy compared to more focused servers. A few tools could be consolidated (e.g., diagnose_job could wrap get_job and get_job_logs internally without exposing them).

    Completeness3/5

    The set covers key operations for queues (add, get, delete, retry, count) and jobs (list, get, start, stop, diagnose, logs), which are the core workflows. However, there are notable gaps: no create/update/delete for schedules, assets, robots, or machines, and no folder management beyond listing. This means users can monitor and operate existing resources but cannot manage the full lifecycle of those resources.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Resources

    Related MCP Connectors

    Related MCP Servers