@belal-elsabbagh-apex/copilot-mcp
Provides tools for managing and analyzing orders in UiPath Orchestrator, including cloning orders between environments, finding clone candidates, deleting pre-prod orders, building queue items, and tracing order executions to jobs.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
@belal-elsabbagh-apex/copilot-mcp
MCP server exposing EHR Copilot operations over stdio. It is a Go program, served through npx: the
release tarball's bin/copilot-mcp.js is a tiny Node launcher that execs the bundled static Go binary for your
platform (dist/<goos>-<goarch>/copilot-mcp[.exe]).
Platforms: linux/amd64, darwin/arm64 (Apple Silicon) and windows/amd64 — nothing else ships (Intel Macs and linux/arm64 are unsupported; the launcher exits with a message listing the three). Requirements: Node >= 20 to run it (the launcher only); nothing else — the binary is self-contained. Go 1.27 is needed only to develop it.
Install and run
There is no npm registry. The package is private, is not published to npmjs or GitHub Packages, and needs no
.npmrc or token. Every GitHub release attaches copilot-mcp.tgz and the repo is public, so npx runs it straight
from the download URL. releases/latest/download/copilot-mcp.tgz always points at the newest release; swap in
releases/download/vX.Y.Z/copilot-mcp.tgz to pin a version.
{
"mcpServers": {
"copilot": {
"command": "npx",
"args": [
"-y",
"https://github.com/belal-elsabbagh-apex/copilot-mcp/releases/latest/download/copilot-mcp.tgz"
],
"env": {
"COPILOT_MCP_CONFIG": "/abs/path/to/copilot-mcp.config.json"
}
}
}
}Pinned form: npx -y https://github.com/belal-elsabbagh-apex/copilot-mcp/releases/download/vX.Y.Z/copilot-mcp.tgz
(a release also carries the same tarball as belal-elsabbagh-apex-copilot-mcp-X.Y.Z.tgz).
Use COPILOT_MCP_LOCAL_DIR instead of COPILOT_MCP_CONFIG for the split legacy files.
The tarball is about 13 MB (v2.0.0's JS tarball was 174 KB): each Go binary carries its own runtime. npx caches
the package once per version, so a pinned URL downloads once.
A release also attaches the raw binaries (copilot-mcp-linux-amd64, copilot-mcp-darwin-arm64,
copilot-mcp-windows-amd64.exe) if you would rather run one directly with no Node at all.
As an MCP Bundle (.mcpb)
Every release also attaches copilot-mcp.mcpb — a self-contained MCP Bundle
(launcher + the three platform binaries + manifest.json + copilot-mcp.config.example.json) for one-click install in
MCPB-supporting hosts (e.g. Claude for macOS/Windows). Download it from the
latest release, open it with the host, and
when prompted for the Config file option point it at your own copilot-mcp.config.json (see
copilot-mcp.config.example.json). The host runs node bin/copilot-mcp.js
with COPILOT_MCP_CONFIG set to that path.
Related MCP server: opencode-codex-mcp
Tools
33 tools, grouped below by domain. Args lists only the arguments relevant to auth/scope
(env, profile, orchestrator) — see each tool's own schema for the rest. Every Copilot tool requires an
explicit profile; most also require an explicit env (prod | pre_prod) — neither is ever
defaulted. The one exception is list_clinics, which takes env but no profile: it's the
discovery tool that produces the profile → clinicUid mapping, so requiring a profile would be
circular. Orchestrator tools also take env but no profile (orchestrators auth globally, not per-account), plus an
orchestrator (uipath | apex) that is required and never defaulted on every job- or queue-level tool. The carve-outs:
find_order_queue_items and find_stuck_orders (omitted = every registered backend) and the Apex-only get_job_artifacts (no orchestrator arg).
Copilot orders
All read tools here are READ-ONLY. Writes (delete_preprod_order, create_preprod_order,
submit_preprod_order) only ever target pre-prod; prod is never mutated. There's no single
"clone" tool — the clone-and-verify-order prompt (see Prompts below) orchestrates find_clone_candidates
→ get_order → create_preprod_order (and the settings tools, if a reference doesn't resolve).
Tool | Args | What it does |
|
| Scan recent PROD orders and return only the ones that will actually clone to forReview (have a referredFacility, orderType, and orderNames) — filters out the ones that would get stuck "incomplete". |
|
| Mint a fresh PRE-PROD order from explicit data and drive it to forReview. Never submits (see |
|
| Submit a PRE-PROD order sitting at forReview, advancing it to inProgress. A real, deliberate write — requires explicit user authorization before calling. |
|
| Delete one or more orders from PRE-PROD ( |
|
| Fetch one order's normalized detail (status, insurance, ICD/CPT, facility, POS, note presence) plus |
|
| Filter an account's orders by location, insurance, referred-to, order type, auth/upload status, MRN, free text or any of 5 date ranges ( |
|
| Cheap per-folder order counts (For Review, PCP Notes, Processing, Archived, with sub-buckets) for a filter, same dimensions as |
|
| Scan recent orders in an env and flag ones sitting in a non-terminal status (default |
|
| Fetch an order and BUILD the queue-item request payload for the chosen orchestrator — never POSTs. |
|
| Log into the Copilot BE (reusing a cached session) and return the session JWT (the same token UiPath callbacks use as |
|
| List the clinics the configured support account can switch into ( |
Orchestrator (UiPath + Apex) — reads
All READ-ONLY. Every tool takes env and orchestrator (uipath | apex); results come back as { orchestrator, env, … } with backend-neutral cores (JobCore, QueueItemCore, QueueCore, ProcessCore, TriggerCore) and backend-specific fields under details. Job state uses UiPath's vocabulary on both backends (Apex statuses are mapped; rawState keeps the original). One Apex transaction can have many jobs (a retry is a new job on the same queue item), so queue items carry jobs[], newest first.
Tool | Args | What it does |
|
| List the most recent jobs in a folder, newest first, no order correlation ( |
|
| Fetch one ( |
|
| Fetch a job's logs (oldest first, capped 500), batchable via |
|
| List a job's artifacts ( |
|
| Find the queue item(s) an order flowed through and their job ids. |
|
| Browse a portal's queue for triage — |
|
| List queues in a folder — use to discover a queue id (pre-prod ids differ from the prod portal registry) or the exact queue name for |
|
| List processes (UiPath releases / Apex workflows) — |
|
| List triggers (queue + time). Apex has no triggers API, so queue triggers are synthesized from queues ( |
|
| Fetch one queue item (UiPath: Orchestrator |
|
| Read a faulted job + its logs and BUILD a ready-to-post GitHub issue payload ( |
Orchestrator (UiPath + Apex) — writes (pre-prod only)
env is a schema-enforced literal "pre_prod" on every tool below — "prod" is rejected before
any HTTP call (UiPath: the dev-clone folder; Apex: the Authorization Test folder), and every posted payload passes a safety guard.
Tool | Args | What it does |
|
| POST one item to a pre-prod queue ( |
|
| Delete one queue item ( |
|
| Start job(s) for a process ( |
|
| Stop ( |
Settings sync (prod ↔ pre-prod)
diff_settings/get_settings/plan_settings_sync are READ-ONLY; apply_settings_sync is the
only settings tool that writes, and it's additive-only against pre-prod (never overwrites/deletes).
Tool | Args | What it does |
|
| Diff an account's settings between prod and pre-prod (UID/timestamp/dummy-email noise stripped, list items matched by name not UID). Scope with |
|
| Fetch an account's settings sections from ONE env — the single-env counterpart to |
| — | List every section |
|
| Compute — WITHOUT writing — the additive actions that would copy prod-only settings into pre-prod. Covers the specialties domain ( |
|
| Execute a reviewed selection of |
Meta / diagnostics
Tool | Args | What it does |
|
| Probe the server's external connections — three checks per env (prod + pre-prod): Copilot BE auth (reusing a cached session; reports |
| — | Compose a GitHub issue about this MCP server from a bug report or general feedback — no tool failure required. Posts nothing and holds no GitHub credentials; returns |
Prompts
User-invokable workflow prompts chain the tools above for common ops tasks:
diagnose-order, reconcile-settings, inspect-settings, clone-and-verify-order,
triage-stuck-orders, report-faulted-jobs, and send-mcp-feedback.
reconcile-settings walks the full settings workflow: list_setting_sections →
diff_settings → plan_settings_sync → review the planned action ids with the user →
apply_settings_sync with exactly the approved ids. inspect-settings reads one env's
settings via get_settings and summarizes them.
clone-and-verify-order picks a cloneable prod order (or uses a given uid), reads it via
get_order, and mints an equivalent pre-prod order via create_preprod_order — there's no
dedicated "clone" tool, since whether a clone succeeds is order-specific (it depends on
pre-prod already having the referenced facility/speciality/order type/order names). If minting
fails or the order doesn't reach forReview, the prompt diagnoses via list_setting_sections →
diff_settings → plan_settings_sync, reporting a proposed fix rather than applying one.
Submitting the resulting order is a separate, explicit submit_preprod_order call that only
happens with the user's authorization.
report-faulted-jobs finds faulted jobs on the chosen orchestrator (uipath or apex; prod by default) and files each as a
GitHub issue on Apex-Medical-AI-Inc/RPAPlaywright — creating one issue per distinct fault
and commenting on the existing issue when the same fault recurs. Apex fault signatures are
apex:-prefixed so they never collide with UiPath ones. This server holds no
GitHub credentials: the prompt drives a GitHub MCP server connected in the host to do
the actual search/create/comment, so that server must be connected with write access to the
repo.
send-mcp-feedback (summary, optional kind = bug | feedback) turns a report about this server itself into a
GitHub issue via build_mcp_issue and the host's GitHub tooling.
Configuration
The server reads one validated config holding the Copilot BE creds and the UiPath / Apex args. Two ways to provide it:
Single file (preferred): set
COPILOT_MCP_CONFIGto a JSON file shaped likecopilot-mcp.config.example.json. IfCOPILOT_MCP_CONFIGisn't set, the server looks forcopilot-mcp.config.jsonin its working directory (falling back to the olderconfig.local.jsonname if that's what you already have).Split legacy files: set
COPILOT_MCP_LOCAL_DIRto a directory containingorder-copy-credentials.json+uipath-config.json.
Each copilot.profiles.<name> entry has a prod/pre_prod env pair, and each env is
either:
a support-account pointer,
{ "clinicUid": "..." }— the credentials that actually log in come fromcopilot.support.<env>(shared across every profile using this mode for that env); use thelist_clinicstool to look up each clinic'sclinicUid, ora direct login,
{ "be", "email", "password", "fe"? }— the original per-account shape, unchanged.
clinicUid wins if a profile entry somehow carries both, which is how an account is migrated
to the support-account model one env at a time without deleting its old credentials. Today
prod ships as support-account (copilot.support.prod required) and pre-prod stays on direct
login, but nothing hard-codes that split — it's whatever each profile's env entries say.
Authenticated sessions (cookies + JWT) are cached in memory and, by default, on disk at
~/.cache/copilot-mcp/sessions.json (mode 0600; $XDG_CACHE_HOME is honored when set to an
absolute path; COPILOT_MCP_CACHE overrides the path outright) so a server restart doesn't
burn a login. Set "copilot.sessionCache": false to disable disk persistence (memory-only for
the process lifetime; this also disables the job caches and token persistence, see Caching). This is what keeps the support account's 10-logins-per-15-minutes budget
from being exhausted by routine restarts — never commit or echo that cache file, it holds live
tokens.
The uipath.queueUrl / addQueueItemPath / serverUrlByEnv fields are only
required by build_queue_item. Editing the config file while the server is running
takes effect on the next tool call — no restart needed — and the server sends an MCP
logging notification when it reloads.
Apex orchestrator (optional)
Add an apex block to enable orchestrator: "apex":
"apex": {
"apiUrl": "https://orchestrator.apexmedicalai.com",
"username": "…", "password": "…",
"folderByEnv": { "prod": "Authorization", "pre_prod": "Authorization Test" },
"serverUrlByEnv": { "pre_prod": "https://pre-prod-be-batch.ehrcopilotbe.com" },
"queueUrl": "https://sqs.…"
}apiUrlis the load-balancer host, never a CloudFront host (CloudFront caps request bodies at 8 KB).username/passwordare your own login — Apex audits writes per user.folderByEnvis optional (the values above are the defaults); folder names resolve to ids at runtime.serverUrlByEnv/queueUrlpin what a posted queue item may carry (the write guard fails closed when they are unset).Any of
apiUrl/username/passwordthe file leaves out is read fromAPEX_API_URL/APEX_USER_NAME/APEX_PASSWORD. This needs a host that passes its environment through (CLI hosts andnpxdo); MCPB installs only passCOPILOT_MCP_CONFIG, so they must use the file.With neither source configured, every
orchestrator: "apex"call fails with "Apex is not configured"; UiPath and Copilot tools are unaffected.doctorreports which source was used.
get_job_artifacts downloads Apex artifacts to ~/.cache/copilot-mcp/artifacts/<jobId>/
(directory mode 0700, never inside a repo). Treat them as PHI.
See the copilot://reference/config-guide MCP resource for a full field-by-field walkthrough
(load order, an annotated JSON template, and the doctor/list_clinics verification steps) —
it's what an agent reads to set this server up from scratch.
When a tool fails for a reason that looks like a bug in this server (an unexpected
exception — not a bad profile, missing/invalid config, not-found, auth, or any HTTP error
the upstream system returned; a transport failure such as a refused/reset connection, a DNS error or a
timeout is flagged), the error response includes a reportIssue block with a
prefilled GitHub new-issue URL. This is on by default; the optional feedback block turns
it off or repoints it:
"feedback": { "enabled": false, "repositoryUrl": "https://github.com/your-org/your-fork" }Caching
Settled jobs never change, so reads of them are cached persistently (memory + disk) and survive restarts:
Apex artifact listings and parsed job.log, UiPath RobotLogs and terminal job details, plus the Apex JWT and UiPath
OAuth token (so a restart doesn't burn a login). An entry is stored only when a live read shows the job
terminal and settled (ended 5+ minutes ago; 15 for Apex cancelled/lost/timed_out); errors, not-found
and running jobs are never cached, and write tools never read through a cache. The two backends differ on a
hit: Apex always reads the job live first (so a hit is served only after that read confirms the job is still
settled), while UiPath serves a hit with no upstream call at all (terminal states are absorbing, and a
per-hit read would spend the tenant's 100 req/min Jobs budget); UiPath makes its extra light Jobs read only on a miss.
Job logs and outputs are PHI and now persist on disk under the cache directory (
~/.cache/copilot-mcp/;$XDG_CACHE_HOMEandCOPILOT_MCP_CACHEare honored, same rules as the session cache):cache/<namespace>/andtokens/, directories0700, files0600, filenames are hashes. Same protection as the artifacts directory — never commit or paste them. Bounded to 512 MiB per namespace and 30 days.Force a refresh: pass
refresh: truetoget_job,get_job_logsorbuild_faulted_job_issue. It skips the cache read and stores the fresh result.get_job_artifactsalso accepts it, but that tool never reads a cache (it always lists live); thererefreshonly re-downloads files whose local copy already matches.Turn it off:
"copilot.sessionCache": falsedisables all disk persistence (sessions, tokens, job caches); they then live in memory for the process only. Or delete the cache directory at any time.LOG_LEVEL=debuglogs cache events (hit-disk,hit-memory,stored,refresh-bypass) with hashed keys only.
Details, keys and bounds: docs/concurrency-and-caching.md.
Migrating from v1.x (v2.0.0 breaking changes)
v2.0.0 puts UiPath and Apex behind one tool surface, so argument names and output shapes became backend-neutral. Skills/prompts that call the old names must be updated.
v1.x | v2.0.0 |
(no such arg) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| per-order |
|
|
| per-job |
|
|
tool results |
|
prompt |
|
resource |
|
UiPath state values and UiPath fault signatures are unchanged. Apex job statuses are mapped
onto the same state vocabulary (completed→Successful, failed→Faulted, cancelled→Stopped, …);
the raw value is always in rawState.
Local development
Needs Go 1.27 (and Node >= 20, jq, curl and python3 for the package smoke). make check is the single
gate — vet, gofmt, golangci-lint (pinned), actionlint, go test -race, a package smoke (cross-builds the three
platforms, runs the launcher through initialize, checks the tarball contents, then cold-installs the tarball over
local HTTP with npx -y http://127.0.0.1:<port>/copilot-mcp.tgz — the shipped install path) and the release-script
self-test — and CI runs exactly it.
make build # ./copilot-mcp (version from `git describe`, leading v stripped)
make test # go test -race ./...
make check # the whole gate
make hooks # opt in: pre-push hook runs `make check`
go test -race ./internal/copilot/settings/ -run TestName # one package / test
go run ./cmd/copilot-mcp # run from source (needs COPILOT_MCP_CONFIG)Exercising the tools
Build, then launch the MCP Inspector against the binary — a UI to list and call the tools without a host:
make build
COPILOT_MCP_CONFIG=/abs/path/to/copilot-mcp.config.json npx @modelcontextprotocol/inspector ./copilot-mcpLogging is silent below warn by default so it never corrupts the stdio JSON-RPC stream. Set LOG_LEVEL=debug
(or COPILOT_MCP_DEBUG=1) to route logs to stderr.
Conventions, invariants and the package map: CLAUDE.md; Go style:
.claude/skills/go-style/; concurrency and caching:
docs/concurrency-and-caching.md.
Releasing
Tag-driven; the version is the git tag, so there is nothing to bump by hand (package.json and
manifest.json stay at 0.0.0-dev; the workflow stamps them). Add a ## [X.Y.Z] - date entry to
CHANGELOG.md, merge to main, then:
make release VERSION=X.Y.Z DRY_RUN=1 # print the plan
make release VERSION=X.Y.Z # tag origin/main and push only that tagscripts/release.sh refuses an existing tag, a missing changelog entry, a dirty tree, or a HEAD that isn't
origin/main. The pushed tag triggers .github/workflows/release.yml: it refuses a tag that is not on
origin/main, runs the gate (check.yml), stamps the tag's version into package.json and manifest.json, then
make dist (the three binaries, serverInfo.version = the bare version, e.g. 2.1.0), npm pack and make mcpb,
and creates the GitHub release. Nothing is published to a registry. The release attaches copilot-mcp.tgz,
belal-elsabbagh-apex-copilot-mcp-X.Y.Z.tgz, copilot-mcp.mcpb and the raw binaries. A - in the version
(2.1.0-rc.1) creates a GitHub prerelease (releases/latest skips it).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Persistent memory, hybrid search and a goal graph for AI agents, over stdio or remote HTTP.
Shared memory MCP server for Claude Code, Codex, Gemini CLI and Cursor. Cited, editable.
Develop, manage, and debug Railway projects, services, and deployments from within agents.
Illumora Craft — evidence-augmented prompt compile for agents via remote MCP (OAuth) or local stdio.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables local text analysis, statistical calculations, and system information retrieval via the Model Context Protocol over stdio.-
- FlicenseNot gradedqualityCmaintenanceEnables MCP-compatible hosts such as OpenCode to drive the Codex CLI through codex app-server over stdio, exposing tools to run prompts, inspect status, list threads, and interrupt running turns.-
- FlicenseNot gradedqualityBmaintenanceEnables MCP clients such as Claude Desktop or Claude Code to drive the local daemon through stdio, listing agents and sessions, running agents, and reporting costs.-
- AlicenseNot gradedqualityBmaintenanceEnables Claude Code, Cursor, OpenCode/LunaCode, and other MCP clients to invoke the harness's shell, file, code, scheduling, and device-control tools over stdio.MIT