What can you do with this server?

Enables AI assistants to search, retrieve, and navigate official Jamf documentation. * Search docs across 28 Jamf products with filters (product, topic, docType, version, language) and pagination * Retrieve full articles as markdown/JSON with section extraction, summary-only previews, and token limits * List supported products, publications, topics, and document type filters * Fetch tables of contents for any product or publication * Batch-fetch up to 10 articles in a single call * Look up Jamf glossary terms with fuzzy matching * Access MCP resources (product lists, topics, per-product TOC/version templates) * Use guided prompt workflows for troubleshooting, setup guides, and version comparison

How do I use Jamf Docs MCP Server?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Jamf Docs MCP Server How do I configure SSO in Jamf Pro?" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Jamf Docs MCP Server

by GET-Technology-Inc

Overview Schema Source Related Servers Discussions Admin

TypeScript

Remote

Jamf Docs MCP Server

npm version License: MIT

An MCP server that gives AI assistants (Claude, Cursor, etc.) direct access to Jamf official documentation. Ask Jamf-related questions and get answers based on the latest docs from learn.jamf.com.

Supported Products (28): Jamf Pro, Jamf School, Jamf Connect, Jamf Protect, Jamf Now, Jamf Safe Internet, Jamf Insights, RapidIdentity, Jamf Trust, Jamf Routines, Self Service+, Jamf App Catalog, Jamf Account, Jamf Security Cloud, Elevate, Composer, Jamf Parent, Jamf Teacher, Jamf Setup and Reset, Jamf Assessment, Title Editor, Jamf Infrastructure Manager, Jamf AD CS Connector, Jamf PKI Proxy, Jamf Migrate, Jamf Remote Assist, Jamf Cloud Distribution Service, Healthcare Listener

中文文件

Installation

@modelcontextprotocol/server is a peer dependency, and the CLI imports it at startup (dist/index.js → @modelcontextprotocol/server/stdio). If it is missing from the install tree the process exits immediately with ERR_MODULE_NOT_FOUND — the install itself succeeds, so the failure only shows up when you run the server.

Most install paths bring it in automatically:

Install method	Peer installed
`npx -y @get-technology-inc/jamf-docs-mcp-server`	Yes
`npm install` (npm 7+, default settings)	Yes
`pnpm add` (pnpm 10)	Yes
`npm install --legacy-peer-deps`	No
Yarn 1 (classic)	No

If you use one of the last two — or if you are vendoring the package — install the SDK alongside it:

npm install @get-technology-inc/jamf-docs-mcp-server @modelcontextprotocol/server@^2

Why it is a peer dependency, not a regular one. This package hands McpServer instances to its consumers, and those consumers pass them to createMcpHandler from their own SDK copy. If the two resolve to different copies of the SDK, an instance built by one module's Protocol is inspected by another's, and every 2026-07-28 request fails with Cannot read properties of undefined (reading 'includes') — an HTTP 500 with no useful diagnostic. Declaring the SDK as a peer states the single-copy requirement instead of relying on the consumer's tree happening to hoist it; listing it under dependencies as well would reintroduce exactly the duplicate it exists to prevent.

Node.js 20 or newer is required.

Related MCP server: Apple Dev MCP Server

Quick Start

Claude Desktop

Edit claude_desktop_config.json:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "jamf-docs": {
      "command": "npx",
      "args": ["-y", "@get-technology-inc/jamf-docs-mcp-server"]
    }
  }
}

Restart Claude Desktop to apply.

Claude Code (CLI)

claude mcp add jamf-docs -- npx -y @get-technology-inc/jamf-docs-mcp-server

Cursor

Edit ~/.cursor/mcp.json:

{
  "mcpServers": {
    "jamf-docs": {
      "command": "npx",
      "args": ["-y", "@get-technology-inc/jamf-docs-mcp-server"]
    }
  }
}

Verify Installation

Test with MCP Inspector:

npx @modelcontextprotocol/inspector npx -y @get-technology-inc/jamf-docs-mcp-server

Usage Examples

Once configured, just ask your AI assistant:

"How do I configure SSO in Jamf Pro?"
"What are the system requirements for Jamf Protect?"
"Explain the MDM enrollment process"
"What changed in the latest Jamf Connect release notes?"

Available Tools

Tool	Description
`jamf_docs_list_products`	List all supported products, topics, and document type filters
`jamf_docs_search`	Search documentation by keyword with filtering and pagination
`jamf_docs_get_article`	Retrieve full content of a specific documentation article
`jamf_docs_get_toc`	Browse the table of contents for a product or any single publication
`jamf_docs_batch_get_articles`	Fetch multiple articles in one call (up to 10 URLs)
`jamf_docs_glossary_lookup`	Look up Jamf terminology and definitions (fuzzy matching)

jamf_docs_list_products

Returns all available Jamf products and their IDs, available topic filters, and document type filters.

Parameter	Type	Default	Description
`language`	string	`en-US`	Documentation language/locale
`outputMode`	`"full"` \| `"compact"`	`"full"`	Detail level of the response
`responseFormat`	`"markdown"` \| `"json"`	`"markdown"`	Output format
`maxTokens`	number (100–20000)	`5000`	Maximum tokens in response

jamf_docs_search

Searches across all Jamf product documentation.

Parameter	Type	Default	Description
`query`	string (2–200 chars)	required	Search keywords
`product`	string	—	Filter by product ID (e.g., `jamf-pro`)
`topic`	string	—	Filter by topic category (e.g., `enrollment`, `security`)
`docType`	string	—	Filter by document type: `documentation`, `release-notes`, `training`, `solution-guide`, `glossary`, `getting-started`
`version`	string	—	Filter by version (e.g., `"11.5.0"`)
`language`	string	`en-US`	Documentation language/locale
`limit`	number (1–50)	`10`	Results per page
`page`	number (1–100)	`1`	Page number for pagination
`maxTokens`	number (100–20000)	`5000`	Maximum tokens in response
`outputMode`	`"full"` \| `"compact"`	`"full"`	Detail level; use `"compact"` for token-efficient output
`responseFormat`	`"markdown"` \| `"json"`	`"markdown"`	Output format

jamf_docs_get_article

Fetches and converts a documentation article to clean markdown or JSON.

Parameter	Type	Default	Description
`url`	string	required	Full URL from `docs.jamf.com` or `learn.jamf.com`
`section`	string	—	Extract only a named section (e.g., `"Prerequisites"`)
`summaryOnly`	boolean	`false`	Return only article outline — token-efficient way to preview before fetching full content
`includeRelated`	boolean	`false`	Include links to related articles
`language`	string	`en-US`	Documentation language/locale
`maxTokens`	number (100–20000)	`5000`	Maximum tokens in response
`outputMode`	`"full"` \| `"compact"`	`"full"`	Detail level; `"compact"` shows a ~500-token preview with available sections list
`responseFormat`	`"markdown"` \| `"json"`	`"markdown"`	Output format

When content exceeds maxTokens, the tool truncates the response and lists all available sections with their token counts. Use the section parameter on a follow-up call to retrieve a specific part.

jamf_docs_get_toc

Retrieves the navigation structure (table of contents) for a product.

Parameter	Type	Default	Description
`product`	string	required	Product ID (see supported products below)
`version`	string	latest	Specific version to fetch
`language`	string	`en-US`	Documentation language/locale
`page`	number (1–100)	`1`	Page number for paginated TOC
`maxTokens`	number (100–20000)	`5000`	Maximum tokens in response
`outputMode`	`"full"` \| `"compact"`	`"full"`	Use `"compact"` for a flat list without nested children
`responseFormat`	`"markdown"` \| `"json"`	`"markdown"`	Output format

jamf_docs_batch_get_articles

Fetches multiple documentation articles in a single call. Each URL is fetched concurrently, and invalid domains are reported as per-article errors without failing the entire batch.

Parameter	Type	Default	Description
`urls`	string[] (1–10)	required	Array of Jamf documentation URLs
`concurrency`	number (1–5)	`3`	Maximum parallel requests
`language`	string	`en-US`	Documentation language/locale
`maxTokens`	number (100–20000)	`5000`	Total token budget across all articles
`outputMode`	`"full"` \| `"compact"`	`"full"`	Detail level per article
`responseFormat`	`"markdown"` \| `"json"`	`"markdown"`	Output format

jamf_docs_glossary_lookup

Looks up a term in the Jamf official glossary and returns matching definitions using fuzzy matching. Glossary content is currently English-only; non-English language values are accepted but results will be in English.

Parameter	Type	Default	Description
`term`	string (2–100 chars)	required	Glossary term to look up
`product`	string	—	Filter by product ID
`language`	string	`en-US`	Documentation language/locale (glossary is English-only)
`maxTokens`	number (100–50000)	`5000`	Maximum tokens in response
`outputMode`	`"full"` \| `"compact"`	`"full"`	Detail level
`responseFormat`	`"markdown"` \| `"json"`	`"markdown"`	Output format

MCP Resources

Static and dynamic reference data accessible without tool calls:

Resource	URI	Description
Products list	`jamf://products`	All available Jamf products with IDs and version info (fetched dynamically from API)
Topics list	`jamf://topics`	Topic categories for filtering documentation searches
Product TOC	`jamf://products/{productId}/toc`	Table of contents for a specific product (template resource)
Product versions	`jamf://products/{productId}/versions`	Available documentation versions for a specific product (template resource)

Template resources support tab-completion on productId in compatible clients.

MCP Prompts

Pre-built prompt workflows that guide the AI through multi-step documentation tasks:

`jamf_troubleshoot`

Guides the AI through a structured troubleshooting workflow: searching for relevant documentation, previewing articles with summaryOnly, then providing a root-cause diagnosis and step-by-step resolution.

Argument	Type	Description
`problem`	string (required)	Description of the issue to troubleshoot
`product`	string (optional)	Jamf product ID to scope the search

`jamf_setup_guide`

Directs the AI to generate a step-by-step setup guide for a Jamf feature, including prerequisites, configuration steps, and verification.

Argument	Type	Description
`feature`	string (required)	The feature or capability to set up
`product`	string (optional)	Jamf product ID to scope the search

`jamf_compare_versions`

Instructs the AI to compare table-of-contents structures and key articles between two product versions, summarizing new features, removed capabilities, and migration considerations.

Argument	Type	Description
`product`	string (required)	Jamf product ID
`version_a`	string (required)	First version to compare (e.g., `"11.5.0"`)
`version_b`	string (required)	Second version to compare (e.g., `"11.12.0"`)

Supported Products

Product ID	Name	Description
`jamf-pro`	Jamf Pro	Apple device management for enterprise
`jamf-school`	Jamf School	Apple device management for education
`jamf-connect`	Jamf Connect	Identity and access management
`jamf-protect`	Jamf Protect	Endpoint security for Apple
`jamf-now`	Jamf Now	Simple Apple device management for small businesses
`jamf-safe-internet`	Jamf Safe Internet	Content filtering and web security for education and business
`jamf-insights`	Jamf Insights	Analytics and reporting platform for Apple fleet
`jamf-rapididentity`	RapidIdentity	Identity and access management platform
`jamf-trust`	Jamf Trust	Zero-trust network access for Apple devices
`jamf-routines`	Jamf Routines	Automated workflow orchestration for device management
`self-service-plus`	Self Service+	Next-generation self-service portal for macOS and mobile
`jamf-app-catalog`	Jamf App Catalog	Curated application catalog for managed deployments
`jamf-account`	Jamf Account	Identity, licensing, and platform services portal
`jamf-security-cloud`	Jamf Security Cloud	Cloud security portal for Jamf Connect and Jamf Protect
`elevate`	Elevate	Guided remediation and device health portal
`composer`	Composer	macOS package building and editing
`jamf-parent`	Jamf Parent	Parental device controls for school-issued devices
`jamf-teacher`	Jamf Teacher	Classroom device management for teachers
`jamf-setup-reset`	Jamf Setup and Reset	Device personalisation and wipe-and-reprovision apps
`jamf-assessment`	Jamf Assessment	Locked-down assessment mode for education devices
`title-editor`	Title Editor	Custom software title patch definitions
`jamf-infrastructure-manager`	Jamf Infrastructure Manager	On-premises proxy for LDAP and other internal services
`jamf-adcs-connector`	Jamf AD CS Connector	Certificate issuance via Active Directory Certificate Services
`jamf-pki-proxy`	Jamf PKI Proxy	Proxy for certificate authorities behind a firewall
`jamf-migrate`	Jamf Migrate	Migrating macOS devices between Jamf Pro instances
`jamf-remote-assist`	Jamf Remote Assist	Remote screen sharing and support sessions
`jamf-cloud-distribution-service`	Jamf Cloud Distribution Service	Jamf-hosted package distribution (JCDS)
`healthcare-listener`	Healthcare Listener	Integration with healthcare information systems

Key Features

Compact Mode: Use outputMode: "compact" for token-efficient responses; articles show a ~500-token preview with an available sections list
Summary Only: Use summaryOnly: true on jamf_docs_get_article to preview an article outline before fetching full content
Section Extraction: Use section: "Prerequisites" to retrieve only the part of an article you need
Batch Fetching: Use jamf_docs_batch_get_articles to fetch up to 10 articles in one call with concurrent requests
Glossary Lookup: Use jamf_docs_glossary_lookup to look up Jamf terminology with fuzzy matching
Multi-language: All tools accept a language parameter for localized documentation (e.g., ja-JP, de-DE)
Document Type Filter: Use docType on jamf_docs_search to narrow results to documentation, release-notes, training, solution-guide, glossary, or getting-started
Version Query: Use the version parameter to query documentation for a specific product version
Pagination: Search results support page and limit; table of contents supports page; product lists are not paginated
Search Suggestions: Receive helpful suggestions when a search returns no results
Token Management: All tools accept a maxTokens parameter (100–20000, default 5000) to control response size

MCP Apps (interactive viewer)

Hosts that negotiate the MCP Apps extension (io.modelcontextprotocol/ui) render jamf_docs_search, jamf_docs_get_toc and jamf_docs_get_article results as an interactive viewer instead of plain markdown: search hits are clickable through to the article, TOC entries open in place, and articles carry section navigation and a back stack. All three tools reference one self-contained ui:// resource, whose URI carries a hash of the bundle it names (ui://jamf-docs/app-<hash>.html). Hosts that do not negotiate the extension ignore the metadata and get exactly the markdown they always did.

The resource is served with a 24-hour public cache hint, which is safe precisely because the URI is content-addressed: a given URI names one exact bundle forever, and a new bundle arrives under a new URI rather than replacing an old one. Hosts pick up a changed viewer on their next tools/list refresh.

Design

The viewer paints no background and owns no colour. It reads the host's theme, design tokens and fonts out of hostContext (applyDocumentTheme, applyHostStyleVariables, applyHostFonts) and builds every rule from those, so the panel is a piece of the host's surface rather than a web page embedded in one. app-ui/styles.ts carries a :root fallback for each token, because hosts may send any subset of the 76 style variables.

Before 5.10 it did the opposite: a hardcoded palette with a prefers-color-scheme dark block. That media query reports the operating system, not the host — so a user running Claude in dark mode on a light OS got a white slab in a dark conversation, and no tuning of the greys could fix it.

Inline and fullscreen

The two display modes render different things, because Claude's design guidelines make them different surfaces. An inline card is a compact summary that fits its own content; fullscreen is where a documentation browser lives.

	Inline	Fullscreen
Search hits	3	the page
Table-of-contents rows	8	the page
Article prose	3 blocks, stopping before any table or code block	whole
Breadcrumbs, Back, parent link	—	✓
Section rail, neighbour list	—	✓
Type-ahead filter, paging	—	✓
Actions	1	as needed

Opening a result from an inline panel sends ui/request-display-mode before the tools/call, so the article arrives in the mode built for it. A host that declines, or that offers no fullscreen, still gets the article in place.

Two documented constraints drive this.

Inline apps must not scroll internally. On a touch device the conversation view owns vertical panning, so a vertical gesture starting inside an inline app is handed to the conversation — an internal scroll container does not scroll at all, and everything past the host's cap becomes unreachable rather than below the fold. Bounding what is rendered instead keeps search at ~518px, the table of contents at ~373px and an article at ~554px, all fully visible.

Inline apps must not drill in. "Drill-ins, breadcrumbs, or multiple views" are named patterns to avoid, which is why every piece of navigation chrome above is fullscreen-only.

The article preview is counted in blocks rather than characters. A character budget does not predict height: 900 characters of prose is three short paragraphs, and 900 characters containing a settings table is 700px of panel.

Style variables in app-ui/styles.ts are transcribed from the same guidelines.

jamf_docs_get_article publishes navigation — parent, siblings, children, and the true totals alongside the (capped) lists.

This matters more than it sounds. Fluid Topics serves one topic per API call while learn.jamf.com concatenates a topic and its children into a single page, so every <h2> a reader sees on the site is a separate topic here — verified at 9 of 9 on "Computer Configuration Profiles", whose API payload contains zero heading tags of any level. Without navigation, a client showing that page has the introduction and no route to the nine procedures the page consists of on the website. The viewer renders them as In this section.

It is derived from the map's TOC index, which the breadcrumb lookup already fetches and caches, so an article pays no extra request for it.

Developing the viewer

npm run dev:app-ui     # http://127.0.0.1:5173 — edit app-ui/*.ts, the frame reloads

app-ui/dev/harness.ts is a local MCP Apps host built on the SDK's AppBridge, which accepts Client | null — a host with no server behind it is a supported mode. It speaks the real protocol to the real App class and answers tools/call out of app-ui/dev/fixtures.json, real structuredContent captured from the live tools by npm run fixtures:app-ui.

It exists because the viewer only runs inside a host, so there is nothing to look at without one, and the alternative loop — build, launch the Inspector, click through — is tens of seconds per edit. It also does three things no inspector can: strip hostContext.styles entirely (the check that proves the :root fallbacks are coherent as a set), resize the container continuously across the @container breakpoints, and lie about deviceCapabilities.hover.

Before shipping, run the viewer through the real thing as well — it is the only place the actual ui:// resource, CSP and _meta are exercised:

npm run build && npm run test:inspector

WARNING

The MCP Apps viewer is broken in 4.0.0 — upgrade past it. The build step that inlines the UI bundle into the HTML document used a replacement string, so every $ pattern in the minified JavaScript was expanded instead of copied. The document that shipped is not parseable JavaScript, and a host that renders it gets SyntaxError: missing ) after argument list and a blank panel. Nothing else in 4.0.0 is affected — tools, resources and prompts return the same results either way, since a host that cannot render the app falls back to the markdown. Fixed in 4.0.1.

4.0.1 alone did not reach every host. Up to and including 4.0.1 the resource lived at a fixed ui://jamf-docs/app.html with a 24-hour public cache hint, so a host that had read the broken 4.0.0 bundle kept serving it from cache for up to a day after the server was upgraded — the corrected bundle was published under the same URI and never fetched. Upgrading past 4.0.1 fixes the distribution as well as the bundle: the URI now changes with the content, so a host holding the 4.0.0 copy simply stops asking for it. No manual cache clearing is needed, and the remaining delay is the one-hour tools/list hint rather than 24 hours.

HTTP/SSE Transport Mode

In addition to the default stdio transport, the server supports an HTTP transport for use as a remote or shared MCP endpoint.

Starting the HTTP Server

# Using the npm script (defaults: localhost:3000)
npm run start:http

# Using the built binary directly with custom options
node dist/index.js --transport http --port 8080 --host 127.0.0.1

CLI Arguments

Argument	Default	Description
`--transport`	`stdio`	Transport mode: `stdio` or `http`
`--port`	`3000`	Port to listen on (1–65535)
`--host`	`127.0.0.1`	Host to bind to

Security note: The default host 127.0.0.1 restricts access to localhost only. Binding to 0.0.0.0 exposes the server to the network; only do this in controlled environments.

HTTP Endpoints

Endpoint	Method	Description
`/mcp`	`POST`	MCP JSON-RPC endpoint (streamable HTTP transport)
`/health`	`GET`	Health check — returns `{"status":"ok","version":"<current>"}`

Connecting an MCP Client via HTTP

Claude Desktop or other MCP clients that support HTTP transport can connect with:

{
  "mcpServers": {
    "jamf-docs": {
      "url": "http://127.0.0.1:3000/mcp"
    }
  }
}

CORS Configuration

By default the server does not set CORS headers (cross-origin requests are blocked). To allow specific origins, set the CORS_ALLOWED_ORIGINS environment variable:

CORS_ALLOWED_ORIGINS=https://myapp.example.com node dist/index.js --transport http

Multiple origins are separated by commas.

Rate Limiting

The HTTP server applies per-IP token-bucket rate limiting. The default is 60 requests per minute. Override with the RATE_LIMIT_RPM environment variable.

Configuration

All settings are optional. Set them as environment variables before launching the server.

Cache Settings

Variable	Default	Range	Description
`CACHE_DIR`	`.cache`	—	Cache directory (relative paths must stay within the project; sensitive system paths are rejected)
`CACHE_TTL_SEARCH`	`1800000` (30 min)	1 min–30 days	TTL for search result cache entries
`CACHE_TTL_ARTICLE`	`86400000` (24 hr)	1 min–30 days	TTL for article content cache entries
`CACHE_TTL_PRODUCTS`	`604800000` (7 days)	1 min–30 days	TTL for product list cache entries
`CACHE_TTL_TOC`	`86400000` (24 hr)	1 min–30 days	TTL for table of contents cache entries
`CACHE_MAX_ENTRIES`	`500`	10–10000	Maximum number of entries kept in the in-memory cache

Request Settings

Variable	Default	Range	Description
`REQUEST_TIMEOUT`	`15000`	1000–60000 ms	HTTP request timeout
`MAX_RETRIES`	`3`	0–10	Number of retry attempts on failure
`RETRY_DELAY`	`1000`	100–30000 ms	Delay between retries
`RATE_LIMIT_DELAY`	`500`	0–10000 ms	Delay between outbound requests (politeness)
`USER_AGENT`	`JamfDocsMCP/1.0 ...`	—	User-Agent header sent to learn.jamf.com

HTTP Transport Settings

Variable	Default	Range	Description
`RATE_LIMIT_RPM`	`60`	1–10000	Inbound requests per minute per IP (HTTP transport only)
`CORS_ALLOWED_ORIGINS`	`` (empty)	—	Comma-separated list of allowed CORS origins (HTTP transport only)

Development

git clone https://github.com/GET-Technology-Inc/jamf-docs-mcp-server.git
cd jamf-docs-mcp-server
npm install
npm run dev        # stdio mode with file watching
npm run start:http # HTTP transport mode

Available Scripts

Script	Description
`npm run build`	Compile TypeScript to `dist/`
`npm run dev`	Development mode with auto-reload (stdio)
`npm run dev:app-ui`	Live preview of the MCP Apps viewer at http://127.0.0.1:5173
`npm run fixtures:app-ui`	Re-capture the viewer's fixtures from the live tools
`npm run start:http`	Start HTTP/SSE transport mode
`npm test`	Run all tests
`npm run test:unit`	Unit tests only
`npm run test:integration`	Integration tests only
`npm run test:e2e`	End-to-end tests only
`npm run test:coverage`	Test coverage report
`npm run test:inspector`	Launch MCP Inspector against local build
`npm run lint`	Lint source files
`npm run typecheck`	TypeScript type check without emitting

License

Disclaimer

This is an unofficial tool and is not affiliated with Jamf.

Available Tools

6 tools

jamf_docs_batch_get_articlesBatch Get Jamf Documentation ArticlesA

Read-onlyIdempotent

Retrieve multiple Jamf documentation articles in a single request.

Fetches up to 10 articles in parallel with concurrency control. Useful for comparing articles, gathering information from multiple pages, or bulk research.

Args:

urls (string[], required): Array of 1-10 article URLs (must be from docs.jamf.com or learn.jamf.com)
concurrency (number, optional): Max parallel requests 1-5 (default: 3)
maxTokens (number, optional): Total token budget across all articles 100-50000 (default: 5000). Distributed evenly.
outputMode ('full' | 'compact'): Output detail level (default: 'full'). Use 'compact' for brief output.
responseFormat ('markdown' | 'json'): Output format (default: 'markdown')

Returns: An array of article results. Each article independently succeeds or fails. For JSON format, returns a BatchResponse object with results, summary, and tokenInfo.

Examples:

Compare two products: urls=["https://learn.jamf.com/.../page/A.html", "https://learn.jamf.com/.../page/B.html"]
Bulk fetch with compact output: urls=[...], outputMode="compact", maxTokens=10000

Note: Token budget is split evenly across articles. Use higher maxTokens for more articles. Partial failures are reported per-article without failing the entire batch.

ParametersJSON Schema

Name	Required	Description	Default
`urls`	Yes	Array of Jamf documentation article URLs (1-10)
`language`	No	Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH, it-IT, pt-BR, zh-CN
`maxTokens`	No	Total token budget across all articles (100-50000, default: 5000)
`outputMode`	No	Output detail level: "full" for detailed output or "compact" for brief output	full
`concurrency`	No	Maximum parallel requests (1-5, default: 3)
`responseFormat`	No	Output format: "markdown" for human-readable or "json" for machine-readable	markdown

Output Schema

ParametersJSON Schema

Name	Required	Description
`results`	Yes
`summary`	Yes

TDQS

A4.3/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint and idempotentHint, and the description adds transparency about per-article failure handling and token budget distribution. It does not disclose rate limits or error specifics, but given the annotations cover the core safety profile, the added context on partial failures is a meaningful bonus.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with sections for args, examples, and notes. It contains some redundancy (repeating schema parameter details), but the examples and the final note are concise and actionable, making the overall organization effective without excessive verbosity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (6 parameters, 3 enums), the description covers the essential operational aspects: examples, concurrency, token management, and failure semantics. It does not elaborate on the output schema structure, but the presence of an output schema and the description's mention of 'array of article results' is sufficient for an agent to understand the expected return.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema provides full descriptions for all parameters (100% coverage), so the baseline is 3. The description adds valuable context beyond the schema, such as the note that 'Token budget is split evenly across articles' and guidance to 'Use higher maxTokens for more articles,' which deepens understanding of the maxTokens parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Retrieve multiple Jamf documentation articles in a single request.' It also distinguishes itself from single-article retrieval by emphasizing the batch nature, which is reinforced by the tool name and the explicit mention of 'batch.'

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides examples, explains token budget splitting, and mentions partial failures. It implicitly suggests use cases (comparing articles, bulk research) but does not explicitly contrast with the single-article sibling tool (jamf_docs_get_article), leaving the 'when not to use' slightly implicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

jamf_docs_get_articleGet Jamf Documentation ArticleA

Read-onlyIdempotent

Retrieve the full content of a specific Jamf documentation article.

This tool fetches and parses a Jamf documentation article, converting it to a clean, readable format. Works with any article from docs.jamf.com or learn.jamf.com.

Args:

url (string, required): Full URL of the article (must be from docs.jamf.com or learn.jamf.com)
section (string, optional): Extract only a specific section by title or ID (e.g., "Prerequisites", "Configuration")
summaryOnly (boolean, optional): Return only article summary and outline instead of full content (default: false). Token-efficient way to preview an article
includeRelated (boolean, optional): Include links to related articles (default: false)
maxTokens (number, optional): Maximum tokens in response 100-50000 (default: 5000)
outputMode ('full' | 'compact'): Output detail level (default: 'full'). Use 'compact' for brief output
responseFormat ('markdown' | 'json'): Output format (default: 'markdown')

Returns: For JSON format: { "title": string, "content": string, "url": string, "product": string, "version": string, "breadcrumb": string[], "relatedArticles": [...], "tokenInfo": { "tokenCount": number, "truncated": boolean, "maxTokens": number }, "sections": [ { "id": string, "title": string, "level": number, "tokenCount": number } ] }

For Markdown format: The article content with token info and available sections.

Examples:

Get full article: url="https://learn.jamf.com/en-US/bundle/jamf-pro-documentation/page/Configuration_Profiles.html"
Get specific section: url="...", section="Prerequisites"
Limit response size: url="...", maxTokens=2000

Errors:

"Article not found (404)" if the URL returns a 404 error
"Invalid URL" if the URL is not from docs.jamf.com or learn.jamf.com
"Section not found" if the specified section doesn't exist (will list available sections)

Note: Large articles are intelligently truncated with remaining sections listed. Use the section parameter to retrieve specific sections for long articles.

ParametersJSON Schema

Name	Required	Description	Default
`url`	No	Full URL of the Jamf documentation article. Alternative: use mapId + contentId for direct fetch.
`mapId`	No	Fluid Topics map ID (from search results or TOC). Use with contentId for direct fetch.
`section`	No	Extract only a specific section by title or ID (e.g., "Prerequisites", "Configuration")
`language`	No	Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH, it-IT, pt-BR, zh-CN
`contentId`	No	Fluid Topics content ID (from search results or TOC). Use with mapId for direct fetch.
`maxTokens`	No	Maximum tokens in response (100-50000, default: 5000)
`outputMode`	No	Output detail level: "full" for detailed output or "compact" for brief output	full
`summaryOnly`	No	Return only article summary and outline instead of full content (token-efficient)
`includeRelated`	No	Include related article links in the response
`responseFormat`	No	Output format: "markdown" for human-readable or "json" for machine-readable	markdown

Output Schema

ParametersJSON Schema

Name	Required	Description
`url`	Yes
`mapId`	No
`title`	Yes
`content`	Yes
`product`	No
`version`	No
`sections`	Yes
`contentId`	No
`truncated`	Yes
`breadcrumb`	No
`navigation`	No
`tokenCount`	No
`lastUpdated`	No
`contentLocale`	No
`versionStatus`	No

TDQS

A4.2/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavior beyond annotations: truncation of large articles with remaining sections listed, error handling (404, invalid URL, section not found), token info in response, and output format options. This is thorough and consistent with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but well-organized with clear headings (Args, Returns, Examples, Errors, Note). It front-loads the purpose and each section serves a distinct role. Some redundancy exists (e.g., outputMode and responseFormat are explained both in Args and Returns), but overall it is efficient for a tool with 10 parameters.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (10 parameters, output schema, multiple output modes), the description is exceptionally complete. It covers error cases, truncation behavior, token limits, parameter alternatives (url vs mapId/contentId), and includes concrete examples. The presence of an output schema reduces the need to explain return values, but the description still elaborates sufficiently. No critical information is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with all parameters described. The description adds some context (e.g., summaryOnly as a 'token-efficient way to preview', maxTokens range, section extraction behavior) and examples, but largely reinforces the schema. No missing parameter semantics beyond what the schema provides, so a baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Retrieve the full content of a specific Jamf documentation article') with a specific resource (Jamf documentation article). It distinguishes this from siblings like search, TOC, glossary, and batch fetch by focusing on a single article retrieval. No ambiguity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives extensive how-to guidance (URL vs mapId/contentId, section extraction, summaryOnly, maxTokens, etc.) but does not explicitly contrast this tool with siblings like jamf_docs_search or jamf_docs_batch_get_articles. It does not state when to prefer this over alternatives, though the purpose is clear enough to infer most usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

jamf_docs_get_tocGet Documentation Table of ContentsA

Read-onlyIdempotent

Get the table of contents for Jamf documentation.

Browse the navigation structure of either a Jamf product or any single Jamf publication - release notes, technical papers, courses, evaluation guides and configuration guides all live on the publication axis rather than the product one. Exactly one of product and publication is required.

Args:

product (string): Product ID - one of: jamf-pro, jamf-school, jamf-connect, jamf-protect, jamf-now, jamf-safe-internet, jamf-insights, jamf-rapididentity, jamf-trust, jamf-routines, self-service-plus, jamf-app-catalog, jamf-account, jamf-security-cloud, elevate, composer, jamf-parent, jamf-teacher, jamf-setup-reset, jamf-assessment, title-editor, jamf-infrastructure-manager, jamf-adcs-connector, jamf-pki-proxy, jamf-migrate, jamf-remote-assist, jamf-cloud-distribution-service, healthcare-listener
publication (string): Bundle family id of any single publication, e.g. "technical-paper-laps" or "jamf-pro-release-notes". Call jamf_docs_list_products for the available ids
version (string, optional): Specific version (defaults to latest)
page (number, optional): Page number for pagination 1-100 (default: 1)
maxTokens (number, optional): Maximum tokens in response 100-50000 (default: 5000)
outputMode ('full' | 'compact'): Output detail level (default: 'full'). Use 'compact' for flat list without nested children
responseFormat ('markdown' | 'json'): Output format (default: 'markdown')

Returns: For JSON format: { "product": string, "productId": string, // present when addressed by product "publicationId": string, // present when addressed by publication "version": string, "mapId": string, // omitted when the map could not be resolved "toc": [...], // each entry carries title, url and contentId "tokenInfo": { "tokenCount": number, "truncated": boolean, "maxTokens": number }, "pagination": { "page": number, "pageSize": number, "totalPages": number, "totalItems": number, "hasNext": boolean, "hasPrev": boolean } }

For Markdown format: A hierarchical list of documentation topics with pagination and token info.

Examples:

Browse Jamf Pro documentation: product="jamf-pro"
Get page 2 of TOC: product="jamf-pro", page=2
Limit response size: product="jamf-pro", maxTokens=2000

Errors:

"Invalid product ID" if the product is not recognized
"Version not found" if the specified version doesn't exist

Note: Use this to discover what topics are available before searching or retrieving specific articles. Large TOCs are paginated. The response-level mapId and an entry's contentId together form the pair jamf_docs_get_article accepts for a direct fetch. Markdown output shows the mapId only; use responseFormat="json" (or read structuredContent) for the per-entry contentIds. structuredContent.entries is the TOC flattened in document order and always carries every descendant; each entry's depth (0 for top level) is what restores the nesting. The markdown is not the same view: outputMode="full" shows that nesting as indentation, while outputMode="compact" lists only the top-level entries and shows no nesting at all.

ParametersJSON Schema

Name	Required	Description	Default
`page`	No	Page number for pagination (1-100, default: 1)
`product`	No	Product ID: jamf-pro, jamf-school, jamf-connect, jamf-protect, jamf-now, jamf-safe-internet, jamf-insights, jamf-rapididentity, jamf-trust, jamf-routines, self-service-plus, jamf-app-catalog, jamf-account, jamf-security-cloud, elevate, composer, jamf-parent, jamf-teacher, jamf-setup-reset, jamf-assessment, title-editor, jamf-infrastructure-manager, jamf-adcs-connector, jamf-pki-proxy, jamf-migrate, jamf-remote-assist, jamf-cloud-distribution-service, healthcare-listener
`version`	No	Specific version (e.g. "11.13.0"); defaults to latest
`language`	No	Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH, it-IT, pt-BR, zh-CN
`maxTokens`	No	Maximum tokens in response (100-50000, default: 5000)
`outputMode`	No	Output detail level: "full" for detailed output or "compact" for brief output	full
`publication`	No	Bundle family id for any Jamf publication, e.g. "technical-paper-laps" or "jamf-pro-release-notes". Use this for the documents that are not one of the products in `product` — release notes, technical papers, courses, evaluation and configuration guides. Exactly one of `product` or `publication` is required. Call jamf_docs_list_products to see the available ids.
`responseFormat`	No	Output format: "markdown" for human-readable or "json" for machine-readable	markdown

Output Schema

ParametersJSON Schema

Name	Required	Description
`page`	Yes
`mapId`	No
`entries`	Yes
`hasMore`	Yes
`product`	Yes
`version`	Yes
`productId`	No
`localeNote`	No
`totalPages`	Yes
`versionNote`	No
`totalEntries`	Yes
`publicationId`	No
`paginationNote`	No

TDQS

A4.5/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare read-only, idempotent, and non-destructive. The description adds substantial context: pagination behavior, token limits, output modes, structuredContent semantics, and the mapId/contentId pairing for get_article. It also lists errors. No contradiction.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-organized but verbose. It repeats parameter details already in the schema (e.g., full product list), which is redundant. However, it front-loads purpose and includes valuable examples and notes, so it earns its length despite some redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the 8-parameter tool with output schema and annotations, the description is exceptionally complete. It covers purpose, usage, parameters, return format, errors, and the nuanced behavior of structuredContent and output modes. Nothing an agent needs is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema covers all parameters with descriptions, so baseline is 3. The description adds meaning by explaining the product/publication exclusivity, giving examples of publication ids, clarifying outputMode and responseFormat differences, and detailing pagination and token behavior.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States the tool retrieves the table of contents for Jamf documentation, distinguishing between product and publication axes. It clearly indicates this is for browsing navigation structure, distinct from searching or retrieving articles.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states exactly one of product or publication is required, and that this should be used before searching or retrieving articles. It also points to jamf_docs_list_products for available ids and mentions get_article for direct fetch, providing clear routing among siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

jamf_docs_glossary_lookupLookup Jamf Glossary TermA

Read-onlyIdempotent

Look up a term in the Jamf official glossary and get its definition.

This tool searches glossary pages across Jamf product documentation and returns matching term definitions using fuzzy matching.

Note: Glossary content is currently only available in English (en-US). Non-English language parameters are accepted but results will be in English.

Args:

term (string, required): Glossary term to look up (2-100 characters). Supports fuzzy matching.
product (string, optional): Filter by product ID (use jamf_docs_list_products to see all)
language (string, optional): Documentation language/locale (default: en-US). Note: glossary is English-only.
maxTokens (number, optional): Maximum tokens in response 100-50000 (default: 5000)
outputMode ('full' | 'compact'): Output detail level (default: 'full')
responseFormat ('markdown' | 'json'): Output format (default: 'markdown')

Returns: For JSON format: { "term": string, "totalMatches": number, "entries": [{ "term": string, "definition": string, "product": string, "url": string }], "tokenInfo": { "tokenCount": number, "truncated": boolean, "maxTokens": number } }

For Markdown format: A formatted list of glossary definitions with source links.

Examples:

"What is MDM?" → term="MDM"
"Configuration Profile in Jamf Pro" → term="Configuration Profile", product="jamf-pro"
"What does DEP stand for?" → term="DEP"

Errors:

"No matching term found" if no glossary entries match
"Invalid product ID" if product parameter is not recognized

ParametersJSON Schema

Name	Required	Description	Default
`term`	Yes	Glossary term to look up (e.g., "MDM", "Configuration Profile", "Smart Group")
`product`	No	Filter by product: jamf-pro, jamf-school, jamf-connect, jamf-protect, jamf-now, jamf-safe-internet, jamf-insights, jamf-rapididentity, jamf-trust, jamf-routines, self-service-plus, jamf-app-catalog, jamf-account, jamf-security-cloud, elevate, composer, jamf-parent, jamf-teacher, jamf-setup-reset, jamf-assessment, title-editor, jamf-infrastructure-manager, jamf-adcs-connector, jamf-pki-proxy, jamf-migrate, jamf-remote-assist, jamf-cloud-distribution-service, healthcare-listener
`language`	No	Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH, it-IT, pt-BR, zh-CN
`maxTokens`	No	Maximum tokens in response (100-50000, default: 5000)
`outputMode`	No	Output detail level: "full" for detailed output or "compact" for brief output	full
`responseFormat`	No	Output format: "markdown" for human-readable or "json" for machine-readable	markdown

Output Schema

ParametersJSON Schema

Name	Required	Description
`term`	Yes
`entries`	Yes
`truncated`	Yes
`totalMatches`	Yes

TDQS

A4.3/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already provide readOnlyHint and idempotentHint, and the description adds concrete behavioral details beyond that: fuzzy matching, language acceptance with English-only results, and output format options. This gives an agent a richer understanding of expected behavior without requiring a call.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-organized into sections (description, args, returns, examples, errors) and is free of redundancy. Each sentence serves a purpose, making it concise yet comprehensive. The front-loaded main description gives the essential purpose immediately.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of 6 parameters (with 4 enums) and two output formats, the description covers all necessary aspects: it fully describes each parameter, explains both JSON and Markdown return structures, provides concrete usage examples, and lists possible errors. The provided output schema further enhances completeness, leaving no critical gaps for an agent to call the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already provides 100% coverage with detailed descriptions for every parameter (term, product, language, maxTokens, outputMode, responseFormat). The tool description repeats these details and adds examples, but it does not add substantially new semantic meaning beyond what the schema already conveys, so the baseline of 3 is maintained.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Look up a term in the Jamf official glossary and get its definition.' It specifies a resource (glossary) and a specific action (search/lookup), and its examples further clarify typical use cases. This effectively distinguishes it from the general search and article retrieval siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for glossary lookups and provides examples, but it does not explicitly state when to prefer this tool over alternatives like jamf_docs_search or jamf_docs_get_article. There is no explicit 'use this when' or 'use instead of' guidance, so a 3 is appropriate.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

jamf_docs_list_productsList Jamf ProductsA

Read-onlyIdempotent

List Jamf products, publications, topics, and documentation versions.

Returns two separate catalogues:

Products: the IDs the product filter in jamf_docs_search accepts, and the product parameter of jamf_docs_get_toc. Jamf Pro, Jamf School, Jamf Connect, Jamf Protect, Jamf Now, Jamf Safe Internet and more.
Publications: every document Jamf publishes - release notes, technical papers, courses, evaluation and configuration guides - grouped the way Jamf classifies them. Pass one of these IDs as the publication parameter of jamf_docs_get_toc. These are documents, not products, and the search product filter does not take them.

Also lists available topic and docType filters for search.

Args:

maxTokens (number, optional): Maximum tokens in response 100-50000 (default: 10000, higher than other tools because this one answers with a whole catalogue)
outputMode ('full' | 'compact'): Output detail level (default: 'full'). Use 'compact' for brief list
responseFormat ('markdown' | 'json'): Output format (default: 'markdown')

Returns: For JSON format: { "products": [...], "publications": [...], // omitted if the maps registry is unreachable "topics": [...], "tokenInfo": { "tokenCount": number, "truncated": boolean, "maxTokens": number } }

For Markdown format: A formatted list of products and topics with their details.

Examples:

"What Jamf products are available?" → use this tool
"List all Jamf documentation" → use this tool
"What topics can I filter by?" → use this tool
"Where are the Jamf Pro release notes?" → use this tool, then get_toc with the publication ID

Note: This is a read-only operation that does not modify any state.

ParametersJSON Schema

Name	Required	Description	Default
`maxTokens`	No	Maximum tokens in response (100-50000, default: 10000)
`outputMode`	No	Output detail level: "full" for detailed output or "compact" for brief output	full
`responseFormat`	No	Output format: "markdown" for human-readable or "json" for machine-readable	markdown

Output Schema

ParametersJSON Schema

Name	Required	Description
`topics`	Yes
`products`	Yes
`publications`	No

TDQS

A4.9/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations (readOnlyHint, idempotentHint), the description discloses that publications may be omitted if the maps registry is unreachable, and explains why maxTokens default is higher than other tools (because it returns a whole catalogue). These behavioral details add value beyond the structured annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but well-structured with clear sections (overview, args, returns, examples). Every sentence serves a purpose—no fluff. The main purpose is front-loaded, and the examples are concise and actionable. For a tool with this complexity, the length is justified and efficiently organized.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite having an output schema, the description goes further by showing the JSON return structure, noting the potential omission of publications, and giving example queries. It fully equips an agent to call the tool correctly and interpret the response, leaving no critical gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with descriptions for all three parameters, so the baseline is 3. The description adds meaningful context: it explains the maxTokens default is intentionally higher than other tools, recommends 'compact' for brief lists, and clarifies the difference between markdown and json response formats. This goes beyond the schema's basic descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it lists Jamf products, publications, topics, and docTypes, and explicitly distinguishes itself from siblings by explaining how its outputs feed into jamf_docs_search and jamf_docs_get_toc. The verb+resource is specific and unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit when-to-use guidance via concrete examples ('What Jamf products are available?' → use this tool) and explains how to chain it with jamf_docs_get_toc for release notes. It also clarifies that publications are documents, not products, preventing misuse of the search filter.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

jamf_docs_searchSearch Jamf DocumentationA

Read-onlyIdempotent

Search Jamf documentation for articles matching your query.

This tool searches across all Jamf product documentation including Jamf Pro, Jamf School, Jamf Connect, Jamf Protect, Jamf Now, Jamf Safe Internet, and more. Results include article titles, snippets, and direct links.

Args:

query (string, required): Search keywords (2-200 characters)
product (string, optional): Filter by product ID (use jamf_docs_list_products to see all)
topic (string, optional): Filter by topic. Common: enrollment, profiles, policies, packages, scripts, patch, apps, security, filevault, sso, identity-provider, inventory, reports, api, network. See jamf_docs_list_products for the full list of 40 topic IDs.
docType (string, optional): Filter by document type: documentation, release-notes, training, solution-guide, glossary, getting-started
version (string, optional): Filter by version (e.g., "11.5.0", "10.x")
limit (number, optional): Maximum results per page 1-50 (default: 10)
page (number, optional): Page number for pagination 1-100 (default: 1)
maxTokens (number, optional): Maximum tokens in response 100-50000 (default: 5000)
outputMode ('full' | 'compact'): Output detail level (default: 'full'). Use 'compact' for brief, token-efficient output
responseFormat ('markdown' | 'json'): Output format (default: 'markdown')

Returns: For JSON format: { "total": number, "query": string, "results": [...], "tokenInfo": { "tokenCount": number, "truncated": boolean, "maxTokens": number }, "pagination": { "page": number, "pageSize": number, "totalPages": number, "totalItems": number, "hasNext": boolean, "hasPrev": boolean } }

For Markdown format: A formatted list of search results with pagination and token info.

Examples (common query → recommended filters):

"Configure SSO with Okta in Jamf Connect" → query="SSO Okta", product="jamf-connect", topic="sso"
"Set up FileVault encryption" → query="FileVault encryption", product="jamf-pro", topic="filevault"
"Patch macOS apps" → query="patch policy", product="jamf-pro", topic="patch"
"Smart group criteria" → query="smart group criteria", product="jamf-pro", topic="reports"
"Automated Device Enrollment workflow" → query="ADE prestage", product="jamf-pro", topic="enrollment"
"Shared iPad in a classroom" → query="shared iPad classroom", product="jamf-school", topic="education"
"Jamf Protect custom analytic" → query="custom analytic", product="jamf-protect", topic="protect-analytics"
"Jamf Pro REST API authentication" → query="API role bearer token", product="jamf-pro", topic="api"
"Extension attribute scripts" → query="extension attribute script", product="jamf-pro", topic="extension-attributes"
"Paginate through results" → query="policy", page=2

Errors:

"No results found" if search returns empty
"Invalid product ID" if product parameter is not recognized

Note: Results are ranked by relevance. Use filters and pagination to navigate large result sets. Most results carry a mapId + contentId pair; pass both to jamf_docs_get_article to fetch that article directly instead of resolving its URL. The pair is omitted when a result comes from a source that does not resolve one — fall back to the URL in that case.

ParametersJSON Schema

Name	Required	Description	Default
`page`	No	Page number for pagination (1-100, default: 1)
`limit`	No	Maximum number of results per page (1-50)
`query`	Yes	Search keywords to find in Jamf documentation
`topic`	No	Filter by topic. Common: enrollment, profiles, policies, packages, scripts, patch, apps, security, filevault, sso, identity-provider, inventory, reports, api, network. See jamf_docs_list_products for the full list of 40 topic IDs.
`docType`	No	Filter by document type: documentation, release-notes, training, solution-guide, glossary, getting-started
`product`	No	Filter by product: jamf-pro, jamf-school, jamf-connect, jamf-protect, jamf-now, jamf-safe-internet, jamf-insights, jamf-rapididentity, jamf-trust, jamf-routines, self-service-plus, jamf-app-catalog, jamf-account, jamf-security-cloud, elevate, composer, jamf-parent, jamf-teacher, jamf-setup-reset, jamf-assessment, title-editor, jamf-infrastructure-manager, jamf-adcs-connector, jamf-pki-proxy, jamf-migrate, jamf-remote-assist, jamf-cloud-distribution-service, healthcare-listener
`version`	No	Filter by version (e.g., "11.13.0") or "current"
`language`	No	Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH, it-IT, pt-BR, zh-CN
`maxTokens`	No	Maximum tokens in response (100-50000, default: 5000)
`outputMode`	No	Output detail level: "full" for detailed output or "compact" for brief output	full
`responseFormat`	No	Output format: "markdown" for human-readable or "json" for machine-readable	markdown

Output Schema

ParametersJSON Schema

Name	Required	Description
`page`	Yes
`limit`	No
`query`	Yes
`filters`	No
`hasMore`	Yes
`results`	Yes
`totalPages`	Yes
`suggestions`	No
`versionNote`	No
`otherSources`	No
`totalResults`	Yes
`relevanceNote`	No
`paginationNote`	No
`filterRelaxation`	No
`truncatedContent`	No

TDQS

A5/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description discloses ranking by relevance, pagination behavior, token limits, error messages ('No results found', 'Invalid product ID'), and the fallback to URL when mapId+contentId is absent. This gives the agent a full picture of the tool's runtime behavior without conflicting with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but well-structured with clear sections (Args, Returns, Examples, Errors, Note). It front-loads the core purpose, then systematically covers every parameter, return format, and edge case. Every sentence contributes meaningful information; nothing is redundant or padding.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (11 parameters, output schema, pagination, multiple response formats), the description is remarkably complete. It includes error handling, fallback behavior, examples, and cross-references to sibling tools, leaving no critical information missing for an agent to call it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, but the description adds significant value beyond the schema: it explains the purpose of each filter, provides a curated list of common topic IDs, shows example queries with recommended parameter combinations, and clarifies the mapId/contentId usage. This goes well beyond the schema's dry parameter definitions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a clear statement: 'Search Jamf documentation for articles matching your query.' It names the resource (Jamf documentation) and the verb (search), and distinguishes itself from sibling tools like jamf_docs_get_article (which fetches a specific article) and jamf_docs_list_products (which lists product IDs). The scope across all Jamf product documentation is explicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit guidance on when to use this tool and how to combine it with siblings: it references jamf_docs_list_products for product/topic IDs, and instructs to pass mapId+contentId to jamf_docs_get_article for direct retrieval. It also gives examples of common queries with recommended filters, effectively teaching the agent how to choose parameters.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

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

1 tool updatev5.10.6Sep 15, 2026
- Changedjamf_docs_list_products8 fields changed
  - changedInput schema / properties / maxTokens / default
```
Previous value: -5000New value: +10000
```
  - changedInput schema / properties / maxTokens / description
```
Previous value: -"Maximum tokens in response (100-50000, default: 5000)"New value: +"Maximum tokens in response (100-50000, default: 10000)"
```
  - addedOutput schema / properties / publications / items / properties / app / items
```
Added value: +{
+  "type": "string"
+}
```
  - changedOutput schema / properties / publications / items / properties / app / type
```
Previous value: -"string"New value: +"array"
```
  - addedOutput schema / properties / publications / items / properties / portal / items
```
Added value: +{
+  "type": "string"
+}
```
  - changedOutput schema / properties / publications / items / properties / portal / type
```
Previous value: -"string"New value: +"array"
```
  - addedOutput schema / properties / publications / items / properties / utility / items
```
Added value: +{
+  "type": "string"
+}
```
  - changedOutput schema / properties / publications / items / properties / utility / type
```
Previous value: -"string"New value: +"array"
```

6 tool updatesv5.10.1Sep 8, 2026

Changedjamf_docs_batch_get_articles2 fields changed

changedInput schema / properties / language / description

Previous value: -"Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH"New value: +"Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH, it-IT, pt-BR, zh-CN"

changedInput schema / properties / language / enum

Previous value: -[
-  "en-US",
-  "ja-JP",
-  "zh-TW",
-  "de-DE",
-  "es-ES",
-  "fr-FR",
-  "nl-NL",
-  "th-TH"
-]New value: +[
+  "en-US",
+  "ja-JP",
+  "zh-TW",
+  "de-DE",
+  "es-ES",
+  "fr-FR",
+  "nl-NL",
+  "th-TH",
+  "it-IT",
+  "pt-BR",
+  "zh-CN"
+]

Changedjamf_docs_get_article2 fields changed

changedInput schema / properties / language / description

Previous value: -"Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH"New value: +"Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH, it-IT, pt-BR, zh-CN"

changedInput schema / properties / language / enum

Previous value: -[
-  "en-US",
-  "ja-JP",
-  "zh-TW",
-  "de-DE",
-  "es-ES",
-  "fr-FR",
-  "nl-NL",
-  "th-TH"
-]New value: +[
+  "en-US",
+  "ja-JP",
+  "zh-TW",
+  "de-DE",
+  "es-ES",
+  "fr-FR",
+  "nl-NL",
+  "th-TH",
+  "it-IT",
+  "pt-BR",
+  "zh-CN"
+]

Changedjamf_docs_get_toc11 fields changed

changedInput schema / properties / language / description

Previous value: -"Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH"New value: +"Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH, it-IT, pt-BR, zh-CN"

changedInput schema / properties / language / enum

Previous value: -[
-  "en-US",
-  "ja-JP",
-  "zh-TW",
-  "de-DE",
-  "es-ES",
-  "fr-FR",
-  "nl-NL",
-  "th-TH"
-]New value: +[
+  "en-US",
+  "ja-JP",
+  "zh-TW",
+  "de-DE",
+  "es-ES",
+  "fr-FR",
+  "nl-NL",
+  "th-TH",
+  "it-IT",
+  "pt-BR",
+  "zh-CN"
+]

changedInput schema / properties / product / description

Previous value: -"Product ID: jamf-pro, jamf-school, jamf-connect, jamf-protect, jamf-now, jamf-safe-internet, jamf-insights, jamf-rapididentity, jamf-trust, jamf-routines, self-service-plus, jamf-app-catalog"New value: +"Product ID: jamf-pro, jamf-school, jamf-connect, jamf-protect, jamf-now, jamf-safe-internet, jamf-insights, jamf-rapididentity, jamf-trust, jamf-routines, self-service-plus, jamf-app-catalog, jamf-account, jamf-security-cloud, elevate, composer, jamf-parent, jamf-teacher, jamf-setup-reset, jamf-assessment, title-editor, jamf-infrastructure-manager, jamf-adcs-connector, jamf-pki-proxy, jamf-migrate, jamf-remote-assist, jamf-cloud-distribution-service, healthcare-listener"

changedInput schema / properties / product / enum

Previous value: -[
-  "jamf-pro",
-  "jamf-school",
-  "jamf-connect",
-  "jamf-protect",
-  "jamf-now",
-  "jamf-safe-internet",
-  "jamf-insights",
-  "jamf-rapididentity",
-  "jamf-trust",
-  "jamf-routines",
-  "self-service-plus",
-  "jamf-app-catalog"
-]New value: +[
+  "jamf-pro",
+  "jamf-school",
+  "jamf-connect",
+  "jamf-protect",
+  "jamf-now",
+  "jamf-safe-internet",
+  "jamf-insights",
+  "jamf-rapididentity",
+  "jamf-trust",
+  "jamf-routines",
+  "self-service-plus",
+  "jamf-app-catalog",
+  "jamf-account",
+  "jamf-security-cloud",
+  "elevate",
+  "composer",
+  "jamf-parent",
+  "jamf-teacher",
+  "jamf-setup-reset",
+  "jamf-assessment",
+  "title-editor",
+  "jamf-infrastructure-manager",
+  "jamf-adcs-connector",
+  "jamf-pki-proxy",
+  "jamf-migrate",
+  "jamf-remote-assist",
+  "jamf-cloud-distribution-service",
+  "healthcare-listener"
+]

addedInput schema / properties / publication

Added value: +{
+  "description": "Bundle family id for any Jamf publication, e.g. \"technical-paper-laps\" or \"jamf-pro-release-notes\". Use this for the documents that are not one of the products in `product` — release notes, technical papers, courses, evaluation and configuration guides. Exactly one of `product` or `publication` is required. Call jamf_docs_list_products to see the available ids.",
+  "maxLength": 200,
+  "minLength": 1,
+  "type": "string"
+}

changedInput schema / properties / version / description

Previous value: -"Specific version (defaults to latest)"New value: +"Specific version (e.g. \"11.13.0\"); defaults to latest"

addedInput schema / properties / version / pattern
```
Added value: +"^(?:current|\\d+(?:\\.\\d+)*)$"
```
removedInput schema / required
```
Removed value: -[
-  "product"
-]
```
addedOutput schema / properties / localeNote
```
Added value: +{
+  "type": "string"
+}
```
addedOutput schema / properties / publicationId
```
Added value: +{
+  "type": "string"
+}
```

changedOutput schema / required

Previous value: -[
-  "product",
-  "productId",
-  "version",
-  "totalEntries",
-  "page",
-  "totalPages",
-  "hasMore",
-  "entries"
-]New value: +[
+  "product",
+  "version",
+  "totalEntries",
+  "page",
+  "totalPages",
+  "hasMore",
+  "entries"
+]

Changedjamf_docs_glossary_lookup4 fields changed

changedInput schema / properties / language / description

Previous value: -"Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH"New value: +"Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH, it-IT, pt-BR, zh-CN"

changedInput schema / properties / language / enum

Previous value: -[
-  "en-US",
-  "ja-JP",
-  "zh-TW",
-  "de-DE",
-  "es-ES",
-  "fr-FR",
-  "nl-NL",
-  "th-TH"
-]New value: +[
+  "en-US",
+  "ja-JP",
+  "zh-TW",
+  "de-DE",
+  "es-ES",
+  "fr-FR",
+  "nl-NL",
+  "th-TH",
+  "it-IT",
+  "pt-BR",
+  "zh-CN"
+]

changedInput schema / properties / product / description

Previous value: -"Filter by product: jamf-pro, jamf-school, jamf-connect, jamf-protect, jamf-now, jamf-safe-internet, jamf-insights, jamf-rapididentity, jamf-trust, jamf-routines, self-service-plus, jamf-app-catalog"New value: +"Filter by product: jamf-pro, jamf-school, jamf-connect, jamf-protect, jamf-now, jamf-safe-internet, jamf-insights, jamf-rapididentity, jamf-trust, jamf-routines, self-service-plus, jamf-app-catalog, jamf-account, jamf-security-cloud, elevate, composer, jamf-parent, jamf-teacher, jamf-setup-reset, jamf-assessment, title-editor, jamf-infrastructure-manager, jamf-adcs-connector, jamf-pki-proxy, jamf-migrate, jamf-remote-assist, jamf-cloud-distribution-service, healthcare-listener"

changedInput schema / properties / product / enum

Previous value: -[
-  "jamf-pro",
-  "jamf-school",
-  "jamf-connect",
-  "jamf-protect",
-  "jamf-now",
-  "jamf-safe-internet",
-  "jamf-insights",
-  "jamf-rapididentity",
-  "jamf-trust",
-  "jamf-routines",
-  "self-service-plus",
-  "jamf-app-catalog"
-]New value: +[
+  "jamf-pro",
+  "jamf-school",
+  "jamf-connect",
+  "jamf-protect",
+  "jamf-now",
+  "jamf-safe-internet",
+  "jamf-insights",
+  "jamf-rapididentity",
+  "jamf-trust",
+  "jamf-routines",
+  "self-service-plus",
+  "jamf-app-catalog",
+  "jamf-account",
+  "jamf-security-cloud",
+  "elevate",
+  "composer",
+  "jamf-parent",
+  "jamf-teacher",
+  "jamf-setup-reset",
+  "jamf-assessment",
+  "title-editor",
+  "jamf-infrastructure-manager",
+  "jamf-adcs-connector",
+  "jamf-pki-proxy",
+  "jamf-migrate",
+  "jamf-remote-assist",
+  "jamf-cloud-distribution-service",
+  "healthcare-listener"
+]

Changedjamf_docs_list_products1 field changed

addedOutput schema / properties / publications

Added value: +{
+  "items": {
+    "additionalProperties": false,
+    "properties": {
+      "app": {
+        "type": "string"
+      },
+      "id": {
+        "type": "string"
+      },
+      "locales": {
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "portal": {
+        "type": "string"
+      },
+      "title": {
+        "type": "string"
+      },
+      "utility": {
+        "type": "string"
+      },
+      "versions": {
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      }
+    },
+    "required": [
+      "id",
+      "title",
+      "locales",
+      "versions"
+    ],
+    "type": "object"
+  },
+  "type": "array"
+}

Changedjamf_docs_search8 fields changed

changedInput schema / properties / language / description

Previous value: -"Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH"New value: +"Documentation language/locale (default: en-US). Options: en-US, ja-JP, zh-TW, de-DE, es-ES, fr-FR, nl-NL, th-TH, it-IT, pt-BR, zh-CN"

changedInput schema / properties / language / enum

Previous value: -[
-  "en-US",
-  "ja-JP",
-  "zh-TW",
-  "de-DE",
-  "es-ES",
-  "fr-FR",
-  "nl-NL",
-  "th-TH"
-]New value: +[
+  "en-US",
+  "ja-JP",
+  "zh-TW",
+  "de-DE",
+  "es-ES",
+  "fr-FR",
+  "nl-NL",
+  "th-TH",
+  "it-IT",
+  "pt-BR",
+  "zh-CN"
+]

changedInput schema / properties / product / description

Previous value: -"Filter by product: jamf-pro, jamf-school, jamf-connect, jamf-protect, jamf-now, jamf-safe-internet, jamf-insights, jamf-rapididentity, jamf-trust, jamf-routines, self-service-plus, jamf-app-catalog"New value: +"Filter by product: jamf-pro, jamf-school, jamf-connect, jamf-protect, jamf-now, jamf-safe-internet, jamf-insights, jamf-rapididentity, jamf-trust, jamf-routines, self-service-plus, jamf-app-catalog, jamf-account, jamf-security-cloud, elevate, composer, jamf-parent, jamf-teacher, jamf-setup-reset, jamf-assessment, title-editor, jamf-infrastructure-manager, jamf-adcs-connector, jamf-pki-proxy, jamf-migrate, jamf-remote-assist, jamf-cloud-distribution-service, healthcare-listener"

changedInput schema / properties / product / enum

Previous value: -[
-  "jamf-pro",
-  "jamf-school",
-  "jamf-connect",
-  "jamf-protect",
-  "jamf-now",
-  "jamf-safe-internet",
-  "jamf-insights",
-  "jamf-rapididentity",
-  "jamf-trust",
-  "jamf-routines",
-  "self-service-plus",
-  "jamf-app-catalog"
-]New value: +[
+  "jamf-pro",
+  "jamf-school",
+  "jamf-connect",
+  "jamf-protect",
+  "jamf-now",
+  "jamf-safe-internet",
+  "jamf-insights",
+  "jamf-rapididentity",
+  "jamf-trust",
+  "jamf-routines",
+  "self-service-plus",
+  "jamf-app-catalog",
+  "jamf-account",
+  "jamf-security-cloud",
+  "elevate",
+  "composer",
+  "jamf-parent",
+  "jamf-teacher",
+  "jamf-setup-reset",
+  "jamf-assessment",
+  "title-editor",
+  "jamf-infrastructure-manager",
+  "jamf-adcs-connector",
+  "jamf-pki-proxy",
+  "jamf-migrate",
+  "jamf-remote-assist",
+  "jamf-cloud-distribution-service",
+  "healthcare-listener"
+]

changedInput schema / properties / version / description

Previous value: -"Filter by version (e.g., \"11.5.0\", \"10.x\")"New value: +"Filter by version (e.g., \"11.13.0\") or \"current\""

addedInput schema / properties / version / pattern
```
Added value: +"^(?:current|\\d+(?:\\.\\d+)*)$"
```

addedOutput schema / properties / otherSources

Added value: +{
+  "items": {
+    "additionalProperties": false,
+    "properties": {
+      "source": {
+        "type": "string"
+      },
+      "title": {
+        "type": "string"
+      },
+      "url": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "title",
+      "url",
+      "source"
+    ],
+    "type": "object"
+  },
+  "type": "array"
+}

addedOutput schema / properties / results / items / properties / otherVersions

Added value: +{
+  "items": {
+    "type": "string"
+  },
+  "type": "array"
+}

2 tool updatesv4.3.1Aug 5, 2026

Changedjamf_docs_get_article3 fields changed

addedOutput schema / properties / contentLocale
```
Added value: +{
+  "type": "string"
+}
```

addedOutput schema / properties / navigation

Added value: +{
+  "additionalProperties": false,
+  "properties": {
+    "childCount": {
+      "type": "number"
+    },
+    "children": {
+      "items": {
+        "additionalProperties": false,
+        "properties": {
+          "title": {
+            "type": "string"
+          },
+          "url": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "title",
+          "url"
+        ],
+        "type": "object"
+      },
+      "type": "array"
+    },
+    "parent": {
+      "additionalProperties": false,
+      "properties": {
+        "title": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "title",
+        "url"
+      ],
+      "type": "object"
+    },
+    "self": {
+      "additionalProperties": false,
+      "properties": {
+        "title": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "title",
+        "url"
+      ],
+      "type": "object"
+    },
+    "siblingCount": {
+      "type": "number"
+    },
+    "siblings": {
+      "items": {
+        "additionalProperties": false,
+        "properties": {
+          "title": {
+            "type": "string"
+          },
+          "url": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "title",
+          "url"
+        ],
+        "type": "object"
+      },
+      "type": "array"
+    }
+  },
+  "required": [
+    "self",
+    "siblings",
+    "children",
+    "siblingCount",
+    "childCount"
+  ],
+  "type": "object"
+}

addedOutput schema / properties / versionStatus

Added value: +{
+  "enum": [
+    "latest",
+    "superseded"
+  ],
+  "type": "string"
+}

Changedjamf_docs_get_toc2 fields changed

addedOutput schema / properties / entries / items / properties / depth

Added value: +{
+  "maximum": 9007199254740991,
+  "minimum": 0,
+  "type": "integer"
+}

changedOutput schema / properties / entries / items / required

Previous value: -[
-  "title",
-  "url"
-]New value: +[
+  "title",
+  "url",
+  "depth"
+]

6 tool updatesv4.0.6Aug 3, 2026

Changedjamf_docs_batch_get_articles2 fields changed

changedInput schema / $schema

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

changedOutput schema / $schema

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

Changedjamf_docs_get_article5 fields changed

changedInput schema / $schema

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

changedInput schema / properties / contentId / pattern

Previous value: -"^[a-zA-Z0-9_~\\-]+$"New value: +"^[a-zA-Z0-9_~-]+$"

changedInput schema / properties / mapId / pattern

Previous value: -"^[a-zA-Z0-9_~\\-]+$"New value: +"^[a-zA-Z0-9_~-]+$"

changedOutput schema / $schema

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

addedOutput schema / properties / tokenCount
```
Added value: +{
+  "type": "number"
+}
```

Changedjamf_docs_get_toc8 fields changed

changedInput schema / $schema

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

changedInput schema / properties / product / description

Previous value: -"Product ID: jamf-pro, jamf-school, jamf-connect, jamf-protect"New value: +"Product ID: jamf-pro, jamf-school, jamf-connect, jamf-protect, jamf-now, jamf-safe-internet, jamf-insights, jamf-rapididentity, jamf-trust, jamf-routines, self-service-plus, jamf-app-catalog"

changedOutput schema / $schema

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

addedOutput schema / properties / mapId
```
Added value: +{
+  "type": "string"
+}
```
addedOutput schema / properties / paginationNote
```
Added value: +{
+  "type": "string"
+}
```
addedOutput schema / properties / productId
```
Added value: +{
+  "type": "string"
+}
```
addedOutput schema / properties / versionNote
```
Added value: +{
+  "type": "string"
+}
```

changedOutput schema / required

Previous value: -[
-  "product",
-  "version",
-  "totalEntries",
-  "page",
-  "totalPages",
-  "hasMore",
-  "entries"
-]New value: +[
+  "product",
+  "productId",
+  "version",
+  "totalEntries",
+  "page",
+  "totalPages",
+  "hasMore",
+  "entries"
+]

Changedjamf_docs_glossary_lookup3 fields changed

changedInput schema / $schema

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

changedInput schema / properties / product / description

Previous value: -"Filter by product: jamf-pro, jamf-school, jamf-connect, jamf-protect"New value: +"Filter by product: jamf-pro, jamf-school, jamf-connect, jamf-protect, jamf-now, jamf-safe-internet, jamf-insights, jamf-rapididentity, jamf-trust, jamf-routines, self-service-plus, jamf-app-catalog"

changedOutput schema / $schema

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

Changedjamf_docs_list_products2 fields changed

changedInput schema / $schema

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

changedOutput schema / $schema

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

Changedjamf_docs_search6 fields changed

changedInput schema / $schema

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

changedInput schema / properties / product / description

Previous value: -"Filter by product: jamf-pro, jamf-school, jamf-connect, jamf-protect"New value: +"Filter by product: jamf-pro, jamf-school, jamf-connect, jamf-protect, jamf-now, jamf-safe-internet, jamf-insights, jamf-rapididentity, jamf-trust, jamf-routines, self-service-plus, jamf-app-catalog"

changedOutput schema / $schema

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

addedOutput schema / properties / filters

Added value: +{
+  "additionalProperties": false,
+  "properties": {
+    "docType": {
+      "type": "string"
+    },
+    "language": {
+      "type": "string"
+    },
+    "product": {
+      "type": "string"
+    },
+    "topic": {
+      "type": "string"
+    },
+    "version": {
+      "type": "string"
+    }
+  },
+  "type": "object"
+}

addedOutput schema / properties / limit
```
Added value: +{
+  "type": "number"
+}
```
addedOutput schema / properties / paginationNote
```
Added value: +{
+  "type": "string"
+}
```

5 tool updatesv3.0.34Jun 18, 2026
- Addedjamf_docs_get_article
- Addedjamf_docs_get_toc
- Addedjamf_docs_glossary_lookup
- Addedjamf_docs_list_products
- Addedjamf_docs_search
5 tool updatesv3.0.30Jun 16, 2026
- Removedjamf_docs_get_article
- Removedjamf_docs_get_toc
- Removedjamf_docs_glossary_lookup
- Removedjamf_docs_list_products
- Removedjamf_docs_search
6 tool updatesv3.0.25May 28, 2026
- First observedjamf_docs_batch_get_articles
- First observedjamf_docs_get_article
- First observedjamf_docs_get_toc
- First observedjamf_docs_glossary_lookup
- First observedjamf_docs_list_products
- First observedjamf_docs_search

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

A4.5/5.0

Scored 2026-09-15 14:20 across 6 tools

Disambiguation5/5

Each tool serves a clearly distinct purpose: single article retrieval, batch retrieval, search, TOC browsing, glossary lookup, and product/listing. The only potential overlap is get_article vs batch_get_articles, but their single-vs-multiple distinction is explicit and unambiguous.

Naming Consistency4/5

All tools share the jamf_docs_ prefix)Skip prefix. Most follow a verb_noun form (get_article, list_products, get_toc, batch_get_articles), but glossary_lookup inverts the order and search is a bare verb, introducing minor inconsistency.

Tool Count5/5

Six tools is a well-scoped size for a documentation browsing server. Each tool adds clear value and there is no redundancy or bloat.

Completeness5/5

The tool surface covers the full documentation workflow: discover products/publications, browse the TOC, search for articles, fetch single or multiple articles, and look up glossary terms. No obvious gaps for the stated purpose of accessing Jamf docs.

Maintenance

ActivityActive

ResponsivenessResponsive

Resources

Need Help?

Related Servers

Related MCP Connectors

docs A
com.ntop
Search and query nTop's knowledge base and engineering guides from AI applications.
Search Documentation Access
32
developer-toolkit-mcp A
io.github.mjaskolski
The documentation, as a tool your agent can call: 950+ AI-dev guides. Search + fetch tools.
AI & Machine Learning Search
21
llmref A
org.llmref
Versioned documentation registry and semantic search for AI tools and coding assistants.
Documentation Access Search Developer Tools
42
developer-tools A
goog.workspace-developer
Provides tools for searching Google Workspace documentation and much more.
Developer Tools Documentation Access Search
22

Related MCP Servers

Adobe Experience League MCP
Documentation Access Search Content Management Systems
vinnyang
F
license
Not graded
quality
D
maintenance
Enables AI assistants to search and fetch documentation content from Adobe Experience League, allowing natural language queries to retrieve Adobe product documentation and articles.
Updated 10 months ago (2025-11-16 03:46 UTC)
-
Apple Dev MCP Server
Documentation Access Developer Tools Software Architecture
tmaasen
A
license
B
quality
F
maintenance
Provides AI assistants with access to Apple's Human Interface Guidelines and technical API documentation across all Apple platforms (iOS, macOS, watchOS, tvOS, visionOS), enabling unified search of design principles and implementation details.
Updated a year ago (2025-08-01 12:27 UTC)
3
81 npm
21
MIT
Apple Docs MCP
Documentation Access Developer Tools Search
kimsungwhee
A
license
A
quality
D
maintenance
Provides access to Apple's official developer documentation, frameworks, APIs, and WWDC session transcripts across all Apple platforms. It enables AI assistants to search technical guides, sample code, and platform compatibility information using natural language queries.
Updated 6 months ago (2026-03-17 02:39 UTC)
18
565 npm
1,378
MIT
jam-nodes-docs-mcp
Documentation Access Developer Tools
KNQuoc
A
license
A
quality
D
maintenance
Enables AI agents to search and retrieve jam-nodes documentation, including node info, API references, and guides, via MCP tools without loading everything into context.
Updated 7 months ago (2026-02-15 19:51 UTC)
5
1
MIT

Jamf Docs MCP Server

Installation

Quick Start

Claude Desktop

Claude Code (CLI)

Cursor

Verify Installation

Usage Examples

Available Tools

jamf_docs_list_products

jamf_docs_search

jamf_docs_get_article

jamf_docs_get_toc

jamf_docs_batch_get_articles

jamf_docs_glossary_lookup

MCP Resources

MCP Prompts

jamf_troubleshoot

jamf_setup_guide

jamf_compare_versions

Supported Products

Key Features

MCP Apps (interactive viewer)

Design

Inline and fullscreen

Article navigation

Developing the viewer

HTTP/SSE Transport Mode

Starting the HTTP Server

CLI Arguments

HTTP Endpoints

Connecting an MCP Client via HTTP

CORS Configuration

Rate Limiting

Configuration

Cache Settings

Request Settings

HTTP Transport Settings

Development

Available Scripts

License

Disclaimer

Links

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Tool Schema Changelog

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

`jamf_troubleshoot`

`jamf_setup_guide`

`jamf_compare_versions`