What can you do with this server?

The Jamf Docs MCP Server gives AI assistants direct access to official Jamf documentation from docs.jamf.com and learn.jamf.com, enabling intelligent search, retrieval, and exploration of Jamf product documentation. * Search documentation: Search across all Jamf product docs by keyword, with filters for product, topic, document type, version, and language; supports pagination and returns ranked snippets. * Retrieve articles: Fetch full content or specific sections of a documentation article; options for summary preview, related articles, and token-limited responses. * Browse table of contents: Get the navigation structure for a specific Jamf product and version. * Batch fetch: Retrieve up to 10 articles in a single concurrent request. * Glossary lookup: Find Jamf terminology definitions using fuzzy matching. * List products and filters: View all supported Jamf products, topics, and document types. * MCP prompts: Leverage pre-built workflows for structured troubleshooting, generating setup guides, and comparing product versions. * MCP resources: Access static/dynamic reference data (product lists, topics, TOCs, versions) without tool calls. * Multi-language support: Pass a language parameter (e.g., en-US, ja-JP, de-DE, zh-TW) for localized documentation. * Output configuration: Control response detail (full/compact), format (markdown/JSON), and token limits. * HTTP/SSE transport: Run the server as a remote endpoint with rate limiting, CORS, and health checks, in addition to stdio mode. * Client integrations: Compatible with Claude, Cursor, and other MCP clients via stdio or HTTP.

How do I use Jamf Docs MCP Server?

1. Click on "Install 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 Related Servers Score Discussions

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: 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

中文文件

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
`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`, `install-guide`, `technical-paper`, `configuration-guide`, `training`
`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
`jamf-app-catalog`	Jamf App Catalog	Curated application catalog for managed deployments

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 release-notes, install-guide, technical-paper, configuration-guide, or training
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.

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 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
`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.8/5.0

Behavior5/5

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

Annotations already indicate readOnly, openWorld, idempotent, and non-destructive behavior. The description adds valuable context beyond annotations: parallel execution with concurrency control, independent success/failure per article, partial failure reporting without failing the batch, and token budget distribution. No contradiction 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 well-structured with Args, Returns, Examples, and Note sections. Every sentence adds useful information: constraints, defaults, behavioral notes, and examples. Despite its length, it is appropriately sized for a tool with six parameters and complex batch behavior, and it is front-loaded with the primary purpose.

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 (batch retrieval, concurrency, token budget, partial failures), the description covers all essential aspects: input constraints, parameter defaults, return format details, example usage, and fallback behavior. The presence of an output schema reduces the need to enumerate return fields, but the description still summarizes the return structure adequately.

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?

Every parameter in the schema has a description, and the tool description elaborates further with semantics such as 'Distributed evenly' for maxTokens, 'Use compact for brief output', and constraints like 'must be from docs.jamf.com or learn.jamf.com' for URLs. The description adds meaning beyond the schema's property 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 the tool retrieves multiple Jamf documentation articles in a single request, using a specific verb and resource. It explicitly mentions fetching up to 10 articles in parallel, which distinguishes it from the sibling tool jamf_docs_get_article that likely handles single 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?

The description provides clear use cases: 'useful for comparing articles, gathering information from multiple pages, or bulk research.' It does not explicitly mention when not to use it or name alternative tools, but the context is sufficient for an agent to decide. A slightly lower score is given for missing explicit exclusions or alternatives.

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
`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.4/5.0

Behavior5/5

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

Annotations already mark this as read-only, idempotent, and non-destructive, but the description adds important behavioral context beyond that: it mentions 'Large articles are intelligently truncated with remaining sections listed,' lists possible errors (404, invalid URL, section not found), and clarifies that summaryOnly is a token-efficient preview. These details help the agent predict and handle edge cases without contradicting any 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 well-structured with clear sections (Args, Returns, Examples, Errors, Note) and is front-loaded with the main purpose. While it is lengthy, every section serves a purpose, and the JSON return example is useful given the tool's complexity. It is slightly redundant with the schema (e.g., listing default values), but that redundancy is acceptable for discoverability.

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, sibling tools), the description is highly complete. It covers return formats, error handling, truncation behavior, and provides multiple usage examples. The existence of an output schema does not reduce the value of the description's own Returns section, which clarifies how each parameter affects the response.

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 schema descriptions cover 100% of parameters, so baseline is 3. The description adds examples and explains token efficiency, but its Args list omits mapId, contentId, and language, and incorrectly labels url as 'required' when the schema has no required fields. This misleading detail undermines the added value, making it a net-neutral contribution beyond the schema.

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 the full content of a specific Jamf documentation article.' It uses a specific verb (retrieve) and resource (article), and distinguishes itself from siblings like search, list_products, and get_toc by focusing on fetching a known article's content.

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?

Provides clear context on when to use the tool: 'Works with any article from docs.jamf.com or learn.jamf.com.' Includes examples (e.g., full article, specific section, maxTokens) and a note about using the section parameter for long articles. However, it does not explicitly mention alternative tools like search or list_products, so it stops short of giving exclusionary guidance.

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 a Jamf product's documentation.

This tool retrieves the navigation structure for a specific Jamf product, allowing you to browse available documentation topics.

Args:

product (string, required): 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
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, "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`	Yes	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
`version`	No	Specific version (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
`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
`mapId`	No
`entries`	Yes
`hasMore`	Yes
`product`	Yes
`version`	Yes
`productId`	Yes
`totalPages`	Yes
`versionNote`	No
`totalEntries`	Yes
`paginationNote`	No

TDQS

A4.7/5.0

Behavior5/5

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive, but the description adds substantial behavioral context: it explains the return structure (mapId, contentId, tokenInfo, pagination), how outputMode affects nesting, how structuredContent flattens the TOC with depth values, and how markdown vs JSON differ in exposing contentIds. It also discloses error types and the relationship with jamf_docs_get_article. This goes well beyond the 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?

Though long, the description is efficiently structured with clear sections (Args, Returns, Examples, Errors, Note). Every sentence adds functional value: parameter details, return format, usage examples, error handling, and cross-tool integration. The opening sentence front-loads the purpose, and the note clarifies edge cases without 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 tool's complexity—7 parameters, multiple output formats, pagination, structuredContent behavior, and integration with jamf_docs_get_article—the description is remarkably complete. It covers all aspects an agent needs: what it does, when to use it, how parameters affect behavior, what the return looks like, errors, and examples. The presence of an output schema does not reduce the need for this contextual detail, and the description delivers it fully.

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 7 parameters with descriptions, enum values, and defaults, so baseline is 3. The description adds meaningful nuance beyond the schema, such as clarifying that outputMode='compact' gives 'flat list without nested children' (schema just says 'brief output') and explaining how responseFormat affects whether contentIds are visible. It also shows example parameter combinations. This extra context justifies a 4.

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 specific verb+resource: 'Get the table of contents for a Jamf product's documentation.' It clearly distinguishes this from sibling tools by focusing on navigation structure and topic discovery rather than search or article retrieval. The purpose is unambiguous and immediately actionable.

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 explicitly states when to use the tool: 'Use this to discover what topics are available before searching or retrieving specific articles.' It also notes that large TOCs are paginated, implying you should handle pagination. While it doesn't explicitly contrast with every sibling tool, the discovery-first guidance is clear and useful.

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
`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
`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.7/5.0

Behavior5/5

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

Annotations already declare readOnlyHint and idempotentHint, but the description adds critical behavioral context: fuzzy matching, the English-only limitation for glossary content despite the language parameter, and the effect on results. It also discloses error messages and output structure, going well beyond the annotation baseline.

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 clear sections (main purpose, note, Args, Returns, Examples, Errors) and remains readable despite its length. Every sentence contributes meaningful information, and the core purpose is front-loaded with no redundant fluff.

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 and the presence of a full output schema, the description thoroughly covers selection criteria, invocation parameters, output formats, examples, and potential error messages. It fully equips an agent to select and invoke the tool correctly without needing to infer details.

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 descriptions cover all 6 parameters, but the description enriches them by explaining the English-only caveat for the language parameter, providing illustrative examples for term and product, and detailing the JSON return structure. This adds value beyond the schema's baseline.

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 with a specific verb and resource: 'Look up a term in the Jamf official glossary and get its definition.' It distinguishes itself from sibling tools like jamf_docs_search and jamf_docs_get_article by focusing exclusively on glossary terms and mentioning fuzzy matching.

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 clear context for when to use this tool: to look up glossary terms. It includes examples of natural language queries and offers parameters for filtering by product. However, it does not explicitly state when not to use it or directly name alternatives, falling short of the full 'when/when-not' guidance.

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 all available Jamf products, topics, and their documentation versions.

This tool returns information about all Jamf products with available documentation, including Jamf Pro, Jamf School, Jamf Connect, Jamf Protect, Jamf Now, Jamf Safe Internet, and more. Also lists available topic and docType filters for search.

Args:

maxTokens (number, optional): Maximum tokens in response 100-50000 (default: 5000)
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": [...], "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

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: 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
`topics`	Yes
`products`	Yes

TDQS

A4.2/5.0

Behavior4/5

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this with 'This is a read-only operation'. It adds useful behavioral context beyond annotations by explaining the return JSON structure, including tokenInfo with a truncated flag, and the difference between markdown and json output formats.

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 clear sections (Main purpose, Args, Returns, Examples, Note) and front-loads the core purpose. It is slightly verbose due to examples and return format details, but every part serves a purpose and no information is redundant.

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?

The description fully covers the tool's role and output. With an output schema present, it still explains both JSON and Markdown return formats, includes token truncation behavior, and gives concrete example queries. It also mentions docType filters, which connects to sibling search tools, making it contextually complete.

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 has 100% coverage for all three parameters with descriptions and defaults. The description restates the parameters but adds minimal new insight—mainly the implication that 'compact' mode yields a brief list. Since the schema already explains the parameters well, the description does not need to compensate significantly.

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 states 'List all available Jamf products, topics, and their documentation versions' with a specific verb and resource. It clearly differentiates from sibling tools like jamf_docs_search, which searches rather than lists. The scope is explicit, listing examples like Jamf Pro and Jamf School.

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?

Provides clear context and examples for when to use the tool: 'What Jamf products are available?' and 'What topics can I filter by?'. However, it does not explicitly mention alternatives or when not to use it, leaving room for a more direct comparison with sibling tools.

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
`version`	No	Filter by version (e.g., "11.5.0", "10.x")
`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
`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
`totalResults`	Yes
`relevanceNote`	No
`paginationNote`	No
`filterRelaxation`	No
`truncatedContent`	No

TDQS

A4.7/5.0

Behavior5/5

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

Beyond the annotations, the description discloses result ranking by relevance, error messages ('No results found', 'Invalid product ID'), the mapId/contentId behavior with fallback to URL, pagination limits, and output modes. This goes well beyond what annotations provide and fully informs the agent of behavioral nuances.

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?

Although long, the description is well-structured into clear sections (intro, Args, Returns, Examples, Errors, Note). Every section serves a purpose and is front-loaded with the core purpose. There is no redundant or filler content given the tool's complexity.

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?

The description is highly complete for a search tool with 11 parameters and an output schema. It covers all parameter semantics, return formats, error scenarios, pagination, and cross-references to sibling tools. The presence of an output schema does not diminish the need for the detailed examples and behavioral notes, which are provided.

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 already has 100% coverage with descriptions for all 11 parameters. The description adds value by providing concrete query examples, recommended filter combinations, and explaining the mapId/contentId usage for results, which enriches the semantic understanding beyond merely restating schema constraints.

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 verb 'Search' and the resource 'Jamf documentation' with explicit scope across all products. It distinguishes itself from siblings by noting that results carry mapId/contentId to pass to jamf_docs_get_article, and references jamf_docs_list_products for filter options.

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 clear context with example queries and recommended filters, and explicitly mentions alternatives like jamf_docs_get_article for direct article retrieval and jamf_docs_list_products for product IDs. However, it does not explicitly state when NOT to use this tool, though the examples imply typical usage.

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. Dates show when Glama detected each change.

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

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.5/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose: list products, search articles, retrieve a single article, retrieve a TOC, glossary lookup, and batch retrieval. There is no functional overlap that would confuse an agent.

Naming Consistency4/5

All tools share the 'jamf_docs_' prefix, and most follow a verb-first pattern (list_products, get_article, get_toc, batch_get_articles). The exception is 'glossary_lookup', which puts the noun before the verb, creating a slight inconsistency.

Tool Count5/5

Six tools is well-scoped for a documentation server, covering core browsing, searching, retrieval, and batch needs. Each tool earns its place without unnecessary bloat.

Completeness5/5

The surface covers the full documentation workflow: discovering products, exploring TOCs, searching with filters, retrieving individual articles, fetching multiple articles, and looking up glossary terms. No obvious gaps or dead ends.

Maintenance

ActivityActive

ResponsivenessSyncing

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

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
70
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
867
1,370
MIT
DevDocs MCP Server
Documentation Access Developer Tools Search
JavierDevCol
F
license
A
quality
D
maintenance
Provides AI models with direct access to documentation for over 600 technologies from DevDocs.io, including popular languages, frameworks, and tools. It enables comprehensive searching, content retrieval, and offline access via an intelligent local caching system.
Updated 8 months ago (2026-01-14 06:37 UTC)
12
2
-

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/GET-Technology-Inc/jamf-docs-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

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)

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

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

`jamf_troubleshoot`

`jamf_setup_guide`

`jamf_compare_versions`