Set up machine-to-machine MCP access

Use a service client when an internal AI gateway, automated agent, or backend workload must connect to ClosedLoop AI without a person authorizing it in a browser. The workload authenticates with a signed JWT or a shared secret, then receives a short-lived, read-only access token. For LiteLLM, use the guided integration in ClosedLoop AI. For another gateway or workload, create and manage a service client from MCP access settings.

Connect LiteLLM

Open the LiteLLM integration

In ClosedLoop AI, open Integrations → Developer tools → LiteLLM and click Connect.You need integration management permission. A workspace owner or admin can grant this permission to another member.

Create and save the credential

Click Create LiteLLM credential. Copy the generated environment variables into your secret manager before leaving the page.

The client secret is shown only once. If you lose it, generate a new secret from the LiteLLM integration.

Copy the generated LiteLLM configuration

Copy the generated config.yaml block into LiteLLM. ClosedLoop AI automatically supplies the correct MCP and token URLs for your workspace region.Restart or reload LiteLLM after changing its configuration, then ask it to list the available tools.

Verify tool discovery

Return to the LiteLLM integration in ClosedLoop AI and click Check again. The integration becomes connected after LiteLLM lists the ClosedLoop AI tools.Then call find_reference_customers or get_overview through LiteLLM to verify a complete request. LiteLLM may expose a namespaced name such as closedloop_ai-find_reference_customers.

Settings → MCP access remains the advanced surface for owners and admins managing custom gateways, public keys, and all service clients. Use public-key authentication when a non-LiteLLM client supports OAuth private_key_jwt. Use a shared secret for clients that support only client_secret_basic or client_secret_post.

Before you begin

You need:

Integration management permission for LiteLLM, or a workspace owner or admin account for advanced MCP access
A client that supports HTTP MCP and the OAuth client_credentials flow
A secret manager for the private key or shared secret

Set up another machine-to-machine client

Choose your regional endpoints

Use every URL from the same row:

Workspace region	MCP URL	Token URL
US	`https://mcp.closedloop.sh`	`https://mcp.closedloop.sh/token`
EU	`https://eu.mcp.closedloop.sh`	`https://eu.mcp.closedloop.sh/token`

Credentials created for one region do not work in the other region.

Create a service client

In ClosedLoop AI, open Settings → MCP access.
Click Create service client.
Enter a name that identifies the gateway or workload using it.
Copy the client ID. If you plan to use shared-secret authentication, also copy the client secret into your secret manager.

The client secret is shown only once. If you lose it, rotate the credential and save the new secret.

Configure a shared-secret client

Set these values in your gateway:

Field	Value
Transport	HTTP
Authentication	OAuth
OAuth flow	`client_credentials`
MCP URL	The regional MCP URL above
Token URL	The regional token URL above
Client ID	The saved service-client ID
Client secret	The saved service-client secret
Scope	`mcp:read`

Use client_secret_basic when your gateway lets you choose the client authentication method. ClosedLoop AI also supports client_secret_post.If your gateway sends an OAuth resource value, set it to the exact regional MCP URL. Gateways that omit resource are supported.

Test the connection

Ask the gateway to list the available tools, then call a read-only tool such as get_overview.A successful connection does not open a browser. The gateway receives a one-hour token with the mcp:read scope and must fetch a new one when it expires.

Use public-key authentication

Public-key authentication keeps the private key in your infrastructure. ClosedLoop AI stores only the public JSON Web Key (JWK).

Generate a key pair

Generate either an RSA key of at least 2048 bits with public exponent 65537 for RS256, or a P-256 key for ES256. This RSA example requires OpenSSL and Node.js 20 or later:

openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -pkeyopt rsa_keygen_pubexp:65537 -out closedloop-mcp-private.pem
openssl pkey -in closedloop-mcp-private.pem -pubout -out closedloop-mcp-public.pem
node -e "const fs=require('node:fs');const crypto=require('node:crypto');const key=crypto.createPublicKey(fs.readFileSync('closedloop-mcp-public.pem'));console.log(JSON.stringify(key.export({format:'jwk'})))"

Save closedloop-mcp-private.pem in your secret manager. The last command prints the public JWK you will register.

In ClosedLoop AI, open Settings → MCP access.
Find the service client and click Add public key.
Enter a unique key ID, select the matching algorithm, and paste the public JWK.
Click Register public key.

Never paste or upload the private key. ClosedLoop AI needs only the public JWK.

A service client can have up to two active public keys so you can rotate without downtime.

Configure the official TypeScript client

Install the MCP client package:

npm install @modelcontextprotocol/client@2.0.0

Configure PrivateKeyJwtProvider with the same client ID, algorithm, and regional MCP URL:

import { readFile } from 'node:fs/promises';
import {
  auth,
  Client,
  PrivateKeyJwtProvider,
  StreamableHTTPClientTransport,
} from '@modelcontextprotocol/client';

const serverUrl = new URL(process.env.CLOSEDLOOP_MCP_URL!);
const provider = new PrivateKeyJwtProvider({
  clientId: process.env.CLOSEDLOOP_MCP_CLIENT_ID!,
  privateKey: await readFile(process.env.CLOSEDLOOP_MCP_PRIVATE_KEY_PATH!, 'utf8'),
  algorithm: 'RS256',
  scope: 'mcp:read',
  jwtLifetimeSeconds: 300,
  expectedIssuer: serverUrl.toString().replace(/\/$/, ''),
});

await auth(provider, {
  serverUrl,
  scope: 'mcp:read',
});

const transport = new StreamableHTTPClientTransport(serverUrl, {
  authProvider: provider,
});
const client = new Client({ name: 'closedloop-ai-client', version: '1.0.0' });

await client.connect(transport);
const { tools } = await client.listTools();
console.log(tools.map((tool) => tool.name));

Set CLOSEDLOOP_MCP_URL to the exact regional MCP URL and keep the private-key file outside source control.After the first successful public-key connection, revoke the generated shared-secret credential unless another integration still needs it.

LiteLLM configuration reference

LiteLLM currently requires a client ID and shared secret for this flow. It does not expose private_key_jwt configuration.

The guided LiteLLM integration generates this block with the correct regional URLs. Store the generated values as CLOSEDLOOP_MCP_CLIENT_ID and CLOSEDLOOP_MCP_CLIENT_SECRET, then add the configuration to config.yaml:

mcp_servers:
  closedloop_ai:
    url: "https://eu.mcp.closedloop.sh"
    transport: http
    auth_type: oauth2
    oauth2_flow: client_credentials
    client_id: os.environ/CLOSEDLOOP_MCP_CLIENT_ID
    client_secret: os.environ/CLOSEDLOOP_MCP_CLIENT_SECRET
    token_url: "https://eu.mcp.closedloop.sh/token"
    scopes: ["mcp:read"]

For a US workspace, change both URLs to https://mcp.closedloop.sh and https://mcp.closedloop.sh/token. LiteLLM fetches, caches, and renews access tokens automatically. To verify the setup, list its tools and call find_reference_customers or get_overview.

Rotate or revoke credentials

Access tokens expire after one hour. Service-client secrets expire after 180 days.
ClosedLoop AI notifies workspace owners and admins in Settings → MCP access 30 and 7 days before a secret expires.
When you rotate a credential, its existing secret remains valid for at most 24 hours. Update the gateway, verify the new secret, then revoke the old credential.
Revoking a credential immediately invalidates its issued access tokens. Revoking a service client immediately invalidates all its credentials and tokens.
Public keys do not expire automatically. Register the replacement, test it, then revoke the old key.
Revoking a public key immediately invalidates every access token issued through that key.

Create a separate service client for each gateway or workload so access can be rotated, audited, and revoked independently.

Troubleshooting

Error or symptom	What to check
`invalid_client`	Confirm the client ID and region. For shared secrets, check the current secret. For public keys, check the registered key, algorithm, JWT claims, five-minute maximum lifetime, and unique `jti`.
`invalid_scope`	Request only `mcp:read`.
`invalid_target`	Match the OAuth `resource` value exactly to the regional MCP URL, or omit it.
`Invalid or expired token`	Do not use a regular API key. Let the gateway fetch a new token from the regional token URL.
A browser opens	Configure `client_credentials`, not the authorization-code flow.
`find_reference_customers` is unavailable	In LiteLLM, reload the configuration and list tools. Look for either `find_reference_customers` or a namespaced name ending in `-find_reference_customers`. Then click Check again in the ClosedLoop AI LiteLLM integration.
Write tools are unavailable	Service-client access is intentionally read-only.

MCP Overview

Set up interactive clients and learn how MCP access works.

Core tools reference

Browse core tools and their parameters.

Workspace

SSO & provisioning

Security & procurement

Set up machine-to-machine MCP access

Connect LiteLLM

Before you begin

Set up another machine-to-machine client

Use public-key authentication

LiteLLM configuration reference

Rotate or revoke credentials

Troubleshooting

MCP Overview

Core tools reference

​Connect LiteLLM

​Before you begin

​Set up another machine-to-machine client

​Use public-key authentication

​LiteLLM configuration reference

​Rotate or revoke credentials

​Troubleshooting

MCP Overview

Core tools reference

Connect LiteLLM

Before you begin

Set up another machine-to-machine client

Use public-key authentication

LiteLLM configuration reference

Rotate or revoke credentials

Troubleshooting