Skip to main content
Glama
jamf-platform-mcp-server

jamf-platform-mcp-server

jamf-platform-mcp-server: MCP server for the Jamf Platform API Gateway

Tier Upstream pre-commit Tests License SemVer Keep a Changelog Node

An MCP server that gives AI assistants read access to a Jamf fleet through the Jamf Platform API Gateway, authenticating with OAuth 2.0 client credentials rather than user-account tokens. That choice is the point of the project: scoped machine credentials mean the permission boundary is enforced by Jamf, so a read-only integration cannot mutate a fleet no matter what this code does. See JPM-0001.

A second, optional server built from the same code makes a deliberately narrow set of reversible writes, today Restricted Software create and update, scope changes on profiles and policies (computers and computer groups, as targets or exclusions), and script and (always disabled) policy creation, under its own credential (JPM-0008). JPM-0013 decides the write server's whole intended surface and permission set once; the tools it lists beyond today's ten are built in phases. The read server never gains a write tool. Canonical location: github.com/jackvaughanjr/jamf-platform-mcp-server.

Tier: Prototype — no production dependants, upstream API in public beta, minor versions may break.

The upstream API is a public beta. The Platform API Gateway has no published breaking-change protocol and no announced GA date. Pin dependencies and expect churn. One documented API group (Compliance Benchmarks) currently returns a gateway-side 500 (JPM-0006).

Provenance

This is an independent project, not a fork or a derivative. No shared git history, no upstream remote, and no copied code.

It is worth naming an influence, though: evaluating dbankscard/jamf-mcp-server (MIT) is what surfaced the compound-tool idea used here: answering a whole fleet question in one call rather than making a model loop over per-device requests. That is a design idea, freely reusable and not subject to any licence term, so this credit is courtesy rather than obligation and carries no requirement onward to anyone using this project. Reasoning: JPM-0002.

Related work worth knowing about:

Related MCP server: KVMFleet MCP Server

Structure

src/
  index.ts              read server: tool registration, stdio transport
  write-server.ts       write server (JPM-0008 to JPM-0014): the ten write tools, nothing else
  restricted-software.ts  write logic: scope rules, XML, diff, read-back, rollback
  scope-membership.ts   write logic: add/remove one computer group in a profile or policy scope
  scope-changes.ts      write logic: the scope-change engine (plan hash, one PUT per object) and applyScopeChanges: computers or groups, targets or exclusions (JPM-0014)
  scope-membership-batch.ts  write logic: applyScopeMembershipBatch, group targets only, as an input format over that engine
  create-script.ts      write logic: create one script (Jamf Pro API JSON), contents hashed (JPM-0012)
  create-policy.ts      write logic: create one policy, always disabled, explicit scope, parameters hashed (JPM-0012)
  secret-material.ts    hashing and error scrubbing for values the create tools never echo
  payload-normalization.ts  semantic check that a profile difference is only Jamf regenerating inner payload ids (JPM-0011)
  mcp-common.ts         config loading and result rendering shared by both servers
  platform-client.ts    every gateway concern — auth, token cache, URL shapes, paging
  config.ts             environment validation (zod)
  fleet.ts              pure fleet aggregation — no client, no clock, no I/O
  automations.ts        script/policy auditing, criteria projection, inventory cost
  declaration-scope.ts  pure DDM rollup: one declaration across many devices
  references.ts         pure reference analysis + smart-group dependency graph
  adr-guard.ts          CI's ADR immutability check; allows only a superseded-by pointer
  *.test.ts             unit tests (vitest)
decisions/              architectural decision records, JPM- prefix, immutable
docs/
  capabilities.md       what the server can answer, by question rather than endpoint
  gateway-reference.md  observed gateway behaviour: paths, status semantics, paging
  endpoint-inventory.md documented endpoint surface, compiled from Jamf's llms.txt
  BACKLOG.md            open work: why each item exists and what done looks like
fixtures/
  shapes/               type-only response schemas — committed
  raw/                  captured responses — GITIGNORED, live fleet data
  discovery-report.md   empirical record of what resolves
scripts/
  discover-gateway.sh   resolves service segments; probes the PRE-2026-move gateway
  fetch-blueprints.sh   standalone Blueprints smoke test (current gateway)
  jamf                  cwd-independent wrapper: scripts/jamf <tool> ['<json>']
  call-tool.mjs         calls one MCP tool live; inherits env so `op run` works
  check-adr-immutability.sh
.githooks/pre-commit    rejects force-added ignored files; enforces ADR immutability

Current state (as of 2026-10-06)

Jamf moved the gateway between 2026-08-10 and 2026-10-06. The host is now {region}.api.jamfcloud.com, paths drop the /api/ prefix and the tenant segment, and the tenant or environment travels in a header. Pre-move integrations did not survive; create a Platform environment integration. Details in docs/gateway-reference.md.

Working and confirmed against a live tenant, re-confirmed on the new gateway 2026-10-06 (path below the host is /{segment}/{version}/{resource}, or /proclassic/{resource}):

segment

style

resource

notes

blueprints

tenant

blueprints

totalCount-only envelope; needs a Platform environment integration

blueprints

tenant

blueprint-components

records keyed identifier, not id

devices

tenant

devices

full paging envelope; spans macOS and iOS

device-groups

tenant

device-groups

full envelope; exposes memberCount

pro

tenant

300+ resources

the Jamf Pro API in full

proclassic

classic

{resource}

Jamf Pro Classic — no version segment

ddm/report

tenant

devices/{id}/channels

Declaration Reporting

ddm/report

tenant

devices/{id}/declarations

per-device declaration state; filter required

ddm/report

tenant

declarations/{id}/devices

the same state per declaration, across devices

Compliance Benchmarks has a correct, documented path but returns 500 {"error":"Upstream host lookup failed"}. The gateway routes it and cannot reach its own backend. A fault on Jamf's side, not something a client can work around.

An earlier revision of this file claimed Classic, Declaration Reporting and Compliance Benchmarks were simply not exposed. That was wrong; see JPM-0006, which supersedes JPM-0005 and explains how the error happened.

Tools: getFleetOverview, findDevices, findOutdatedDevices, findDeviceGroups, getDeviceGroupMembers, findExpensiveAutomations, getInventoryCollectionSettings and findCriteriaReferences (compound), listBlueprints and getDeviceDeclarationState, getDeclarationScope, findObjectReferences and findGroupDependencies and getComputerGroup (typed), and platformRequest (authenticated GET-only passthrough to any gateway route). Tool count stays deliberately small (JPM-0003).

Write server: createRestrictedSoftware, updateRestrictedSoftware, and four scope tools (addComputerGroupToProfileScope, removeComputerGroupFromProfileScope, addComputerGroupToPolicyScope, removeComputerGroupFromPolicyScope, JPM-0009), and applyScopeMembershipBatch (JPM-0010), applyScopeChanges (JPM-0014), and createScript and createPolicy (JPM-0012), nothing else. The restricted-software read path is confirmed live against real entries, and updates are confirmed live (2026-11-04): Jamf accepted the XML body, which its pages do not publish, and the read-back verified. Create has not yet been called. The scope tools passed their first-use canary on 2026-11-05 (JPM-0009; see docs/gateway-reference.md): scope-only PUTs are accepted, leave everything else untouched, and did not redistribute a profile. The batch tool sends the same scope-only PUT, one per object. applyScopeChanges uses the same engine, but no computer or exclusion has yet been written with it live. The script and policy creates (JPM-0012) have not yet been called live either. Open work is tracked in docs/BACKLOG.md.

Pagination is confirmed live: a real page-1 request returned different records with hasPrevious: true and totalPages: 13, so page is 0-based as assumed and query parameters survive the passthrough.

device-actions remains unverified, because every route in it is a write and its scopes are never granted (JPM-0007, unchanged by JPM-0008).

Setup

npm install                    # also points core.hooksPath at .githooks
cp .env.op.example .env.op     # edit to match your 1Password vault/item
npm run build

Create an integration in Jamf Account → Integrations at the Platform environment level, choosing the environment that contains your Jamf Pro tenant. A read-only integration is sufficient and strongly preferred. The client secret is shown exactly once. The level cannot be changed later, and the legacy Tenant level cannot reach Blueprints.

Variable

Required

Notes

JAMF_CLIENT_ID

yes

from the integration

JAMF_CLIENT_SECRET

yes

shown once at creation

JAMF_ENVIRONMENT_ID

one of these two

Platform environment integration; sent as X-Environment-Id on every request

JAMF_TENANT_ID

one of these two

legacy Tenant integration; sent as X-Tenant-Id; cannot reach Blueprints

JAMF_GATEWAY_BASE_URL

no

defaults to https://us.api.jamfcloud.com

JAMF_TOKEN_URL

no

defaults to <base>/auth/token

JAMF_READ_ONLY

no

defaults to true; a backstop, not the guarantee

Write posture

A read-only integration (above) is the read server's supported configuration, not a starter mode to graduate from (JPM-0007). Writes live in a separate server under a separate credential (below). Scopes that can erase or unmanage a device are never granted to this server — not gated, not granted, in any configuration. That work belongs in Jamf Pro's own interface, where it is attributed to a named person and lands in Jamf's audit log.

JAMF_READ_ONLY above is a backstop, not the guarantee: it is on unless the value is the literal string false, so a typo fails closed. The real boundary is what the credential's scopes permit, which Jamf enforces, not this code. A fork that grants write scopes is making that decision, and owns what follows from it.

platformRequest offers no method or body parameter, so the passthrough cannot express a mutation at all, not even with write scopes granted. A passthrough write is unreviewable in a way a typed tool's write is not, since method, path and body would all be caller-composed with no schema constraining any of them. Every write is a named tool with a narrow schema, so the set of possible mutations stays enumerable by reading one file.

The write server

Reversible writes ship as a second server built from this repo, dist/write-server.js (JPM-0008). It registers only createRestrictedSoftware, updateRestrictedSoftware, the four scope-membership tools, applyScopeMembershipBatch, applyScopeChanges, createScript and createPolicy: no passthrough, no read tools, and no delete. The read server registers no write tools in any configuration.

  • Its own integration. A Platform environment integration named for its role (it is expected to grow), granted exactly what the write tools need. Today that is restricted-software:read, :create and :update, plus (JPM-0009) configuration-profiles:read and :update, policies:read and :update, and device-groups:read, plus (JPM-0012) policies:create, scripts:create, scripts:read and categories:read; never any :delete. By operator decision it also holds :create on configuration profiles and device groups, and device-groups:update, which no tool uses yet (JPM-0009). That was the state before JPM-0013, which fixes the complete set (below). Keep it in its own 1Password item, separate from the read integration, so the read server's credential can never write.

  • Its own env file, with JAMF_READ_ONLY=false. With the flag on, the server still starts and dry runs still work, but every real write refuses.

  • Registered per project, not globally. Register it only in the repository that holds your Jamf change log, so its tools appear only there. Local scope keeps the machine paths out of that repository; run this from inside it:

    claude mcp add -s local jamf-platform-write -- \
      op run --env-file=/absolute/path/to/.env.op.write -- \
      node /absolute/path/to/dist/write-server.js

    Consider an ask permission rule for mcp__jamf-platform-write in that repository's .claude/settings.local.json, so every write prompts even in accept-edits mode.

All write tools default to dryRun: true, which returns the exact XML and a field-by-field diff and writes nothing. A real write reads the entry back and reports any field Jamf stored differently, and returns rollback arguments. Scope is required on create and never defaults to all computers. An update changes only the fields passed and leaves scope alone unless a complete replacement is given. The scope tools take {id, computerGroupId, dryRun?}, send only the full <scope>, refuse anything they cannot round-trip, and report otherFieldsUnchanged from before/after hashes of everything but the scope. One difference is accepted: when Jamf regenerates the PayloadUUID and PayloadIdentifier of a profile's inner payloads and re-serialises the payload plist, and a semantic comparison shows nothing else changed (JPM-0011), otherFieldsUnchanged is still false but the result adds normalizedByJamf (a count) and otherFieldsSemanticallyUnchanged: true, and the object counts as verified. Any other difference still fails.

createScript and createPolicy (JPM-0012) create only. Every field is stated, unknown fields are rejected, and a name that already exists is refused. A policy is always created disabled (there is no enabled input), with an explicit scope of computer ids and computer group ids (never all computers; an empty scope only with emptyScopeIntended: true), and without packages. Script contents and every script parameter value are shown only as SHA-256 and length, in the dry run, the result, errors and logs. A live create reads the object back and compares every field it sent; a policy is also checked for anything it did not send (restart, commands, packages) being inert. Enabling a created policy is done in the Jamf console.

The complete permission set (JPM-0013 decision 8) is :read, :create and :update on nine resources: restricted-software, configuration-profiles, policies, scripts, device-groups, extension-attributes, categories, packages and advanced-device-searches (27 permissions); plus, granted ahead of any tool, 20 on patch policies, patch titles, apps, app package information, internal patch sources, advanced user searches, user extension attributes and user groups. No other permission is held. Never granted, on either integration: any :delete, any :execute, device secrets, device actions and MDM command queuing, enrollment invitations and webhooks; the write integration also never holds Devices, Users or Device history read. Holding a permission does not authorise a tool: a tool not listed in JPM-0013 needs its own record, and the ten tools above are still the whole write server until a phase of JPM-0013 builds more. The conventions test sweeps the write modules for the permanent exclusions (no DELETE or PATCH, no all-computers scope, no device actions, MDM, erase, unmanage, LAPS or recovery secrets).

applyScopeMembershipBatch takes 1 to 150 {kind, id, action, computerGroupId} operations (JPM-0010) so a rollout is reviewed and approved once. Its dry run (the default) validates every operation, returns a per-object before/after table and a planHash, or, if any operation is refused, every refusal and no hash. A live call must carry that planHash; it re-reads everything and writes nothing if any listed object or group changed since the dry run. Operations are grouped by object and each object gets one PUT with its final scope, read back and verified in order; the first failure stops the batch, except that an object Jamf only normalised (above) is marked written with the same two extra fields and the batch continues. The rollback is an inverse batch to be dry-run first. A PUT that Jamf answers with an HTTP error is never counted as written (JPM-0014): it is not read back, because reads have been seen to show a rejected change for minutes afterwards, and it is listed under rollback.notWritten rather than in the rollback's operations. A policy whose name another policy shares is refused, since Jamf has been seen to reject a scope PUT to one.

applyScopeChanges (JPM-0014) is the same engine for computers as well as computer groups, as targets or exclusions. Each operation states every field, and nothing defaults: {kind, id, action, member: "computerGroup", list: "include" | "exclude", computerGroupId} or {kind, id, action, member: "computer", list: "include" | "exclude", computerId}. The dry run gives before and after for every list touched, and the planHash covers member and list and every list of each object's live scope. On top of the batch's refusals it refuses the same member added to both the targets and the exclusions in one plan, and a change after which every target is also excluded. Computer ids are not checked before the write, because the write integration holds no device read permission (JPM-0013): confirm them with the read server first. To exclude one Mac from a profile: {"kind": "profile", "id": 12, "action": "add", "member": "computer", "list": "exclude", "computerId": 345}.

Credentials are injected at runtime so the secret never lands on disk:

op run --env-file=.env.op -- npm run dev

Register with Claude Code

claude mcp add jamf-platform -- node /absolute/path/to/dist/index.js

Register the read server globally if you like; it cannot write. The write server is registered per project (see above).

The read server's credential is bound by the same exclusions as the write server's (JPM-0013 decision 6). Because platformRequest issues any GET the credential allows, the credential is the only boundary for secrets: grant the read integration only the read permissions it needs, and never device secrets (lock PIN, Recovery lock password, FileVault recovery key, LAPS), enrollment invitations, or webhooks. The conventions test cannot see a credential, so this is held by the Jamf console and by a startup check if the gateway's token response lists scopes; that check is unverified.

Conventions

  • ISO dates (YYYY-MM-DD) everywhere, including in dated snapshots above.

  • ADRs are immutable once committed. Correct one by superseding it, never by editing. Enforced by scripts/check-adr-immutability.sh via the pre-commit hook; ADR_ALLOW_EDIT=1 covers the sanctioned exceptions. Prefix: JPM-.

  • Decisions vs findings. decisions/ holds decisions and is immutable. docs/gateway-reference.md holds observations about a beta API and is expected to change. Do not mix them.

  • Never git add -f. The ignore list is a data-handling boundary guarding the client secret and captured fleet data; a pre-commit hook enforces it.

  • Never commit a captured API response. Only type-only shapes (JPM-0004).

  • Confirm routes empirically. A Jamf docs section is not evidence a route exists. The documentation has been wrong about this gateway four times, each retraction recorded in docs/gateway-reference.md.

  • Commit messages explain why, and state explicitly when they retract an earlier conclusion. Descriptive imperative subjects; not Conventional Commits, which is why there is no badge claiming otherwise.

Versioning

SemVer 2.0.0. package.json is the single source of the version. Changes are recorded in CHANGELOG.md per Keep a Changelog. Releases are tagged vX.Y.Z.

While the gateway remains in public beta, minor versions may carry breaking changes, because the upstream contract offers no stability guarantee, so strict SemVer against it would be a false promise.

Testing

npm test              # vitest, 370 tests
npm run typecheck
DRY_RUN=1 ./scripts/discover-gateway.sh    # probe matrix (pre-move gateway shapes; see the script header)

To exercise a tool against a live tenant, from any directory:

scripts/jamf tools/list
scripts/jamf getFleetOverview
scripts/jamf findDevices '{"query":"MacBook"}'

scripts/jamf wraps op run with an absolute --env-file path, because op resolves that against the caller's cwd and fails with a bare "open .env.op: no such file or directory" otherwise. It also unsets OP_SERVICE_ACCOUNT_TOKEN, which the committed .envrc handles inside the repo but cannot outside it, and resolves symlinks so it can be linked onto PATH for a shorter handle:

ln -s "$PWD/scripts/jamf" ~/.local/bin/jamf-mcp
jamf-mcp getFleetOverview

Not npm run inspector under op run. The MCP Inspector spawns the server as a child process without forwarding the parent environment, so injected credentials never reach it and the server exits on config validation. Its -e flag would work but puts the client secret on a command line where ps can read it. scripts/call-tool.mjs spawns the server with the environment inherited, so credentials go straight to the process that needs them. Its output can contain live fleet data, so redirect to a gitignored path if you keep it.

Tests never reach the gateway: fetch is stubbed per test and credentials are fixtures. The suite is mutation-checked rather than assumed useful: each of these deliberate breakages causes failures: removing the totalCount pagination fallback, making paging 1-based, disabling the read-only guard, misclassifying iPads as Macs, treating an unparseable timestamp as a recent check-in, letting an empty search query match every device, and counting an absent managed flag as unmanaged.

The contribution contract

CONTRIBUTING.md is written as a contract, separating what a guard will stop you doing from what a human reviews. Three rules are mechanically enforced by a pre-commit hook and by CI:

Rule

Enforced by

No live identifiers in tracked files — including test fixtures

scripts/check-no-identifiers.sh

No captured API responses committed; never git add -f

.githooks/pre-commit

Committed ADRs are immutable — supersede, never edit (a Status-only superseded-by pointer is the one allowed edit)

scripts/check-adr-immutability.sh + src/adr-guard.ts in CI

src/conventions.test.ts additionally asserts the conventions that drifted during early development: the test-count badge matches reality, ADR numbering is sequential and fully indexed, every superseded record names its successor, and the README does not cite a superseded ADR as guidance.

Test UUIDs use the reserved deadbeef- prefix, so an identifier copied out of live output is visible rather than plausible. That rule exists because a real device id reached a test file exactly that way.

Pull request and review policy

Single maintainer at present, so changes land directly on main. On a second contributor: branch protection on main, one non-author approval, and decisions/ changes reviewed by someone other than the author.

Every change should pass npm test, npm run typecheck, and npm run build. Anything touching src/platform-client.ts should also be exercised against a live tenant, since no test can confirm the gateway's actual behaviour.

Cross-reference

License

MIT — see LICENSE.

Available Tools

15 tools
findCriteriaReferencesFind criteria referencesA

Search smart computer group criteria, advanced computer search criteria, and advanced search display fields for a term — e.g. "Home Directory" to find out whether anything consumes that inventory field before disabling its collection. Matches field names and criterion values, case-insensitively. Reports what it did NOT check, because "no references found" is a weaker claim than a hit.

Inputs: query (required), concurrency.

findDeviceGroupsFind device groupsA

Search device groups by name or description (case-insensitive substring), returning id, member count, deviceType and groupType. Covers both computer and mobile groups, smart and static, since the gateway returns them in one list.

Inputs: query (required), limit.

findDevicesFind devicesA

Search the fleet by serial number, device name, model, device id, or user id (case-insensitive substring). Spans macOS and iOS/iPadOS. Paginates the full device list and filters client-side, because the gateway has no confirmed server-side filter.

Inputs: query (required), limit.

findExpensiveAutomationsFind expensive automationsA

Audit Jamf scripts, computer extension attributes and policies for commands that burn CPU or battery when run repeatedly (du, find /, mdfind, system_profiler and similar), and report which policies run them and how often. Extension attributes are called out separately because they execute at EVERY inventory collection. Answers "what is cooking this laptop's battery". Read-only.

Inputs: concurrency, maxItemsPerKind, includeDisabledPolicies.

findGroupDependenciesFind smart group dependenciesA

Map which computer groups depend on which others, via "Computer Group" membership criteria. Reports dependency cycles as their actual node paths, references to group names that do not exist, and — given a group — its blast radius: everything that transitively changes when that group's membership changes, with depth. A "not member of" criterion is reported distinctly from "member of", since treating one as the other inverts the meaning. Groups whose detail could not be fetched are named, because a group absent from the graph must not read as independent.

Inputs: group, concurrency.

findObjectReferencesFind what references an objectA

Find everything that references a package, computer group or script — the check to run before deleting or changing one. Reports where each reference sits (scope, exclusion, script slot, group criterion) and distinguishes an EXCLUSION from an inclusion, since those mean opposite things. Names are matched exactly and case-insensitively, never as substrings. Critically, it reports which source kinds it could NOT check and what that means: a "clear" verdict requires full coverage, so most answers are partial-clear and must not be read as permission to delete. Coverage is in the strength field.

Inputs: kind (required), id, name, concurrency.

findOutdatedDevicesFind outdated devicesA

List devices whose OS major version is below a threshold, oldest first, with the freshest activity timestamp for each. Devices whose version is missing or unparseable are returned separately, because "unknown version" is a different finding from "old version". Spans macOS and iOS/iPadOS/tvOS.

Inputs: belowMajor (required), limit.

getComputerGroupGet computer groupA

Read a computer group's criteria in evaluation order, with parentheses and and/or joins preserved, plus a member count. Flags criteria that will not do what they appear to: an unanchored "matches regex" tests whether a value CONTAINS a match rather than equals one, which turns "has failures" into "is not blank". Accepts a group id or a name substring; an ambiguous name returns candidates. Members are NOT included unless asked for, since the roster carries serials and MAC addresses and is rarely the question.

Inputs: group (required), memberLimit, includeMembers.

getDeclarationScopeGet declaration scopeA

Report every device reporting a given DDM declaration, with its status, validity and — for failures — the reasons Jamf gives, grouped so one cause affecting forty Macs reads as one problem rather than forty. Devices are resolved to names and serials, since the API returns bare UUIDs. The inverse of getDeviceDeclarationState. NOTE: Jamf excludes PENDING declarations from any filtered read and a filter is required, so devices still awaiting delivery are invisible — an all-healthy answer is NOT proof of full deployment. See excludedFromThisAnswer in the result.

Inputs: declaration (required), filter.

getDeviceDeclarationStateGet device declaration stateA

Report the declarative device management (DDM) state for one device: which declarations are applied, their status and validity, and — for anything that failed — the reasons Jamf gives. The companion to listBlueprints, since a Blueprint deploys declarations and this says whether they landed. Accepts a device UUID, or a substring of a name, serial, model or user; an ambiguous substring returns candidates rather than guessing. NOTE: Jamf excludes PENDING declarations from any filtered read, so a device mid-deployment will look emptier than it is — see excludedFromThisAnswer in the result.

Inputs: device (required), filter, includeChannels.

getDeviceGroupMembersGet device group membersA

List the devices in a device group, resolved to names, serials, platform and last-seen time. Accepts a group UUID or a name substring; an ambiguous name returns the candidate groups rather than guessing. Member ids with no matching device are reported separately, since a membership pointing at an absent device is itself worth knowing.

Inputs: group (required), limit.

getFleetOverviewFleet overviewA

One-call fleet summary: device counts by platform and OS major, managed vs unmanaged, stale check-ins, device-group breakdown, and blueprint deployment states. Fetches devices, device groups and blueprints concurrently. NOTE the device total spans macOS AND iOS/iPadOS — it is not a Mac count. Sections that fail are reported individually rather than failing the whole call.

Inputs: topGroups, staleThresholdDays.

getInventoryCollectionSettingsInventory collection settingsA

Read the tenant computer inventory collection settings and rate each option by how much work it adds per collection. Flags home_directory_sizes as high cost because Jamf computes it by running du across every user home directory — the usual cause of a du process under JamfDaemon burning battery. Pair with findExpensiveAutomations, which shows how often inventory is actually triggered.

Inputs: no named parameters.

listBlueprintsList blueprintsA

List Blueprints for the configured tenant. Requires the read:pro:blueprints scope — note the scope prefix is "pro" while the URL service segment is "blueprints".

Inputs: no named parameters.

platformRequestJamf Platform API requestA

Make an authenticated request against any Jamf Platform API Gateway endpoint. The gateway also fronts the Jamf Pro API (300+ endpoints) and Jamf Pro Classic API (500+), so this reaches essentially the whole Jamf surface. Shapes: style "tenant" (default) builds /{version}/tenant/{tenantId}/{resource}; style "flat" omits the tenant segment and has never returned 200; rawPath is used verbatim after /api/{service}. For Classic use service "proclassic" with style "classic", which builds /tenant/{tenantId}/{resource} — no version segment, tenant filled in automatically, and no /JSSResource/ prefix, which does not exist on the gateway. The service segment may be more than one segment: Declaration Reporting is "ddm/report". Jamf Pro versions are per-resource (account-groups v1, enrollment v3, computers-inventory v4) — do not assume v1. READ-ONLY BY DESIGN: this tool issues GET and nothing else, and offers no method or body parameter. Writes go through named typed tools with narrow schemas, never through the passthrough, because a passthrough write is unreviewable — method, path and body would all be composed by the caller with nothing to constrain them. See JPM-0007.

Inputs: service (required), query, style, rawPath, +2 more.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 15 tools

    Disambiguation5/5

    Each tool targets a distinct resource and action: device search, group search, DDM state, scope, references, dependencies, etc. Even the two declaration tools are clear inverses, and the passthrough is explicitly read-only, so there is no ambiguity about which tool to select.

    Naming Consistency4/5

    Tool names are consistently camelCase and mostly follow a verb+noun pattern, but the verbs vary (list, get, find) and one tool (platformRequest) breaks the pattern. This is a minor deviation, not chaotic, and the meaning of each verb is reasonably intuitive.

    Tool Count5/5

    15 tools is well-scoped for a broad platform server. Each tool covers a meaningful slice of the Jamf surface, and the count feels neither thin nor bloated.

    Completeness2/5

    The server is read-only by design — there are no create, update, or delete tools, and the generic passthrough explicitly refuses writes. This leaves a critical gap for a management platform: agents can inspect the entire fleet but cannot perform any management action, which will cause failures for any workflow requiring a change.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      A
      quality
      C
      maintenance
      An MCP server that connects AI assistants to the NinjaOne remote monitoring and management platform via the REST API v2. It provides tools for device inventory, organization management, alert handling, maintenance scheduling, and automated job execution.
      22
      1
      -
    • A
      license
      A
      quality
      D
      maintenance
      Read-only MCP server that allows AI assistants to query and monitor KVM Fleet devices, audit logs, and console sessions through the official REST API.
      5
      8 npm
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An async MCP server for Jamf Pro integration, providing AI assistants with tools for computer health analysis, inventory management, and policy monitoring.
      8
      Apache 2.0