# Lorikeet MCP Server
Source: https://docs.lorikeetcx.ai/mcp/mcp-server

Connect to your Lorikeet account from ChatGPT, Claude, Claude Code, and MintMCP using the Model Context Protocol.

The Lorikeet MCP server allows AI tools like ChatGPT and Claude, and managed MCP gateways like MintMCP, to access your Lorikeet account data directly, including workflows, tools, integrations, knowledge base articles, and more.

<Info>
  Looking to connect an external MCP server **to** Lorikeet as a tool provider? See the [External MCP Servers](/tools/mcp) page instead.
</Info>

Once connected, you can:

* **Diagnose tickets** - trace workflow execution and identify root causes
  > "Pull up ticket #12345. What went wrong and why did the customer get escalated?"
* **Audit knowledge bases** - analyze articles at scale, find gaps, and spot quality issues
  > "Review all our knowledge base articles. Which ones are outdated, which topics have gaps, and are there any quality issues?"
* **Explore your setup** - inspect workflows, tools, and integrations
  > "Give me a summary of what integrations are configured."
* **Build workflows** - create and iterate on workflows using natural language
  > "Create a new natural language workflow that handles refund requests by checking order status, verifying the return window, and processing the refund."
* **Test tools** - run and validate tool configurations directly from your AI assistant
  > "Test the 'get-order-status' tool with order ID 98765 and check if the response matches what we expect."
* **Run simulations** - test workflows against different customer scenarios
  > "Set up a simulation batch for the refund workflow with 3 different customer scenarios — a valid refund, an expired return window, and a missing order — and run it."

[MCP (Model Context Protocol)](https://modelcontextprotocol.io/introduction) is an open standard for connecting AI tools to external data sources and services.

## MCP server URL

Use a single, region-agnostic endpoint regardless of where your Lorikeet account is hosted:

```
https://mcp.lorikeetcx.ai
```

Authentication routes traffic to your account's region automatically.

## Setup

<Tabs>
  <Tab title="ChatGPT">
    ### Prerequisites

    * Access to [ChatGPT](https://chatgpt.com) with a Team, Business, or Enterprise subscription
    * **Workspace Admin access** is required for the initial setup (Steps 1–5). Once complete, all workspace members can use the app.

    ### Connect

    <Steps>
      <Step title="Open Workspace Settings">
        Go to [chatgpt.com](https://chatgpt.com), click your profile icon in the bottom-left corner, and select **Workspace settings**.
      </Step>

      <Step title="Create a new app">
        In the admin panel, click the **Create** button.
      </Step>

      <Step title="Configure the app">
        Fill in the app configuration:

        * **Name**: `Lorikeet`
        * **Description**: `Access your Lorikeet account.`
        * **MCP Server URL**: `https://mcp.lorikeetcx.ai`
        * **Authentication**: Select `OAuth`

        Click **Create** to proceed.
      </Step>

      <Step title="Authorize">
        You will be redirected to the Lorikeet authorization page. Sign in to your Lorikeet account and click **Authorize**.
      </Step>

      <Step title="Publish the app">
        After authorization, the Lorikeet app will appear in the **Drafts** section. Click on the app, then click **Publish** to make it available to your workspace.
      </Step>

      <Step title="Use the app">
        Workspace members can now use the Lorikeet app in their conversations:

        1. Start a new chat
        2. Click the **+** button near the message input
        3. Click **More** to see all available apps
        4. Select **Lorikeet**
      </Step>
    </Steps>

    ### Troubleshooting

    For troubleshooting connection issues, refer to the [ChatGPT apps docs](https://help.openai.com/en/articles/11487775-apps-in-chatgpt).

    If you're still having trouble, reach out to the [Lorikeet team](mailto:support@lorikeetcx.ai).
  </Tab>

  <Tab title="Claude">
    ### Prerequisites

    * Access to [Claude](https://claude.ai) with a Pro, Team, or Enterprise subscription

    ### Connect

    <Steps>
      <Step title="Open Settings">
        Go to [claude.ai](https://claude.ai) and click your profile icon in the bottom-left corner, then select **Settings**.
      </Step>

      <Step title="Add a Custom Connector">
        In Settings, click the **Connectors** tab, then click **+ Add Custom Connector**.

        <Warning>
          You may need **admin access** to add custom connectors. Contact your workspace admin if this option is not available.
        </Warning>
      </Step>

      <Step title="Configure the connector">
        Fill in the connector form:

        * **Name**: `Lorikeet`
        * **Description**: `Access your Lorikeet account.`
        * **URL**: `https://mcp.lorikeetcx.ai`

        Click **Add** to proceed. Claude will automatically discover the OAuth endpoints.
      </Step>

      <Step title="Authorize">
        You will be redirected to the Lorikeet authorization page. Sign in to your Lorikeet account and click **Authorize**.
      </Step>

      <Step title="Verify">
        Once connected, the Lorikeet connector will appear in your Connectors list. Try asking Claude:

        ```
        What Lorikeet account am I connected to?
        ```
      </Step>
    </Steps>

    ### Troubleshooting

    For troubleshooting connection issues, refer to the [Claude connector docs](https://support.claude.com/en/articles/11503834-building-custom-connectors-via-remote-mcp-servers).

    If you're still having trouble, reach out to the [Lorikeet team](mailto:support@lorikeetcx.ai).
  </Tab>

  <Tab title="Claude Code">
    ### Prerequisites

    * [Claude Code](https://code.claude.com) installed on your machine

    ### Connect

    Run the following command in your terminal:

    ```bash theme={null}
    claude mcp add --scope user --transport http lorikeet https://mcp.lorikeetcx.ai
    ```

    Then authenticate by running `/mcp` inside Claude Code and following the browser login flow.

    ### Verify

    Once connected, ask Claude Code:

    ```
    What Lorikeet account am I connected to?
    ```

    ### Troubleshooting

    For troubleshooting connection issues, refer to the [Claude Code MCP docs](https://code.claude.com/docs/en/mcp).

    If you're still having trouble, reach out to the [Lorikeet team](mailto:support@lorikeetcx.ai).
  </Tab>

  <Tab title="MintMCP">
    ### Prerequisites

    * Access to a MintMCP workspace that can add remote MCP servers

    ### Connect

    Add Lorikeet as a remote MCP server in MintMCP using:

    * **Name**: `Lorikeet`
    * **MCP server URL**: `https://mcp.lorikeetcx.ai`
    * **Authentication**: `OAuth`

    MintMCP discovers Lorikeet's OAuth endpoints and opens the Lorikeet authorization page. Sign in, select the Lorikeet account to connect, review the requested permissions, and approve access.

    After authorization, confirm that Lorikeet appears as a connected MCP server and make its tools available to the intended MintMCP roles.

    ### Troubleshooting

    For MintMCP workspace configuration, refer to the [MintMCP Gateway documentation](https://www.mintmcp.com/mcp-gateway).

    If you're still having trouble, reach out to the [Lorikeet team](mailto:support@lorikeetcx.ai).
  </Tab>
</Tabs>

## Technical details

| Property | Value |
| - | - |
| Protocol | Model Context Protocol (MCP) |
| Transport | Streamable HTTP |
| Authentication | OAuth 2.1 (PKCE for interactive, client credentials for headless) |
| Token Lifetime | 1 hour (interactive tokens auto-refresh; headless tokens are re-requested) |


# Running simulations from MCP
Source: https://docs.lorikeetcx.ai/mcp/skills

How to get a guided, orchestrated simulation experience when using the Lorikeet MCP server.

In Coach, simulations work because Coach loads **skills** — guided recipes that handle the right multi-step sequence (set up a test customer, write strong assertions, choose the right execution environment, etc.) automatically based on your intent. You don't think about skills; they just happen.

**The MCP server is different.** MCP exposes the underlying Lorikeet tools directly to your AI assistant — there's no automatic orchestration. If you just say *"create a sim for the refund flow"*, the AI calls raw tools and often misses prerequisites: simulations created without test customer profiles, weak assertions, wrong execution environment, silent failures that look fine in the UI.

To get the same guided experience over MCP, you invoke the skill explicitly.

<Info>
  **Coach**: skills load automatically from intent.
  **MCP**: skills must be invoked explicitly — syntax varies by client.
</Info>

## How to invoke a sim skill on MCP

<Tabs>
  <Tab title="Claude Code">
    Type the skill as a slash command at the start of your prompt:

    ```
    /lorikeet:create-simulations build simulations for the refund workflow
    ```

    Claude Code will load the recipe and follow it end-to-end.
  </Tab>

  <Tab title="Claude (desktop / web)">
    Ask Claude to load the skill explicitly, then describe your task:

    ```
    Load the Lorikeet create-simulations skill, then build sims for the refund workflow.
    ```

    Claude calls the MCP `load_prompt` tool to fetch the skill content, then proceeds.
  </Tab>

  <Tab title="ChatGPT">
    With the Lorikeet app enabled in your workspace:

    ```
    Use the Lorikeet load_prompt tool to load the "create-simulations" skill, then build sims for the refund workflow.
    ```
  </Tab>

  <Tab title="Other MCP clients">
    For Cursor, Continue, Cline, and other MCP clients, the universal pattern works:

    ```
    Use the Lorikeet load_prompt tool to load "create-simulations", then build sims for the refund workflow.
    ```
  </Tab>
</Tabs>

<Warning>
  Skip the skill invocation and the AI improvises from raw tools. Most common consequences: simulations created without test customer profiles, weak or missing assertions, wrong execution environment, silent failures. Always invoke the skill first.
</Warning>

## End-to-end example: creating and running sims via MCP

Here's the canonical flow using Claude Code. Adjust the slash command syntax per the tabs above for other clients.

<Steps>
  <Step title="Create simulations for a workflow">
    ```
    /lorikeet:create-simulations create simulations for the refund workflow,
    covering valid refunds, expired return windows, and missing orders.
    ```

    The skill will:

    * Analyze the workflow
    * Set up a test customer profile if needed
    * Generate scenarios with clear instructions and initial messages
    * Define expected results and assertions
    * Confirm with you before creating
  </Step>

  <Step title="Run the simulations">
    ```
    /lorikeet:run-simulations run the simulations I just created and report the results.
    ```

    The skill will execute the batch, poll for completion, and present pass/fail with reasoning per scenario.
  </Step>

  <Step title="Iterate on failures">
    ```
    /lorikeet:simulation-driven-development iterate on the failing sims until pass rate is at least 90%.
    ```

    The skill will classify each failure, propose targeted fixes, apply them on a draft, re-run, and repeat until the target is hit.
  </Step>

  <Step title="Edit a scenario if needed">
    ```
    /lorikeet:update-simulations strengthen the assertions on the "expired return window" scenario.
    ```
  </Step>

  <Step title="Review your sim coverage">
    ```
    /lorikeet:review-simulations review the simulations for the refund workflow — what's missing?
    ```

    The skill grades expected-result reliability, instruction clarity, test customer completeness, and coverage.
  </Step>
</Steps>

## Simulation skills reference

| Skill | When to use it |
| - | - |
| `create-simulations` | Create new test scenarios and test customers for a workflow |
| `run-simulations` | Execute existing simulations and review results |
| `update-simulations` | Edit an existing scenario (instructions, assertions, expected results) |
| `review-simulations` | Audit existing simulations for coverage, clarity, and quality |
| `simulation-driven-development` | Iterate to push simulation pass rates higher (audit → baseline → fix → re-run) |

## Other Lorikeet skills available via MCP

The same skill-invocation pattern works for non-simulation tasks. Replace `create-simulations` with the relevant skill name:

| Skill | Purpose |
| - | - |
| `build-edit-agent` | Build or edit a concierge, its skills, and tools on a draft version |
| `edit-workflow` | Safely edit a workflow on a draft version |
| `build-guardrail` | Create or improve a guardrail |
| `diagnose-guardrails` | Analyze guardrail performance and find gaps |
| `knowledge-creator` | Add new knowledge to Lorikeet, routed to the right primitive |
| `knowledge-gaps` | Find missing knowledge from escalated tickets |
| `understanding-tqs` | Diagnose why TQS is failing |
| `improve-check-score` | Diagnose and fix a failing TQS check |
| `diagnose-ticket` | Investigate what happened on a specific ticket |
| `setup-integration` | Configure a ticketing or external system integration |
| `design-campaign` | Design and launch an outbound campaign |

## Troubleshooting

**Output looks incomplete or missing setup steps** — you likely didn't invoke a skill. Retry with the slash command or `load_prompt` instruction.

**My MCP client doesn't support slash commands** — use the universal fallback: *"Use the Lorikeet load\_prompt tool to load `<skill-name>`, then…"*.

**I want to see what a skill does before invoking it** — call `load_prompt(<skill-name>)` directly via MCP; the content returns inline.

Still stuck? Reach out to the [Lorikeet team](mailto:support@lorikeetcx.ai).