Grooper MCP

2026 BETA

This article covers new or changed functionality in the current or upcoming beta version of Grooper. Features are subject to change before version 2026's GA release. Configuration and functionality may differ from later beta builds and the final 2026 release.

Model Context Protocol (MCP) support in Grooper allows the repository to act as both a provider and a consumer of MCP tools, resources, and prompts. These tools, resources and prompts are exposed in two ways.

• This lets external AI agents (such as coding assistants or custom automation) call directly into a Grooper Repository to access these tools, resources and prompts.
• This lets Grooper's own AI features (AI Assistants and Agent Actions) consume these same tools, resources and prompts and call out to external MCP servers and registries.

Overview

Model Context Protocol is an open standard for connecting AI applications to external tools, data sources, and prompts over a common interface. Grooper's implementation covers both directions:

• Serving tools: A Grooper Repository can expose a curated set of its own capabilities (repository management, Batch/document operations, scripting, external content repositories, search, statistics, and more) as an MCP server that any MCP-compatible client can connect to.
• Consuming tools: The Agent Planner used by AI Assistants and Agent Actions can connect out to external MCP servers and registries, bringing third-party tools into an agent's available toolset alongside Grooper's built-in tools.

Key objects involved

Display name	Object Type	Where you'll find it	Purpose
MCP Server	Node	Added inside a Project	Hosts a named collection of tools, resources, and prompts, and serves them to MCP clients.
MCP Registry	Node	Added inside a Project	Publishes local MCP Servers and/or aggregates outbound connections to other servers and registries.
AI Assistant	Node	Added inside a Project	A configurable chatbot whose Agent Planner can call MCP tools (via its own connections or a registry) alongside Grooper's built-in retrieval tools when answering a user.
Resource File	Node	Added inside a Project	A file-based resource (document, text, etc.) that can be added to an MCP Server's Resources list to expose it to MCP clients, or referenced by an Agent Planner as a knowledge resource.
Agent Action	Action	Submitted by an Action Scheduler or as a one-off Action Task by a user from the Actions page	Has an AI Assistant carry out a task following its own Instructions or a named MCP prompt. This allows the AI Assistant to run MCP tools without a live chat session.
Action Scheduler	Service Instance	Installed using GCC. Configured under Machines	The background service that runs "Scheduled Actions" (including Agent Actions) on a schedule or polling loop, and processes ad-hoc Action Tasks as they're submitted. This is what actually executes an unattended agent.

MCP Server

An MCP Server is added inside a Project and hosts three collections:

• Tools – the callable operations exposed by the server. Grooper ships a large built-in catalog of tools (see Built-in tool catalog below); a given server exposes whichever tools it's configured with.
• Resources – a list of Resource Files made available to clients.
• Prompts – a list of Prompt Template or Prompt Expression entries, each with a name, title, description, and parameters.

Other notable properties:

Property	Description
Namespace	Combines with the server's own name to form its unique identifier, in the form namespace/name.
Instructions	Free-text guidance returned when a client connects, used to steer client/model behavior when using this server.
Grooper Tool Categories	Tool categories made available locally to the agent planner.
Structured Data Mode	Controls how tool results are returned: Enabled (structured data only), Disabled (plain text content only), or Hybrid (both).
Tool List / Resource List / Prompt List	Read-only previews of exactly what the server will report to a connecting client – useful for verifying configuration.

MCP Registry

An MCP Registry has two complementary jobs:

1. Publishing – it exposes one or more local MCP Servers to the outside world under a single registry endpoint.
2. Aggregating – through its list of MCP Connections and MCP Registry Connections, it pulls in tools from other MCP servers and registries – local or remote – and merges them into one logical toolset.

This makes the registry the natural place to centralize and reuse connection configuration across multiple AI Assistants or agents, rather than configuring the same outbound connections repeatedly.

Both MCP Connection and MCP Registry Connection entries support:

• A Url and an Authentication method (Basic or OAuth Client Credentials) for reaching the remote server or registry.
• A Tool Filter (and, for registries, a Server Filter) – text patterns that narrow which tools (or servers) are actually pulled in, so an agent isn't handed a wider toolset than it needs.

AI Assistants and the Agent Planner

Every AI Assistant has an Agent Planner, configured through its Planner property. This is the component that actually decides which tools to call, and in what order, before responding to the user – or, for an Agent Action, before finishing an unattended run.

Local tools vs external tools

Local tools

The Agent Planner's own Tools, Resources and Prompts are locally native to Grooper. They are build from the exact same building blocks as an MCP Server's.

• Tools: The same built in tool catalog, including the "Grooper Tool Categories".
• Resources: The same capability to reference Resource Files is present.
• Prompts: The same capability to add Prompt Templates and Prompt Expressions is present.

In short, anything you can expose on a Grooper MCP Server, you can attach directly to an AI Assistant's Planner as a local tool resource or prompt. This is how Grooper's own agents get MCP-style tool access.

FYI

Note: The Agent Planner's Tools are a completely different mechanism from the Additional Tools property found directly on an AI Assistant. Additional Tools (Ask User, Help Search, Load Schema, Load Web Page, Wiki Search) is an older, retrieval-augmented-generation (RAG) feature built specifically for document/knowledge retrieval. It is not part of the MCP tool system described in this article. Do not confuse the two when reading an AI Assistant's configuration.

External tools

On top of its local Tools/Resources/Prompts, the AI Assistant's Planner can also reach out to MCP Servers and Registries it doesn't own. These are the same kind of outbound connections described under MCP Registry above:

• Servers: A list of MCP Connection entries, each pointing at one external MCP Server.
• Registries: A list of MCP Registry Connection entries, each pointing at one external MCP Registry.

In short, this is a way of stacking external MCP functionality on top of Grooper's own native functionality.

Other notable properties

Property	Description
Instructions	Guidance for the planner to follow when generating execution plans.
Maximum Plan Depth	The maximum number of tool calls the planner will chain together before truncating the plan.
Tool Selector	The strategy the planner uses to decide which of its available tools to actually offer for a given request.
Grooper Tool Categories	Tool categories made available locally, letting you scope the built-in catalog by area instead of listing individual tools one by one.
Local Tools Description / Local Tools Instructions	Extra descriptive text and usage guidance covering the planner's own local Tools, on top of each tool's own built-in description.

This whole flow – whether triggered by a live chat with an AI Assistant or by the Action Scheduler kicking off an Agent Action – comes down to: AI Assistant/Agent Action → Agent Planner → local Tools, and/or MCP Connection/MCP Registry Connection → an external MCP Server or Registry. Once the plan is built, the underlying language model doesn't distinguish between local and external tools – it just sees one combined list it can call.

How agents consume MCP tools

MCP support runs in two directions in Grooper, and it's easy to mix them up because several of the same objects (MCP Servers, MCP Connections, MCP Registries, MCP tools, etc.) show up on both sides. The two flows are:

• Grooper's own agents (AI Assistants and Agent Actions) consuming native Grooper tools and calling out to external MCP tools
• External AI clients calling into a Grooper MCP Server to consume Grooper tools.

Grooper's own agents calling out to MCP tools

This is the direction where an AI Assistant or Agent Action uses its Agent Planner to reach tools that aren't built into the chat itself – whether those tools are attached locally or live on another server entirely.

1. A user starts a chat with an AI Assistant, or the Action Scheduler kicks off an Agent Action (a scheduled or one-off unattended run). Either way, it's that assistant's Agent Planner that builds the execution plan.
2. The planner assembles its available toolset from two places:
   • Its own local Tools, Resources, and Prompts – see Agent Planner above.
   • External tools pulled in through the planner's Servers (MCP Connection) and Registries (MCP Registry Connection) entries, each narrowed by its own Tool Filter (and Server Filter, for a registry connection).
3. The underlying language model doesn't distinguish between local and external tools once the plan is built – it just sees one combined list it can call to answer the question or complete the task.

In short: AI Assistant/Agent Action → Agent Planner → local Tools, and/or MCP Connection/MCP Registry Connection → an external MCP Server or Registry.

External AI clients calling into a Grooper MCP Server

This is the mirror image: something outside Grooper – an AI coding assistant, a custom agent harness, or any other MCP-compatible application – connects in to a Grooper MCP Server (directly, or via an MCP Registry that publishes it) the same way it would connect to any other MCP server.

1. The client connects to the MCP Server's endpoint. The server responds with its Instructions property, giving the client/model guidance on how to use what it's about to see.
2. The client asks what's available, and gets back exactly what the Tool List, Resource List, and Prompt List properties describe – whichever subset of the built-in tool catalog, Resource Files, and Prompt Templates/Expressions that particular server was configured with.
3. The client calls tools the same way it would call any MCP tool, and gets results shaped by the server's Structured Data Mode (structured data, plain text, or both).

In short: an external AI client → a Grooper MCP Server (or a Registry publishing one) → Grooper's own repository tools, resources, and prompts.

This is a very practical way to work with Grooper: rather than a person clicking through the UI or hand-writing scripts against it, an AI client can be handed direct, structured access to repository objects, batches, jobs, and configuration – and because a server only ever exposes the tools it's explicitly configured with, an administrator controls exactly how much of that surface any given client is allowed to touch. (This article itself was researched this way – an AI assistant connected to a Grooper MCP Server and used its built-in tools to look up the real property names and behavior described throughout this page.)

Built-in tool catalog

Grooper ships a large catalog of built-in tools covering most of the repository's design and automation surface. They're grouped here by area, using the name each tool actually presents to a connecting client:

Area	Representative tools
Repository objects	Get Node, List Nodes, Add Child Nodes, Update Node, Copy Or Move Node, Reorder Node, Delete Node, Clear Child Nodes, Execute Node Command, Get Node References, Load Descendant Nodes, Validate Node Properties
Files attached to objects	Get Node File, Save Node File, Delete Node File
Scripting	Create Script, Compile Script, Delete Script, Disable Script, List Scripts, List Script Files, List Scriptable Types, List Members, Get Implementation Details
Batches & documents	Create Batch, List Batches, Get Batch Info, Get Batch Stats, Create Document, Create Page, Get Document Content, Get Document Data, Update Document Data, List Documents, Get Content Type Schema
Jobs & review tasks	List Jobs, Get Job, Cancel Jobs, Delete Jobs, List Tasks, Delete Task, Get Next Review Task, Get Review Task, List Review Tasks, Close Review Task
Scheduled tasks	Add Scheduled Task, Get Scheduled Task, List Scheduled Tasks, Cancel Scheduled Task, Delete Scheduled Task
Databases	List Database Tables, Get Database Table Schema, Run Database Query, Query Database Table
External content repositories (CMIS)	Get Cmis Repository Info, Get Cmis Object, Get Cmis Type, Get Cmis Type Tree, List Cmis Child Objects, List Cmis Child Types, Run Cmis Query, Create Cmis Object, Update Cmis Object Properties, Set Cmis Content Stream, Get Cmis Content Stream
Search & AI	List Indexes, Get Index, Execute Lucene Query, Execute Vector Query, Vector Search, List AI Models, Get Service Usage, Ask VLM
Statistics	Explore Stats, List Stats Sessions, Run Stats Query
Testing & diagnostics	Test Batch Process Step, Test Data Element Extraction, Test Extractor, Get Overrides, Set Overrides, Inspect Expression
Services & licensing	List Services, Start Service, Stop Service, Update Service, Get License Package, Check In License
Event log	List Log Events, Get Log Event, Delete Log Events
Help & discovery	Get Type Info, Get Type Help, Search Help, List Type Derivatives, List Tools, Search Tools, List Tool Connections, Activate Tool Connection
Guided workflows	Read Create Project Skill, Read Create Content Model Skill, Read Create Data Model Skill, Read Create Batch Process Skill, Read Data Model Styling Skill, Read Review Document Skill
Communication & web	Send Email, Search Entra Recipients, HTTP Call, HTTP Load, Ask
Label sets	Load Label Set, Save Label Set
Command console	Run GCC

A given MCP Server only exposes the subset of these it's configured with – its Tool List property shows exactly what will be reported to a connecting client.

Security considerations

• Use a Tool Filter or Server Filter on outbound connections to avoid handing an agent a broader toolset than its task requires.
• Prefer OAuth Client Credentials over Basic authentication for outbound connections where the remote server supports it.
• Many built-in tools are capable of destructive operations (deleting objects, jobs, log events, and so on) – scope what's exposed on a given MCP Server deliberately rather than exposing the full catalog by default.

Connecting a Grooper MCP Server to an AI client

Connecting Grooper MCP Servers to AI clients such as Claude Code or GitHub Copilot varies slightly from client to client. However, the broad strokes involve editing some kind of config file (either directly or indirectly) and entering a URL for the MCP Server.

The MCP Server's URL always takes the following form:

http(s)://<GROOPER-HOST>/gws/mcp/<GROOPER-REPOSITORY-ID>/servers/<MCP-SERVER-NAME>

• <GROOPER-HOST>: Replace this with the server host where the Grooper and GWS apps are installed.
• <GROOPER-REPOSITORY-ID>: Replace this with the Grooper Repository's ID (You can grab this by going to the Design page, selecting the Root node and copying the GUID value from the "Repository ID" property).
• <MCP-SERVER-NAME>: Replace this with whatever you named your MCP Server in Grooper.

The sections below walk through connecting a Grooper MCP Server to specific AI clients.

Claude Code/Claude Desktop

This guide will list the basic steps for hooking up a Grooper MCP Server to Claude Code. This will let you use Grooper tools from a Grooper MCP Server from:

• A terminal window, by typing claude directly (the "Claude Code CLI").
• The Code tab in Claude Desktop.

To get started:

1. Open Windows PowerShell.
2. Run the following command to install Claude Code. This may take a moment. Wait for the "Installation complete!" message at the end.

irm https://claude.ai/install.ps1 | iex

3. Close the PowerShell window and open a brand new one.
4. Run the following command to double-check Claude Code was installed. It should print a version number

claude --version

5. Run this command to add the Grooper MCP Server connection.

claude mcp add --transport http --scope user <NAME-IN-CLAUDE> "https://<GROOPER-HOST>/gws/mcp/<GROOPER-REPOSITORY-ID>/servers/<MCP-SERVER-NAME>"

• <NAME-IN-CLAUDE>: Replace this with whatever you want to name the MCP server, as seen in Claude, for example grooper or grooper-prod or grooper-dev.
• <GROOPER-HOST>: Replace this with the server host where the Grooper and GWS apps are installed.
• <GROOPER-REPOSITORY-ID>: Replace this with the Grooper Repository's ID (You can grab this by going to the Design page, selecting the Root node and copying the GUID value from the "Repository ID" property).
• <MCP-SERVER-NAME>: Replace this with whatever you named your MCP Server in Grooper.
• --scope user: This is recommended to make the server available everywhere for your account, not just locally to a single folder (--scope local).

6. Run this command to verify you've registered the server and show its status.

claude mcp list

7. If Claude Desktop is open, close and re-open it.
8. Go to the Code tab, start a new session and enter "/mcp". You should see the MCP Server you just added in the list.
9. Start prompting requests! The following are safe, read-only requests that will get you started.
   • List the Projects in my Grooper Repository and describe each Content Model.
   • Show me the steps in the list specific process name here Batch Process and what each Activity is configured to do.
   • List the most recent Production Batch and tell me what step it is on.
   • Read the Create Batch Process skill from the Grooper server and summarize the recommended step order for scanned paper documents.

VS Code (GitHub Copilot)

VS Code with the GitHub Copilot extension supports MCP servers in Agent mode. VS Code is a popular platform by itself, making it a good option for users who already have it installed and are familiar with it.

These instructions assume you already have VS Code installed with the GitHub Copilot extension, and that you're signed in to GitHub with an active Copilot license.

• You can install the GitHub Copilot extension from the VS Code Marketplace

Note for Copilot Business/Enterprise orgs: The "MCP servers in Copilot" policy must be enabled by an admin before MCP servers will work. This is off by default. If the MCP commands below are missing entirely from the Command Palette (rather than just failing to connect), this is likely why.

MCP servers are added by editing a config file called mcp.json.

1. Press Ctrl+Shift+P to open the Command Palette.
2. Type and select MCP: Open User Configuration. This opens (or creates) your global mcp.json file.
3. If no "servers" block exists in the JSON config, add the following entry (before the ending } in the JSON):

  "servers": {
    "<NAME-IN-COPILOT>": {
      "type": "http",
      "url": "http(s)://<GROOPER-HOST>/gws/mcp/<GROOPER-REPOSITORY-ID>/servers/<MCP-SERVER-NAME>"
    }
  }

• <NAME-IN-COPILOT>: Replace this with whatever you want to name the MCP server, as seen in Copilot, for example grooper or grooper-prod or grooper-dev.
• <GROOPER-HOST>: Replace this with the server host where the Grooper and GWS apps are installed.
• <GROOPER-REPOSITORY-ID>: Replace this with the Grooper Repository's ID (You can grab this by going to the Design page, selecting the Root node and copying the GUID value from the "Repository ID" property).
• <MCP-SERVER-NAME>: Replace this with whatever you named your MCP Server in Grooper.

4. If there are other servers already listed in the "servers" block, do not delete any existing entries. Simply add yours as a new entry in the object.
5. Important: The root key must be "servers", not "mcpServers". VS Code silently ignores the wrong key with no error message, so this is the single most common mistake when setting this up.
6. Save the file. Look for a "Start" link above your server's entry in the file (VS Code adds this automatically) and click it.
7. Open Copilot Chat and switch the mode dropdown from Ask to Agent. MCP tools are not available in Ask or Edit mode.
8. Click the tools icon in the chat box and confirm your server appears in the list.
9. Start prompting requests! The following are safe, read-only requests that will get you started.
   • List the Projects in my Grooper Repository and describe each Content Model.
   • Show me the steps in the list specific process name here Batch Process and what each Activity is configured to do.
   • List the most recent Production Batch and tell me what step it is on.
   • Read the Create Batch Process skill from the Grooper server and summarize the recommended step order for scanned paper documents.

OpenCode

OpenCode is an open source AI coding agent available as a terminal-based interface or a desktop app. It's an effective and cost effective way to get connected to a Grooper MCP Server. OpenCode uses the AI SDK and Models.dev to support 75+ LLM providers and supports running local models on-premises.

These instructions assume you already have OpenCode installed and connected to a model provider.

• You can download OpenCode at opencode.ai/download
• You can refer to information on how to set up and configure OpenCode at opencode.ai/docs

MCP servers are added by editing the OpenCode config file on your machine.

1. Open Windows File explorer and go to C:\Users\<YOUR-USER-NAME>\.config\opencode
2. Open opencode.json in a text editor.
3. If no such "mcp" block in the JSON config exists, add the following entry to the bottom (before the ending } in the JSON):

  "mcp": {
    "<NAME-IN-OPENCODE>": {
      "type": "remote",
      "url": "https://<GROOPER-HOST>/gws/mcp/<GROOPER-REPOSITORY-ID>/servers/<MCP-SERVER-NAME>",
      "enabled": true
    }
  }

• <NAME-IN-OPENCODE>: Replace this with whatever you want to name the MCP server, as seen in OpenCode, for example grooper or grooper-prod or grooper-dev.
• <GROOPER-HOST>: Replace this with the server host where the Grooper and GWS apps are installed.
• <GROOPER-REPOSITORY-ID>: Replace this with the Grooper Repository's ID (You can grab this by going to the Design page, selecting the Root node and copying the GUID value from the "Repository ID" property).
• <MCP-SERVER-NAME>: Replace this with whatever you named your MCP Server in Grooper.

4. If there are other MCP servers listed in the "mcp" block, do not delete any entries in the block. Simply add your server (<NAME-IN-OPENCODE>": {...}) in the object.
5. Fully quit and reopen OpenCode for the changes to take effect.
6. In the desktop app, if you have "Server status" enabled in the Settings (General > Advanced), you can verify your MCP Server is connected by pressing the "Status" button in the top tool bar.
7. Start prompting requests! The following are safe, read-only requests that will get you started.
   • List the Projects in my Grooper Repository and describe each Content Model.
   • Show me the steps in the list specific process name here Batch Process and what each Activity is configured to do.
   • List the most recent Production Batch and tell me what step it is on.
   • Read the Create Batch Process skill from the Grooper server and summarize the recommended step order for scanned paper documents.