Model Context Protocol server enabling AI assistants (Claude, ChatGPT) to manage Jamf Pro through natural language. Search devices, deploy policies, execute scripts, manage profiles, and generate compliance reports using conversational queries.
星數
39
工具
—
可用率
—
A comprehensive MCP (Model Context Protocol) server that enables AI assistants to interact with Jamf Pro for complete Apple device management. Works with Claude Desktop and ChatGPT (via MCP Connectors).
Two modes: Classic Mode (115 individual tools) or Code Mode (2 tools + sandboxed JavaScript SDK)
What's New in v2.2
Code Mode — a new execution model that exposes just 2 MCP tools (jamf_search + jamf_execute) instead of 115 individual tools. The agent writes JavaScript that runs in a sandboxed node:vm context with a typed Jamf API client, enabling complex multi-step workflows in a single tool call. Includes capability-based access control, budget tracking, plan/apply workflow, and an approval gate for high-impact commands.
Concurrency limiting — semaphore-style ConcurrencyLimiter (default 5, configurable via JAMF_MAX_CONCURRENCY) prevents 429 rate-limit errors. Applied to both the core API client and Code Mode sandbox.
Policy caching — getPolicyDetails results are now cached to avoid redundant API calls, with automatic invalidation on policy writes.
Static computer group XML fix — createStaticComputerGroup and updateStaticComputerGroup now use proper XML via XmlBuilder (with escaping) instead of broken JSON or raw template literals.
What's in v2.1
115 tools (up from 56) — expanded coverage across the full Jamf Pro API and Classic API
12 resources — all returning live data including compliance, storage, OS versions, encryption, and patch reports
12 workflow prompts — guided templates for common admin tasks like onboarding, offboarding, security audits, and staged rollouts
Compound tools — single-call operations like getFleetOverview, getDeviceFullProfile, getSecurityPosture, and getPolicyAnalysis that combine multiple API calls behind the scenes
Bearer Token authentication on Classic API — full OAuth2 Client Credentials support without needing a username/password
Parallel API calls — batch operations and compound tools run requests concurrently for faster results
Correct Jamf terminology — all documentation and tool descriptions align with official Jamf developer documentation
Quick Start
For Claude Desktop Users
git clone https://github.com/dbankscard/jamf-mcp-server.git
cd jamf-mcp-server
npm install
npm run build
Configure your credentials in Claude Desktop (see Configuration below).
For ChatGPT Users
git clone https://github.com/dbankscard/jamf-mcp-server.git
cd jamf-mcp-server
./chatgpt/start-chatgpt-poc.sh
Code Mode replaces 115 individual MCP tools with just 2:
Tool
Purpose
jamf_search
Discover API methods — search by keyword, browse by category, view signatures and required capabilities
jamf_execute
Run JavaScript in a sandboxed VM with access to the full Jamf API client
Why Code Mode? This implementation is inspired by Cloudflare's Code Mode pattern, which addresses a fundamental tension in MCP: agents need many tools to do useful work, but every tool definition consumes context window tokens. Cloudflare found that exposing their full API as individual MCP tools would consume over 1 million tokens — more than the entire context window of most models. Their solution: collapse everything into a search + execute pattern where agents discover APIs on demand and write code against a typed SDK, reducing token usage by up to 99.9%.
We applied the same pattern to Jamf Pro. Our 115 Classic Mode tools consume ~14,000 tokens of tool definitions. Code Mode reduces that to ~500 tokens (2 tool definitions) while retaining access to the full API surface. The agent uses jamf_search to discover methods, then writes JavaScript that runs in a sandboxed node:vm context. This also enables multi-step workflows in a single tool call — chaining API calls, filtering results, and building reports without LLM round-trips between each step.
Safety features:
Plan/Apply workflow — run with mode: "plan" to preview all writes without executing, then mode: "apply" to commit
Capability-based access — declare only the permissions your code needs (read:computers, write:policies, command:mdm, etc.)
// Find all computers not checked in for 30 days
const computers = await jamf.getAllComputers(200);
const stale = computers.filter(c => helpers.daysSince(c.lastContactTime) > 30);
log(`Found ${stale.length} stale computers`);
return stale.map(c => ({ id: c.id, name: c.name, lastContact: c.lastContactTime }));
Code Mode vs Classic Mode Benchmark
Real numbers from a live Jamf Pro instance (npm run benchmark):
Tool Definition Overhead
Every conversation loads all tool definitions into the LLM's context window. Fewer tools = more room for actual work.
Mode
Tools
Def. Size (bytes)
Est. Tokens
Classic
115
55,639
13,910
Code
2
1,963
491
Code Mode uses 28x fewer tokens just for tool definitions.
Scenario Results
10 scenarios covering baseline parity, cross-domain joins, multi-source audits, and workflows that are impossible in Classic Mode:
#
Scenario
Mode
LLM Trips
Time (ms)
Completable
1
Single device lookup
classic
1
308
Yes
1
Single device lookup
code
1
241
Yes
2
Device profile + policy logs
classic
1
276
Yes
2
Device profile + policy logs
code
1
228
Yes
3
Orphaned scripts audit
classic
2
131
Yes
3
Orphaned scripts audit
code
1
172
Yes
4
Policies targeting a group
classic
2
133
Yes
4
Policies targeting a group
code
1
2,611
Yes
5
OS version by department
classic
N/A
N/A
No
5
OS version by department
code
1
1,073
Yes
6
Full security audit
classic
4
62,945
Yes
6
Full security audit
code
1
6,936
Yes
7
Policy comparison
classic
2
221
Yes
7
Policy comparison
code
1
115
Yes
8
Stale devices + details (top 10)
classic
1
1,017
Yes
8
Stale devices + details (top 10)
code
1
4
Yes
9
Package dependency audit
classic
1
15,639
Yes
9
Package dependency audit
code
1
15,015
Yes
10
Group + FileVault + OS filter
classic
N/A
N/A
No
10
Group + FileVault + OS filter
code
1
187
Yes
Code Mode: 10/10 completable. Classic Mode: 8/10.
Key takeaways:
Tool definition overhead: Classic Mode consumes ~14K tokens of context window just for tool definitions — before any work begins. Code Mode uses ~500 tokens.
Impossible workflows: Scenarios 5 and 10 require cross-resource joins (OS version × department, group members × FileVault × OS filter) that Classic Mode simply cannot express in bounded tool calls.
Multi-step workflows: Security audit (S6) drops from 4 sequential LLM round-trips to 1. Policy comparison (S7) drops from 2 to 1. Each saved round-trip eliminates seconds of LLM inference latency.
Cross-domain joins: Orphaned scripts (S3), group-scoped policies (S4), and package dependencies (S9) each require fetching a list, then detail-fetching N items — a pattern that forces Classic Mode into N sequential LLM calls. Code Mode does it in 1.
Simple lookups: Roughly equivalent. Classic's purpose-built tools have slightly less overhead for single-call operations.
Scaling note: These results are from a small Jamf instance. On a production fleet with hundreds of policies and devices, Classic Mode trip counts for S3/S4/S8/S9 would reach 10–20+, pushing the average LLM round-trip reduction well above 80%.
Run the benchmark yourself:
npm run benchmark # all 10 scenarios
npm run benchmark -- --scenarios 1,5,10 # run a subset
# requires JAMF_URL, JAMF_CLIENT_ID, JAMF_CLIENT_SECRET
Classic Mode (115 Tools)
What You Can Do
Ask natural language questions about your Jamf fleet:
"How is my fleet doing?" — uses getFleetOverview for a single-call summary
"Tell me about LAPTOP-001" — uses getDeviceFullProfile to resolve by name, serial, or ID
"What's our security posture?" — uses getSecurityPosture for encryption and compliance analysis
"How is the Software Install policy performing?" — uses getPolicyAnalysis with auto-resolve by name
"Find all devices that haven't checked in for 30 days"
"Deploy software updates to the marketing team"
"Retrieve the LAPS password for this device"
"Show me patch compliance across the fleet"
Tools (115)
Compound Tools (Start Here)
These combine multiple API calls into a single operation:
getFleetOverview: Comprehensive fleet summary — inventory counts, compliance rates, and mobile device status in one call
getDeviceFullProfile: Complete device profile by name, serial, or ID — resolves automatically and fetches details, policy logs, and history in parallel
getSecurityPosture: Fleet security analysis — FileVault encryption rates, compliance status, and OS version currency
getPolicyAnalysis: Policy analysis by ID or name — configuration, scope, compliance, and performance
Device Management
searchDevices: Find devices by name, serial number, IP address, or username
getDeviceDetails: Detailed device information by ID
checkDeviceCompliance: Find devices that haven't reported in X days
getDevicesBatch: Get details for multiple devices in a single request
updateInventory: Force inventory update on a device
Computer History & MDM Commands
getComputerHistory: Full computer history — policy logs, MDM commands, audit events, screen sharing, user/location changes
getComputerPolicyLogs: Policy execution logs showing success/failure per device
getComputerMDMCommandHistory: MDM command history with status and timestamps
Update access for inventory updates, policies, scripts, extension attributes
Execute access for policies, scripts, and MDM commands
For read-only mode:
Read access to all resources only
Architecture
┌─ Classic Mode (110 tools) ──┐
Claude Desktop ──> │ MCP Server (stdio) │──> Jamf Pro API
├─ Code Mode (2 tools) ────────┤
│ jamf_search + jamf_execute │──> (sandboxed VM) ──> Jamf Pro API
└──────────────────────────────┘
ChatGPT ──> Tunnel (Cloudflare) ──> MCP Server (HTTP) ──> Jamf Pro API
The server uses a hybrid API client that supports both the Jamf Pro API and Classic API, with automatic fallback between them for maximum compatibility across Jamf Pro versions. All API calls pass through a concurrency limiter to prevent rate-limit errors.
Troubleshooting
Authentication Issues
Verify your API credentials (Client ID and Secret)
Ensure the API client has the required permissions
For Classic API endpoints, the server automatically uses Bearer Token authentication
503 Errors on Classic API
If using Client Credentials only (no username/password), ensure you're running v2.1+ which supports Bearer Token authentication on Classic API endpoints
Timeouts on Compound Tools
The default request timeout is 30 seconds
Compound tools like getFleetOverview make parallel API calls and may need more time on slower instances
Built with ❤️ for the Jamf, Claude, and ChatGPT communities
J
Jamf
dbankscard·39 顆星·
Model Context Protocol server enabling AI assistants (Claude, ChatGPT) to manage Jamf Pro through natural language. Search devices, deploy policies, execute scripts, manage profiles, and generate co
Model Context Protocol server enabling AI assistants (Claude, ChatGPT) to manage Jamf Pro through natural language. Search devices, deploy policies, execute scripts, manage profiles, and generate compliance reports using conversational queries.
上次檢查時間:2026-10-27。 Model Context Protocol server enabling AI assistants (Claude, ChatGPT) to manage Jamf Pro through natural language. Search devices, deploy policies, execute scripts, manage profiles, and generate compliance reports using conversational queries.