Connecting to QPR ProcessAnalyzer MCP Server

QPR ProcessAnalyzer provides a standard Model Context Protocol (MCP) server endpoint that AI clients can connect to access process mining data and analyses. The primary authentication method is OAuth 2.0, and secondarily an API key can be used for simpler setups. Before configuring any client, ensure that QPRProcessAnalyzer has been configured as the MCP server and the desired authentication methods are enabled.

Claude Desktop

Claude Desktop is Anthropic's desktop GUI application. It supports remote MCP servers through Custom Connectors and local servers through JSON configuration.

Method 1: Custom Connectors / OAuth

For a remote QPR ProcessAnalyzer MCP server with OAuth, use the Custom Connectors feature:

1. Open Claude Desktop.
2. Click the + button at the bottom of the chat area.
3. Select Connectors → Manage Connectors.
4. Click Add custom connector.
5. Enter the QPR ProcessAnalyzer MCP server URL: https://your-pa-server.com/qprpa/api/mcp
6. Claude Desktop will initiate the OAuth flow. Sign in to QPR ProcessAnalyzer and authorize access.
7. Once connected, the QPR ProcessAnalyzer tools will be available in your conversations.

Note: Custom Connectors are available on Pro, Max, Team, and Enterprise plans. Remote servers use Streamable HTTP transport with OAuth.

Method 2: JSON Configuration with API Key

For API key authentication, edit the claude_desktop_config.json file directly.

File location:

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

Shortcut: In Claude Desktop, go to Settings → Developer → Edit Config.

Configuration:

{
  "mcpServers": {
    "qprpa-server": {
      "type": "http",
      "url": "https://your-pa-server.com/qprpa/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_QPRPA_API_KEY"
      }
    }
  }
}

After saving, completely quit Claude Desktop (not just close the window) and restart it. Look for the MCP server indicator in the bottom toolbar of the conversation area to confirm the connection.

Verification

• Click the hammer icon (🔨) or the + button → Connectors to see available tools.
• Go to Settings → Developer → Logs for error messages if the server does not appear.

Claude Code

Claude Code is Anthropic's CLI-based AI coding agent. It has built-in support for connecting to remote MCP servers with OAuth authentication.

Method 1: OAuth Authentication

Claude Code supports OAuth 2.1 natively for remote MCP servers. When connecting, it automatically discovers OAuth metadata, launches a browser-based authorization flow, and securely stores tokens in the system keychain.

Add the server via CLI:

claude mcp add --transport http \
  --client-id "YOUR_QPRPA_CLIENT_ID" \
  --client-secret "YOUR_QPRPA_CLIENT_SECRET" \
  --callback-port 8080 \
  qprpa-server https://your-pa-server.com/qprpa/api/mcp

Parameters:

• --transport http — Use Streamable HTTP transport (recommended over deprecated SSE).
• --client-id / --client-secret — Pre-configured OAuth credentials from QPR ProcessAnalyzer. If the server supports Dynamic Client Registration (DCR), these can be omitted.
• --callback-port — Fixes the OAuth callback port to match a pre-registered redirect URI of the form http://localhost:8080/callback.

Complete the OAuth flow:

1. Run /mcp inside your Claude Code session to initiate the connection.
2. A browser window will open to the QPR ProcessAnalyzer authorization page.
3. Sign in and grant the requested permissions.
4. Claude Code exchanges the authorization code for tokens and stores them securely.

Tip: If QPR ProcessAnalyzer uses a non-standard OAuth metadata endpoint, you can specify it explicitly with the --authServerMetadataUrl flag. By default, Claude Code checks /.well-known/oauth-protected-resource (RFC 9728) then falls back to /.well-known/oauth-authorization-server (RFC 8414).

Alternatively, add via JSON configuration:

claude mcp add-json qprpa-server '{
  "type": "http",
  "url": "https://your-pa-server.com/qprpa/api/mcp",
  "oauth": {
    "clientId": "YOUR_QPRPA_CLIENT_ID",
    "clientSecret": "YOUR_QPRPA_CLIENT_SECRET",
    "callbackPort": 8080
  }
}'

Method 2: API Key Authentication

If using an API key instead of OAuth, configure the server with a static Authorization header:

claude mcp add-json qprpa-server '{
  "type": "http",
  "url": "https://your-pa-server.com/qprpa/api/mcp",
  "headers": {
    "Authorization": "Bearer YOUR_QPRPA_API_KEY"
  }
}'

Verification

To verify the connection is working:

claude mcp get qprpa-server

Or use the /mcp slash command inside an active Claude Code session to see the connected server and its available tools.

Scopes

Claude Code supports three configuration scopes:

• local (default) — Available only to you in the current project.
• project — Shared with everyone in the project via .mcp.json.
• user — Available to you across all projects.

Add -s project or -s user to the claude mcp add command to change the scope.

Microsoft Copilot (via Copilot Studio)

Microsoft Copilot can connect to QPR ProcessAnalyzer as an MCP server through Microsoft Copilot Studio. Copilot Studio supports the Streamable HTTP transport type and both OAuth 2.0 and API key authentication.

Method 1: MCP Onboarding Wizard

The simplest approach uses the built-in MCP onboarding wizard in Copilot Studio:

1. Open your agent in Microsoft Copilot Studio.
2. Ensure generative orchestration is enabled for your agent.
3. Navigate to the Tools page.
4. Select Add a tool → New tool → Model Context Protocol.
5. The MCP onboarding wizard appears. Fill in the required fields:
   • Server name: QPR ProcessAnalyzer
   • Server description: QPR ProcessAnalyzer process mining MCP server
   • Server URL: https://your-pa-server.com/qprpa/api/mcp
6. Configure authentication (see below).
7. Select Next and create a connection.
8. Select Add and configure to finalize.

Authentication Configuration

OAuth 2.0

When using OAuth 2.0 with Copilot Studio:

1. During the MCP wizard setup, select OAuth 2.0 as the authentication type.
2. Provide the credentials from your QPR ProcessAnalyzer identity provider:
   • Client ID
   • Client Secret
   • Authorization URL
   • Token URL
   • Scopes (e.g., openid profile api://your-app-id/mcp)
3. After the tool is created, copy the Redirect URL provided by Copilot Studio.
4. Register this redirect URL in your QPR ProcessAnalyzer OAuth / identity provider configuration (e.g., add it to the allowed redirect URIs in your app registration).
5. Return to Copilot Studio, create a new connection, and complete the sign-in flow.

API Key

For API key authentication:

1. During setup, select API Key as the authentication type.
2. Enter the QPR ProcessAnalyzer API key when prompted.

Method 2: Custom Connector via Power Apps

For more advanced control, create a Custom Connector:

1. Go to the Power Apps or Power Automate portal.
2. Select Custom connectors → New custom connector → Import OpenAPI file.
3. Create an OpenAPI specification pointing to the QPR ProcessAnalyzer MCP endpoint:

swagger: '2.0'
info:
  title: QPR ProcessAnalyzer
  description: QPR ProcessAnalyzer MCP Server
  version: 1.0.0
host: your-qprpa-instance.example.com
basePath: /
schemes:
  - https
paths:
  /mcp:
    post:
      summary: QPR ProcessAnalyzer MCP Server
      x-ms-agentic-protocol: mcp-streamable-1.0
      operationId: InvokeMCP
      responses:
        '200':
          description: Success

1. Import the file and continue through the wizard.
2. On the Security tab, configure OAuth 2.0 with the QPR ProcessAnalyzer credentials (Client ID, Client Secret, Authorization URL, Token URL).
3. Select Update Connector to save.
4. In Copilot Studio, go to Tools → Add a tool → Model Context Protocol and select your custom connector.

Managing Tools

Once connected, the QPR ProcessAnalyzer tools automatically appear under the MCP server's tool listing in Copilot Studio. You can selectively enable or disable individual tools by toggling the Allow all switch off and configuring individual tool toggles.

ChatGPT

ChatGPT supports remote MCP servers through its Apps & Connectors interface (formerly called "Connectors"). MCP support requires Developer Mode for full tool access in chat.

Prerequisites

• A ChatGPT Pro, Plus, Team, Enterprise, or Education subscription.
• Developer Mode enabled (for full read/write tool access in Chat mode).
• The QPR ProcessAnalyzer MCP server must be publicly accessible (ChatGPT cannot connect to localhost).

Adding QPR ProcessAnalyzer as an MCP Server

Step 1: Enable Developer Mode

1. Open ChatGPT (web or desktop app).
2. Go to Settings → Connectors (or Apps & Connectors) → Advanced.
3. Enable Developer Mode.

Step 2: Add the MCP Server

1. In ChatGPT Settings, go to Apps & Connectors.
2. Select Add connector or Add app.
3. Enter the QPR ProcessAnalyzer MCP server URL: https://your-pa-server.com/qprpa/api/mcp
4. If using OAuth: ChatGPT will present the OAuth authorization flow. Sign in to QPR ProcessAnalyzer and grant permissions. OpenAI recommends using OAuth with dynamic client registration.
5. If using API Key: Enter the server URL with the API key appended as a query parameter or configure it as directed by your QPR ProcessAnalyzer admin.
6. The connector will be verified and added to your workspace.

Step 3: Use in Chat

1. In a new or existing chat, open the Developer Mode menu.
2. Enable the QPR ProcessAnalyzer connector for the current session.
3. Ask ChatGPT to use QPR ProcessAnalyzer tools, e.g., "Show me the process mining analysis for the Q1 purchase-to-pay process."
4. ChatGPT will call the appropriate MCP tools and display results. Write operations will prompt for user confirmation.

Using with the API

For programmatic access via the OpenAI API, configure the MCP server in your API call:

{
  "model": "gpt-4o",
  "messages": [...],
  "mcp_servers": [
    {
      "type": "url",
      "url": "https://your-pa-server.com/qprpa/api/mcp",
      "name": "qprpa-server",
      "authorization_token": "YOUR_OAUTH_ACCESS_TOKEN"
    }
  ]
}

Note|When using the API, you must handle the OAuth flow yourself and provide a valid access token. The API does not perform interactive OAuth flows.

Workspace Publishing

Enterprise, Education, and Team administrators can publish the QPR ProcessAnalyzer connector across the workspace so all users can access it without individual setup.

VSCode GitHub Copilot

GitHub Copilot in Visual Studio Code supports connecting to remote MCP servers via the Streamable HTTP transport. MCP is an open standard for connecting AI models to external tools and services, and in VS Code, MCP servers provide tools for tasks like file operations, databases, or external APIs.

Note: Agent mode is required. MCP tools are invisible in Ask or Edit mode. Open Copilot Chat, click the mode dropdown, and select "Agent."

Configuration File Locations

You can manually configure MCP servers by editing the mcp.json file. There are two locations for this file: Workspace — create or open .vscode/mcp.json in your project (include this file in source control to share MCP server configurations with your team); User profile — run the MCP: Open User Configuration command to open the mcp.json file in your user profile folder.

Method 1: OAuth Authentication

VS Code GitHub Copilot supports OAuth authentication for remote MCP servers. If you are using a remote server with OAuth authentication, in the mcp.json file, click Auth from the CodeLens above the server to authenticate to the server. A pop-up or new window will appear, allowing you to authenticate with your account.

Step 1: Add the MCP server configuration

Create or edit .vscode/mcp.json in your workspace (or use the user-level configuration):

{
  "servers": {
    "qpr-processanalyzer": {
      "type": "http",
      "url": "https://your-pa-server.com/qprpa/api/mcp"
    }
  }
}

When using OAuth, VSCode will automatically discover the server's OAuth metadata and initiate the browser-based authentication flow.

Step 2: Start the server and authenticate

1. A "Start" button will appear in your .vscode/mcp.json file, at the top of the list of servers. Click the "Start" button to start the MCP servers. This will trigger the input dialog and discover the server tools, which are then stored for later sessions.
2. Click the Auth CodeLens link above the server entry in mcp.json to initiate the OAuth flow.
3. Sign in to QPR ProcessAnalyzer in the browser window and grant the requested permissions.
4. VS Code securely stores the OAuth tokens for subsequent sessions.

Step 3: Use in Copilot Chat

1. Open Copilot Chat by clicking the icon in the title bar of Visual Studio Code. In the Copilot Chat box, select Agent from the popup menu.
2. To view your list of available MCP servers, click the tools icon in the top left corner of the chat box. This will open the MCP server list, where you can see all the MCP servers and associated tools that are currently available in your Visual Studio Code instance.
3. Ask Copilot to use QPR ProcessAnalyzer tools, e.g., "Analyze the purchase-to-pay process for Q1 using QPR ProcessAnalyzer."

Method 2: API Key Authentication

For API key authentication, use the ${input:} variable syntax to securely prompt for the key at server startup, rather than hardcoding it in the configuration file.

{
  "servers": {
    "qpr-processanalyzer": {
      "type": "http",
      "url": "https://your-pa-server.com/qprpa/api/mcpp",
      "headers": {
        "X-Mcp-Api-Key": "<your API key>"
      }
    }
  }
}

Verification

1. Open the .vscode/mcp.json file and check that the server shows a green status indicator (or "Running" label) via CodeLens.
2. Open Copilot Chat in Agent mode.
3. Click the tools icon (Configure tools) to confirm QPR ProcessAnalyzer tools are listed.
4. Run a test prompt such as: "List available process mining models from QPR ProcessAnalyzer."
5. If Copilot asks you to confirm that you want to proceed, click Continue.