Prints the configuration of the Sitecore MCP server. Secrets (passwords, the GraphQL API key, the authorization header) are redacted.

Explores the Sitecore GraphQL 'edge' schema. With no arguments it returns the root operations plus the Item interface — the whole contract for querying this endpoint, a couple of KB. Use type: "" for one type in full, search: "" to find one, and full: true only when you genuinely need every definition: a delivery schema's full SDL measured 777,501 characters (~194,000 tokens) on a live CM, two thirds of it repeated descriptions. Prefer the typed item/presentation tools when one already answers the question, and authoring-get-item-template or common-get-item-field to read a template's fields — both are far cheaper than the generated per-template types here.

Executes a GraphQL query against the Sitecore 'edge' endpoint and returns the data as JSON. The query is syntax-checked before it is sent. Note what the endpoint can see: 'edge' serves published content only (unpublished master changes are invisible to it), while 'master' / preview schemas read the authoring database. Use introspection-graphql-edge for the schema SDL.

Explores the Sitecore GraphQL 'master' schema. With no arguments it returns the root operations plus the Item interface — the whole contract for querying this endpoint, a couple of KB. Use type: "" for one type in full, search: "" to find one, and full: true only when you genuinely need every definition: a delivery schema's full SDL measured 777,501 characters (~194,000 tokens) on a live CM, two thirds of it repeated descriptions. Prefer the typed item/presentation tools when one already answers the question, and authoring-get-item-template or common-get-item-field to read a template's fields — both are far cheaper than the generated per-template types here.

Executes a GraphQL query against the Sitecore 'master' endpoint and returns the data as JSON. The query is syntax-checked before it is sent. Note what the endpoint can see: 'edge' serves published content only (unpublished master changes are invisible to it), while 'master' / preview schemas read the authoring database. Use introspection-graphql-master for the schema SDL.

Explores the Sitecore Authoring and Management GraphQL schema (items, templates, media, sites, search, publishing, jobs, indexing, workflow, security, identity). With no arguments it returns the operation index: 127 queries and mutations, one line each. Use type: "" for one operation or type in full — for an operation the input types its arguments need are included, so one call is enough to write the document — search: "" to find an operation by what it does, and full: true for the entire SDL (117,188 characters on a live CM). Most of this schema has no typed authoring-* tool, so this is how you find the rest: createUser, createSite, executeWorkflowCommand, addLanguage, archiveItem, cancelPublishing and around a hundred more. Not the Edge schema — that is introspection-graphql-*.

Executes any query or mutation against the Sitecore Authoring and Management GraphQL API and returns the data as JSON. The document is syntax-checked before it is sent. Unlike the Edge endpoint, this one reads and writes the authoring databases, so unpublished content is visible and mutations take effect immediately. Prefer a typed authoring-* tool when one covers the operation; use this for the rest of the schema, with authoring-introspect-schema for the SDL. The API supports no subscriptions, and rejects GET — everything goes over POST, which this tool does for you.

Reads a Sitecore item by ID or path over the Authoring and Management API, returning its identity, template and field values. Reads the authoring database, so unpublished content is visible — unlike the Edge query tools. Supply exactly one of id or path.

Creates a Sitecore item from a template over the Authoring and Management API and returns the created item. The parent must be given as a GUID (the API takes no parent path here) — use authoring-get-item to resolve a path to its ID first.

Sets field values on an existing Sitecore item over the Authoring and Management API. Only the fields named are touched; set reset true on a field to return it to its template's standard value instead of writing a value. Supply exactly one of id or path.

Deletes a Sitecore item over the Authoring and Management API. By default the item goes to the recycle bin and can be restored; permanently true destroys it outright. Deleting an item deletes its descendants with it. Supply exactly one of id or path.

Copies a Sitecore item to another parent over the Authoring and Management API. Copies the whole subtree by default; set deepCopy false to copy the item alone. Supply exactly one of id or path for the source, and exactly one of targetParentId or targetParentPath for the destination.

Moves a Sitecore item to another parent over the Authoring and Management API, taking its descendants with it. Every link to the item survives the move — prefer this over delete-and-recreate, which breaks them. Supply exactly one of id or path, and exactly one of targetParentId or targetParentPath.

Renames a Sitecore item over the Authoring and Management API. The item keeps its ID, so links to it survive, but its path changes and any URL derived from the name changes with it. Supply exactly one of id or path.

Searches a Sitecore index over the Authoring and Management API and returns matching items. Criteria combine on the operator you give each one: MUST is AND, SHOULD is OR, NOT excludes. Useful system fields: '_name', '_fullpath' (the item path), '_path' (matches items under an ancestor, given that ancestor's ID with no braces or dashes), '_template' and '_templatename'. IDs in index values are lowercase and unpunctuated, e.g. '110d559fdea542ea9c1c8a5df7e70ef9'. Returns 10 results unless pageSize says otherwise. A '_path' criterion is the cheap way to read a whole subtree at any depth — one query where item-service-get-item-descendants makes one request per node — at the cost of returning identity fields rather than field values, from the index rather than the database.

Reads a Sitecore data template over the Authoring and Management API, returning its sections and field definitions (name, type, source). Call this before authoring-create-item to learn which fields a template accepts, or before authoring-update-item-template to get the section and field IDs an update needs. Sections report their ID as itemTemplateSectionId; an update supplies that same value as templateSectionId. Supply exactly one of templateId or path.

Creates a Sitecore data template, with its sections and fields, in one call over the Authoring and Management API. The parent must be a GUID — the folder under /sitecore/templates the template belongs in. Field types are Sitecore's own names, e.g. 'Single-Line Text', 'Rich Text', 'Image', 'General Link', 'Droptree'.

Updates a Sitecore data template over the Authoring and Management API. Sections and fields carrying an ID are updated; those without one are created. Matching is by ID only, never by name: to add a field to a section that already exists you must pass that section's templateSectionId (read it as itemTemplateSectionId from authoring-get-item-template), otherwise the call is rejected for creating a second section of the same name. Nothing is removed unless deleteMissingFields is true — and when it is, every section and field absent from this call is deleted, along with the content stored in them, so read the template first.

Uploads a file into the Sitecore media library over the Authoring and Management API and returns the created media item. Does both halves of the documented flow: asks uploadMedia for a pre-signed URL, then POSTs the bytes to it. Source is exactly one of sourceUrl (fetched by this server — use this to import from a live site), filePath (local to the machine running this MCP server), or content (base64). Needs no SPE Remoting, unlike media-upload.

Reads a media item over the Authoring and Management API, returning its identity, mime type, size and URL. Use it after authoring-upload-media to get the ID an image field value needs, or to check what is already in the media library. Supply exactly one of id or path.

Lists the sites configured on the Sitecore instance over the Authoring and Management API, with each site's root path, start path and root item ID. Usually the first call when working on an instance you have not seen: the root item ID is what authoring-search scopes a subtree search by, and the root path is what item paths hang off. System sites (shell, admin, login and the rest) are hidden unless includeSystemSites is set.

Reads one site's configuration by name over the Authoring and Management API — paths, database, language, device and the editing switches. Use authoring-list-sites first if you do not know the site's name.

Queues a publish of one or more items over the Authoring and Management API and returns an operationId. Publishing is asynchronous — the call returns as soon as the job is queued, so poll authoring-publishing-status with the operationId before reporting that content is live. On SitecoreAI the target is 'experienceedge'; on XM/XP it is usually 'web'. Supply exactly one of rootItemIds or rootItemPaths.

Reads the status of a publish queued by authoring-publish-item. Returns state (INITIALIZING, QUEUED, RUNNING, ABORTREQUESTED, ABORTED, FINISHED, UNKNOWN), isDone, isFailed and how many items have been processed. Poll this until isDone before treating published content as live.

Starts a rebuild of one or more Sitecore search indexes over the Authoring and Management API and returns the jobs it queued. A full rebuild of sitecore_master_index is expensive and leaves search results incomplete while it runs, so prefer it only when the index is actually stale. Poll the returned job names with authoring-get-job. Use authoring-graphql with 'query { indexes { nodes { name } } }' to list the index names.

Reads one Sitecore background job by name or handle over the Authoring and Management API, returning its state, progress and messages. This is how you find out whether an index rebuild or other queued operation finished. Supply exactly one of jobName or handle.

Lists Sitecore background jobs over the Authoring and Management API. jobName accepts wildcards: '' for every job, 'myjob' for names starting with it, '*myjob' for names ending with it, 'myjob' for names containing it. Omit jobName to list them all. Use this to find out what the instance is busy with, or to locate a job whose exact name you do not know.

Get a Sitecore item by its ID or path.

Get the direct children of a Sitecore item by its ID, with all their fields. Pass options.fields to return only the fields you need — the full form is roughly 1.9KB per child.

Create a new Sitecore item under parent path with name using template id.

Edit a Sitecore item by its ID.

Delete a Sitecore item by its ID.

Search Sitecore items using the ItemService RESTful API. The endpoint's facet breakdown is omitted unless includeFacets is set — it accounted for 96% of the response on a live CM and is rarely what the caller is after.

Gets every descendant of a Sitecore item by ID, with all their fields. Walks the tree client-side: one request per node, issued sequentially, so a large subtree costs seconds to minutes and returns an unpaged result. For structure only (paths, names, templates) at any depth, authoring-search with a '_path' criterion is one indexed query instead. Truncates at DESCENDANTS_MAX_ITEMS (5000) and says so. See the guide://tool-selection resource.

Get Sitecore languages.

The Sitecore PowerShell Extensions command reference, for writing run-powershell-script scripts. Reveals progressively rather than returning the whole ~510KB corpus: call it with NO arguments first for an index of all 129 commands with one-line summaries, then call it again with 'command' for the full page — syntax, every parameter, and examples — of the one or few you need. 'search' matches names, summaries and page bodies when you know what you want to do but not which cmdlet does it; 'category' lists one group. Do not fetch pages you are not about to use.

Runs a PowerShell script and returns the output. Before writing a script that changes many items, read the guide://bulk-update resource: it carries the pattern a mass write needs (every ID resolved from the instance, a named subtree as the root, a dry run the user approves, BeginEdit/EndEdit with a per-item try/catch).

Lists the renderings a placeholder allows on a given page, read from the placeholder settings items that govern it. Call this before adding a rendering: a placeholder that forbids a component will still accept it silently, and the page will render. Resolves site-level settings first (/Presentation/Placeholder Settings) and falls back to the global tree (/sitecore/layout/Placeholder Settings/Project/...); settingsItemPath in the result says which item answered. Handles dynamic placeholders: a runtime path like /headless-main/page-section-1/container-2 is matched on its leaf segment against wildcard keys such as container-{*}. Allowed control IDs that resolve to no item are reported under 'Unresolved' rather than dropped silently — that is a content defect worth seeing. Found=false means no settings item governs the key, so check the spelling before treating it as unrestricted.

Creates the datasource item for a component, using the Datasource Template and Datasource Location declared on the rendering itself. placement='page-local' (default) creates /Data/ and returns the layout reference form 'local:/Data/' that authored pages use; placement='shared' resolves the rendering's pipe-separated Datasource Location candidates in order and creates the item in the first that exists, returning the item ID to reference it by. Fails naming every candidate it tried when none resolves, rather than guessing at a location. Pass the field values in 'fields' and they are set on the new item.

Adds a rendering to a placeholder on a page, refusing it when the placeholder's settings do not allow that component (the allow-list is named in the error). This is the tool to compose a page with: presentation-add-rendering writes whatever it is told, and an invalid layout still saves and renders. Assigns a collision-free DynamicPlaceholderId when the rendering's parameters template defines one, and writes the full parameter set the template declares. Returns the placeholder path a child rendering should target, so a nested build is one call per level. Pass force=true to skip validation for migration or repair work. Read the guide://compose-page resource for the order to run the composition tools in, and for the dynamic placeholder, splitter and GridParameters cases that silently produce a broken page when guessed at.

Lists the content sites registered on this CM: name, root path, start (home) path, database, hostname and the root item's ID and template. Sitecore's own infrastructure sites (shell, login, service, ...) are filtered out; pass includeSystemSites to see everything Sitecore has registered. Note that 'website' is reported — on XM/XP it is the content site, and on a SitecoreAI CM it shows up rooted at /sitecore/content alongside the real content sites.

Returns one site's definition plus the paths the composition tools need: the home item, the site-level Placeholder Settings root, the Available Renderings root, the shared Data folder, the site definition item, and the project (tenant) folder used to resolve global placeholder settings. Address the site by name, or by any item path inside it.

Lists the pages of a site. Returns { Matched, Returned, Truncated, Root, SiteName, Pages: [{ ID, Path, Template, TemplateID }] }. An item counts as a page when it has presentation (a layout on the item or on its template's standard values), which is what makes it addressable as a page — not a guess from template naming.

Searches a site's pages by name or title, case-insensitively, on a substring match against Name, display name, Title and NavigationTitle. Returns { Matched, Returned, Truncated, Root, SiteName, Pages: [{ ID, Path, Template, TemplateID }] }. An item counts as a page when it has presentation (a layout on the item or on its template's standard values), which is what makes it addressable as a page — not a guess from template naming.

Lists the renderings a site makes available, grouped by its Available Renderings groups (Page Content, Page Structure, FEaaS, Forms, Global on a Stride site). This is the site's component inventory, NOT an allow-list: the groups do not determine where a rendering may be placed. Use get-allowed-components-by-placeholder for that. IDs that resolve to no item are reported under Unresolved per group.

Lists the insert options configured for an item — the templates and branches that may be created under it — read from its __Masters field (which inherits from the template's standard values). Each row reports Kind: 'Branch' items copy a whole subtree, 'Template' items create a single item. Note that insert rules are not evaluated (the uiGetMasters pipeline the Content Editor runs is not available on an SitecoreAI CM), so a project that uses them may see more options in the editor than are listed here. IDs that resolve to no item are reported under Unresolved.

Get the current Sitecore user.

Creates a new Sitecore user.

Removes the Sitecore user.

Disables the Sitecore user account.

Enables the Sitecore user account.

Unlocks a Sitecore user account that has been locked out due to failed login attempts.

Updates properties of a Sitecore user account.

Sets a new password for a Sitecore user. Supply either 'oldPassword' (validated before the change) or 'resetPassword: true' (an administrative reset that does not need the current password) — SPE offers no third way to change a password.

Get Sitecore domains. Omit name to return every domain.

Get Sitecore users, by exact identity or by wildcard filter. Supply exactly one of identity or filter.

Get Sitecore roles, by exact identity or by wildcard filter. Supply exactly one of identity or filter.

Get members of a Sitecore role.

Adds a member to a Sitecore role.

Removes members from a Sitecore role.

Creates a new Sitecore role.

Removes a Sitecore role.

Creates a new Sitecore domain.

Removes a Sitecore domain.

Tests if a Sitecore user exists and has specific properties.

Gets the access control list (ACL) of a Sitecore item — the rules set on the item itself. Narrow it with identity or filter to one account.

Tests whether a user or role has specific access rights to a Sitecore item.

Changes the access rules on a Sitecore item. action 'add' appends one rule and leaves the others; 'replace' discards every existing rule on the item and leaves only this one; 'clear' removes all rules and adds nothing. Read the current rules with security-get-item-acl and check effective rights with security-test-item-acl.

Locks or unlocks a Sitecore item for editing. Independent of delete protection — use security-set-item-protection for that.

Protects or unprotects a Sitecore item against deletion and renaming. Independent of the editing lock — use security-set-item-lock for that.

Exports (serializes) a Sitecore user or role to the CM's own filesystem and returns the file path. Requires SPE 8.0 or later — earlier versions fail with a NullReferenceException (SPE issues #1369, #1370). On SitecoreAI prefer Sitecore CLI serialization.

Imports (deserializes) a Sitecore user or role from the CM's filesystem, overwriting the account's current state with the serialized one. The .user / .role file must exist — export it first with security-export-account. On SitecoreAI prefer Sitecore CLI serialization.

Creates a version of the item in a new language based on an existing language version.

Converts an item from a clone to a fully independent item.

Gets information about Sitecore caches, with their size and occupancy. Omit name to return every cache. Cache names contain square brackets ('master[items]'); pass one exactly as reported and it is matched literally, or use * / ? for a wildcard.

Gets information about Sitecore databases.

Returns all the clones for the specified item.

Gets item fields as either names or fields or template fields.

Gets item references for a Sitecore item, showing where it is used throughout the system.

Gets items referring to a Sitecore item, showing which items reference it.

Gets template information for a Sitecore item.

Gets entries from the workflow history for the specified item.

Gets the current Sitecore jobs with their state and progress. Get-SitecoreJob takes no arguments, so every job is returned; read State and IsDone to find the one you want.

Executes workflow action for a Sitecore item.

Creates a new entry in the workflow history for a Sitecore item.

Publishes a Sitecore item. On SitecoreAI there is no web database — content publishes to Edge, which lives on Sitecore's cloud servers only, so this works on deployed environments but a local development CM has no publishing target.

Removes a version of a Sitecore item.

Resets item fields, specified as either names, fields or template fields.

Restarts the Sitecore Application pool.

Sets the item template.

Checks if the item inherits from the specified template.

Adds or removes a base template on a template item. Removing one takes its fields off every item built from the template, along with their values.

Gets Sitecore database archives.

Gets a page of the items found in the specified archive, with the archive's total entry count. Returns the 100 most recently archived entries unless first/skip say otherwise.

Creates a new item clone based on the item provided.

Removes items permanently from the specified archive.

Restores items to the original database from the specified archive.

Updates all references to the specified item to point to a new provided in the -NewTarget or removes links to the item.

Gets the layout definition item assigned to an item -- the Sitecore layout item itself (e.g. 'Headless Layout'), not the renderings placed on the page. Use presentation-list-renderings to see a page's components.

Resets the layout of an item.

Merges final and shared layouts of an item.

Gets a layout device by name, or the default device when name is omitted. On a headless site there is usually only the Default device.

Gets rendering definition on an item.

Removes renderings from an item.

Gets placeholder setting assigned on an item.

Removes placeholder setting from an item.

Lists the renderings placed on an item — the components that make up the page. This is the tool to use to see a page's composition; presentation-get-layout returns the assigned layout definition item instead. Returns one row per rendering: Index (position in the device's rendering list, which is what presentation-add-rendering and presentation-set-rendering address), Placeholder (the full placeholder path), RenderingName, RenderingID, Datasource and UniqueId. Set includeParameters to add each rendering's Parameters.

Sets layout for an item.

Adds a rendering to presentation of an item. Writes whatever it is told: use get-allowed-components-by-placeholder first, or add-rendering-to-placeholder, if the layout has to stay valid.

Updates a rendering placed on an item with new values.

Switches an existing rendering on an item with an alternate one. The switched instance gets a NEW uniqueId (SPE regenerates it); the tool returns one row per switched instance with the new UniqueId, RenderingID, Placeholder and Datasource — use that UniqueId for any follow-up call, the old one no longer exists.

Adds a placeholder setting to an item.

Gets rendering parameter for a rendering placed on an item.

Removes the specified rendering parameter from the rendering placed on an item.

Adds and updates the specified rendering parameter from the rendering placed on an item.

Retrieves Sitecore logs from the CM's data folder over SPE. On a local Docker CM the same files are on a mounted volume, so reading them from disk is cheaper and shows the whole file; use this when you have no filesystem access to the CM. On a deployed SitecoreAI environment the platform collects logs and the data folder may hold little or nothing.

Gets a Sitecore item by path, ID, Sitecore query or URI.

Get information about Sitecore search indexes, addressed by name. SPE's Get-SearchIndex takes no other filter, so filter the returned rows rather than asking the CM to. IndexingState (Started / Stopped) is reliable; the Summary fields (NumberOfDocuments, IsHealthy, IsClean, OutOfDateIndex) come from the search provider and are not dependable everywhere — on an XM Cloud CM, where every index shares one Solr core, NumberOfDocuments reads 0 and IsHealthy false on an index that is serving queries perfectly well. Run an actual query with indexing-find-item before concluding an index is broken.

Finds items through the Sitecore Content Search API over SPE. Prefer authoring-search where it is available: it needs no SPE, scopes to a subtree with a '_path' criterion, and pages with a real total. For published content, a search query through query-graphql- is also cheaper than this. Reach for this tool when neither is configured, or when you need an index this server's other surfaces cannot address by name. Dates are ISO 8601 (e.g. '2023-10-01T00:00:00Z'). Returns Skip, First, Returned, HasMore and Items; HasMore is how you know to page, since Content Search reports no total.

Rebuilds Sitecore search indexes. Omit id and path to rebuild whole indexes — and omit name too to rebuild every index, which is expensive and leaves search results incomplete while it runs. Supply id or path to rebuild only that item's subtree, which is what you want after changing a branch of content. Pass asJob to queue it and poll with common-get-sitecore-job rather than waiting.

Suspends, stops or resumes Sitecore search indexes. Omit name to act on every index in the matching state. To rebuild an index use indexing-rebuild-search-index; to read the current state use indexing-get-search-index.

Uploads a file into the Sitecore media library via the SPE mediaUpload service and returns the created media item (ID, path, size, mime type). Overwrites an existing item at the destination unless skipExisting is set. Source is exactly one of sourceUrl (fetched by this server — use this to import from a live site), filePath (local to the machine running this MCP server), or content (base64). Requires in the CM's SPE services config.

Downloads a media item's blob from the Sitecore media library via the SPE mediaDownload service. Pass saveTo to write it to a file local to the machine running this MCP server (always do this for anything over ~0.5MB); without saveTo the blob is returned inline as base64, capped at maxBytes. Requires in the CM's SPE services config.