UiPath MCP Server

UiPath On-Premise MCP Server with Web UI for managing multiple MCP endpoints.

Architecture

• Backend: Python (FastAPI/Starlette) - MCP server with authentication
• Frontend: React + TypeScript (Vite) - Web UI for server management
• Database: SQLite - User, server, and tool configuration

Development

Prerequisites

• Python 3.11+
• Node.js 18+
• uv (Python package manager)

Backend Development

cd backend
uv sync
uv run python -m src.main

Backend runs on http://localhost:8000

Frontend Development

cd frontend
npm install
npm run dev

Frontend dev server runs on http://localhost:3000 with API proxy to backend.

Production Build

Build Frontend and Run

# Build frontend (outputs to backend/static/)
./build.sh

# Run backend (serves both API and frontend)
cd backend
uv run python -m src.main

Access the application at http://localhost:8000

Docker Deployment

# 1. Build frontend first
./build.sh

# 2. Build Docker image (uses version from pyproject.toml)
./docker-build-simple.sh

# 3. Run with Docker Compose
docker-compose up -d

Docker image will be tagged with the version from backend/pyproject.toml (currently: 0.1.0).

See DOCKER.md for detailed Docker deployment guide.

Manual Build

# Build frontend
cd frontend
npm install
npm run build

# Run backend
cd ../backend
uv run python -m src.main

Features

• 🔐 Multi-tenant Authentication - User registration and JWT-based authentication
• 🤖 Multiple MCP Servers - Create and manage multiple MCP server endpoints
• 🔧 Dynamic Tool Management - Create tools mapped to UiPath processes
• 🔑 Dual Authentication Support - PAT (Personal Access Token) and OAuth 2.0
• 🌐 Web UI - React-based interface for easy management
• 📊 Real-time Monitoring - Track tool execution and job status
• 🔒 Secure Token Management - Generate and manage API tokens per server
• 🏢 On-Premise Support - Works with both UiPath Cloud and On-Premise installations

API Endpoints

Authentication

• POST /auth/register - Register new user

  {
    "username": "user",
    "email": "user@example.com",
    "password": "password123"
  }
  

• POST /auth/login - Login and get JWT token

  {
    "username": "user",
    "password": "password123"
  }
  

• GET /auth/me - Get current user info (requires JWT)

• PUT /auth/uipath-config - Update UiPath configuration

  {
    "uipath_url": "https://cloud.uipath.com/org/tenant",
    "uipath_auth_type": "pat",
    "uipath_access_token": "your-pat-token"
  }
  

  Or for OAuth:

  {
    "uipath_url": "https://your-server.com/org/tenant",
    "uipath_auth_type": "oauth",
    "uipath_client_id": "your-client-id",
    "uipath_client_secret": "your-client-secret"
  }
  

MCP Servers

• GET /api/servers - List all servers for current user
• POST /api/servers - Create new MCP server

  {
    "tenant_name": "MyTenant",
    "server_name": "MyServer",
    "description": "Server description"
  }
  

• GET /api/servers/{tenant}/{server} - Get server details
• PUT /api/servers/{tenant}/{server} - Update server
• DELETE /api/servers/{tenant}/{server} - Delete server

Server Token Management

• GET /api/servers/{tenant}/{server}/token - Get current API token
• POST /api/servers/{tenant}/{server}/token - Generate new API token
• DELETE /api/servers/{tenant}/{server}/token - Revoke API token

MCP Tools

• GET /api/servers/{tenant}/{server}/tools - List all tools
• POST /api/servers/{tenant}/{server}/tools - Create new tool

  {
    "name": "my_tool",
    "description": "Tool description",
    "input_schema": {
      "type": "object",
      "properties": {
        "param1": {"type": "string"}
      },
      "required": ["param1"]
    },
    "uipath_process_name": "ProcessName",
    "uipath_folder_id": "folder-id"
  }
  

• GET /api/servers/{tenant}/{server}/tools/{tool} - Get tool details
• PUT /api/servers/{tenant}/{server}/tools/{tool} - Update tool
• DELETE /api/servers/{tenant}/{server}/tools/{tool} - Delete tool

UiPath Integration

• GET /api/uipath/folders - List UiPath folders
• GET /api/uipath/processes?folder_id={id} - List processes in folder

MCP Protocol

• GET /mcp/{tenant}/{server}/sse - SSE connection for MCP clients
• POST /mcp/{tenant}/{server}/sse/messages - SSE message posting
• GET /mcp/{tenant}/{server} - HTTP Streamable (GET)
• POST /mcp/{tenant}/{server} - HTTP Streamable (POST)
• DELETE /mcp/{tenant}/{server} - HTTP Streamable (DELETE)

Authentication: MCP endpoints require API token in header:

Authorization: Bearer <server-api-token>

Health Check

• GET /health - Server health check endpoint

UiPath Configuration

Authentication Methods

The server supports two authentication methods for UiPath:

1. Personal Access Token (PAT)

Best for UiPath Cloud environments:

• Generate PAT from UiPath Cloud Admin Console
• Configure in Settings page
• Suitable for: UiPath Cloud (cloud.uipath.com)

2. OAuth 2.0 (Client Credentials)

Best for On-Premise installations:

• Create OAuth application in UiPath
• Get Client ID and Client Secret
• Configure in Settings page
• Suitable for: On-Premise UiPath installations with self-signed certificates

SSL Certificate Handling

The server automatically handles self-signed certificates for On-Premise installations:

• SSL verification is disabled for non-cloud URLs
• SSL warnings are suppressed
• Works seamlessly with internal CA certificates

Execution Methods

The server automatically selects the appropriate execution method:

• UiPath Cloud (uipath.com in URL): Uses UiPath Python SDK
• On-Premise: Uses REST API with startJobs endpoint

Environment Variables

Create a .env file in the backend/ directory:

cd backend
cp .env.example .env
# Edit .env with your configuration

Available variables:

• API_HOST - Server host (default: 0.0.0.0)
• API_PORT - Server port (default: 8000)
• DB_PATH - Database file path (default: database/mcp_servers.db)
• SECRET_KEY - JWT secret key (required for production)
• TOOL_CALL_TIMEOUT - UiPath tool execution timeout in seconds (default: 600)
• LOG_LEVEL - Logging level (default: INFO)

Default Admin Account

When the database is first created, a default admin account is automatically created:

• Username: admin
• Password: admin
• Email: admin@mydomain.com
• Role: admin

⚠️ Security Warning: Please change the default password immediately after first login!

Usage Guide

1. Register and Login

1. Access the web UI at http://localhost:8000
2. Login with the default admin account (username: admin, password: admin)
3. Or register a new account and login with your credentials

2. Configure UiPath

1. Go to Settings page
2. Enter your UiPath URL
3. Choose authentication method:
   • PAT: Enter your Personal Access Token
   • OAuth: Enter Client ID and Client Secret
4. Save configuration

3. Create MCP Server

1. Go to Dashboard
2. Click "Create Server"
3. Enter tenant name and server name
4. Generate API token for the server

4. Add Tools

1. Select a server from the list
2. Click "Add Tool from UiPath"
3. Select folder and process
4. Configure tool parameters
5. Save tool

5. Use MCP Server

Configure your MCP client (e.g., Claude Desktop) with:

{
  "mcpServers": {
    "uipath": {
      "url": "http://localhost:8000/mcp/MyTenant/MyServer/sse",
      "headers": {
        "Authorization": "Bearer <your-server-api-token>"
      }
    }
  }
}

License

MIT