Connect Coviu to Claude: Automate Bookings and Clinical Recordings

If you need to connect Coviu to Claude to orchestrate telehealth waiting queues, automate session rostering, or extract clinical recording files, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's LLM tool calls and Coviu's REST API. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses OpenAI, check out our guide on connecting Coviu to ChatGPT or explore our broader architectural overview on connecting Coviu to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sensitive environment like a clinical video platform is a high-stakes engineering problem. You have to handle OAuth 2.0 lifecycles, parse binary video streams into accessible metadata, enforce strict immutability rules on session state, and map complex nested JSON arrays into flat schemas that an LLM can reliably execute. Every time Coviu introduces a new webhook event or modifies a call queue state, you have to update your server code, redeploy, and test.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Coviu, connect it natively to Claude Desktop, and execute complex clinical and administrative operations using natural language.

The Engineering Reality of the Coviu API

A custom MCP server is a self-hosted API mapping layer. While the open MCP standard provides a predictable framework for models to discover tools, the reality of implementing it against Coviu's API requires dealing with deep domain-specific quirks.

If you decide to build a custom MCP server for Coviu, you are responsible for the entire API lifecycle. Here are the specific challenges you will encounter when exposing Coviu to AI models:

Complex Call State Lifecycles A Coviu waiting room call is not a static object - it is a multi-stage state machine. The list_all_coviu_waiting_queue_calls endpoint returns records containing timestamps for joinedAt, answeredAt, transferredAt, and finishedAt. If you expose this raw schema directly to Claude without clear descriptions, the LLM will struggle to accurately determine if a patient is actively waiting, currently in a consultation, or already discharged. Truto injects specific documentation instructions into the generated MCP schemas, guiding the LLM on exactly how to interpret these lifecycle timestamps to derive the true call state.

Strict Participant and Session Immutability Coviu enforces strict business logic around session mutations. You cannot add a participant to a session that has already finished. You cannot delete a participant belonging to a session that has already started. If your LLM attempts these invalid operations, the API will fail. Truto dynamically attaches context to the tool descriptions to explicitly warn the LLM about these state dependencies, reducing hallucinated tool execution failures.

Binary Payload Extraction Many integration platforms fail when tasked with extracting actual clinical recordings. Fetching submission files (get_single_coviu_submission_file_by_id) does not return JSON. It returns binary video/webm or audio/webm streams (often via HTTP 206 Partial Content). A standard custom MCP implementation will crash if it tries to stringify this payload into the standard JSON-RPC response format. Truto handles the pass-through proxy execution properly, ensuring the binary references are managed and the LLM receives actionable metadata rather than a crashed server context.

Handling Rate Limits and 429s Coviu enforces API quotas on concurrent sessions and polling operations. When an LLM iterates through paginated historical sessions too aggressively, it will trigger an HTTP 429 error. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream API returns a 429, Truto passes that error directly back to Claude. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. The caller is completely responsible for executing retry and backoff logic. Your AI agent must be architected to observe these limits.

Instead of building this complex translation layer from scratch, you can use Truto. Truto derives MCP tool definitions dynamically from Coviu's resource endpoints and executes them through a stateless JSON-RPC router.

sequenceDiagram
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Router
    participant Proxy as Truto Proxy API
    participant Coviu as Coviu REST API
    
    Claude->>MCP: POST /mcp/TOKEN (tools/call: create_a_coviu_session)
    Note over MCP: Validates token & flattens args<br>into query/body schemas
    MCP->>Proxy: Forward normalized request
    Proxy->>Coviu: POST /sessions (with OAuth credentials)
    Coviu-->>Proxy: 201 Created (Session Data)
    Proxy-->>MCP: Normalized JSON Response
    MCP-->>Claude: JSON-RPC 2.0 tool result

Step 1: Generate the Coviu MCP Server

Truto creates MCP servers scoped to a single integrated account. This means the server URL contains a cryptographic token that securely encodes the target Coviu account, the permitted tools, and the expiration time. You do not need to configure OAuth parameters in Claude - the URL handles authentication seamlessly.

You can generate the MCP server through the Truto user interface or programmatically via the API.

Method A: Via the Truto UI

1. Navigate to the Integrated Accounts page for your connected Coviu instance in the Truto dashboard.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure the server name, select any specific method subsets (e.g., restricting access to only read operations), and set an optional expiration date.
5. Copy the generated secure MCP server URL.

Method B: Via the API

If you are provisioning MCP environments for your end-users dynamically, you can use the Truto API to generate the server. The API securely stores the token in distributed KV storage and returns a ready-to-use URL.

Request:

curl -X POST https://api.truto.one/integrated-account/<COVIU_ACCOUNT_ID>/mcp \
  -H "Authorization: Bearer <TRUTO_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Coviu Telehealth Ops",
    "config": {
      "methods": ["read", "write", "list"],
      "tags": ["clinical", "scheduling"]
    }
  }'

Response:

{
  "id": "mcp-token-xyz-123",
  "name": "Coviu Telehealth Ops",
  "config": {
    "methods": ["read", "write", "list"],
    "tags": ["clinical", "scheduling"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/abc123def456..."
}

Step 2: Connect Coviu to Claude

Because Truto exposes the integration natively over HTTP via JSON-RPC 2.0 (using the Server-Sent Events / SSE transport standard supported by the MCP specification), connecting Claude requires zero additional backend code.

Method A: Via the Claude UI

If you are using Claude's web interface or enterprise admin console that supports UI-based custom connectors:

1. Open Settings -> Integrations (or Connectors).
2. Select Add MCP Server.
3. Paste the Truto MCP URL generated in Step 1.
4. Click Add. Claude will instantly execute a tools/list handshake and discover the Coviu API operations.

Method B: Via the Configuration File

If you are using Claude Desktop locally or configuring an automated agent infrastructure, you need to map the server in your MCP configuration file (claude_desktop_config.json).

You will use the official @modelcontextprotocol/server-sse runner to transport the local Claude requests over HTTP to the remote Truto server.

{
  "mcpServers": {
    "coviu-telehealth-ops": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/YOUR_TRUTO_TOKEN_HERE"
      ]
    }
  }
}

Restart Claude Desktop. The application will initialize the connection, verifying capabilities and dynamically loading the Coviu tools into the context window.

Coviu Hero Tools for Claude

Truto automatically generates tool definitions by deriving them from the integration's documented Resources and Methods. Out of dozens of available operations, here are six high-leverage "hero tools" to automate your Coviu clinical workflows.

list_all_coviu_waiting_queue_calls

Retrieves the live state of the virtual waiting room for a specific Coviu queue. This tool returns the critical timestamps (joinedAt, answeredAt, finishedAt) required to track patient flow, enabling the LLM to triage active patients versus completed consultations.

"Claude, pull the current waiting room queue for team ID 8901. Tell me how many patients have been waiting for more than 15 minutes without an answeredAt timestamp."

create_a_coviu_session

Provisions a new discrete Coviu telehealth session. The tool requires session_name, start_time, and end_time, and can optionally configure advanced UI parameters via feature_flags (such as disable-menu or return-url).

"Schedule a new 45-minute multi-disciplinary review session named 'Oncology Board Review' starting tomorrow at 10 AM. Ensure the menu is disabled for external participants."

list_all_coviu_participants

Fetches the complete roster of participants for a given session. Crucial for auditing who has been invited, determining their roles (host vs guest), and retrieving their unique entry URLs for distribution.

"List all participants currently rostered for the 'Oncology Board Review' session (session ID 4455). Give me the entry URL for Dr. Smith so I can email it to her."

create_a_coviu_participant

Adds a new participant to an existing session. The LLM must supply the session_id and the user's display_name. Note: The API enforces state immutability, meaning the LLM cannot execute this tool if the session has already been marked finished.

"Add 'John Doe - Interpreter' to session 4455. Generate his secure entry link and draft a brief email inviting him to join the consultation."

list_all_coviu_submissions

Retrieves the metadata for data collections and file submissions tied to a team and collection ID. This includes the created_at timestamp and array of associated files generated during a telehealth session.

"Fetch all file submissions for the secure collection 9922 over the last 7 days. Summarize the number of files generated per session."

get_single_coviu_submission_file_by_id

Retrieves the specific binary recording file (audio or video stream) for a clinical submission. The agent can use this reference to pipe the recording into transcription or clinical NLP analysis services downstream.

"Get the binary video recording file for submission ID 505 and file ID 77. Extract the payload reference so we can send it to AssemblyAI for transcription."

To view the complete inventory of available Coviu operations, query schemas, and object definitions, visit the Coviu integration page.

Workflows in Action

Exposing an MCP server to Claude transforms static API endpoints into dynamic, multi-step orchestration workflows. Here are three practical scenarios illustrating how the agent executes tools in sequence.

1. Managing the Virtual Waiting Room

In high-volume telehealth clinics, triage nurses spend massive amounts of time monitoring screens. You can instruct Claude to act as a virtual waiting room monitor.

"Review the Coviu waiting queue for Team 404. Find any patients who have joined but have not been answered yet. If anyone has been waiting longer than 10 minutes, format an alert summary."

1. Claude calls list_all_coviu_waiting_queue_calls passing team_id: "404" and waiting_queue_id: "primary".
2. The model analyzes the JSON array, calculating the delta between the current time and the joinedAt timestamp for records where answeredAt is null.
3. Claude outputs a prioritized triage table indicating exactly which callId needs immediate attention.

2. Automating Telehealth Bookings and Rostering

Administrators often need to spin up ad-hoc consultation rooms and distribute links to external specialists.

"Create a new session for 'Emergency Cardiology Consult' starting in 15 minutes and lasting for 1 hour. Once created, add 'Dr. Evans (Cardiologist)' and 'Sarah Connor (Patient)' as participants. Give me their direct entry URLs."

1. Claude calls create_a_coviu_session with the calculated ISO-8601 timestamps and session name.
2. It parses the returned session_id.
3. Claude calls create_a_coviu_participant for "Dr. Evans" using the newly acquired session_id.
4. Claude calls create_a_coviu_participant again for "Sarah Connor".
5. The model formats the final output, providing the discrete entry_url for each party so the administrator can distribute them immediately.

3. Extracting and Analyzing Clinical Recordings

Post-consultation operations require extracting clinical artifacts for compliance, transcription, or EMR ingestion.

"Find the session summary for session ID 8810. Then look up its associated collection submissions. If there is a video recording attached, fetch the recording file reference."

1. Claude calls get_single_coviu_session_summary_by_id to verify the session details and actual_end_time.
2. Claude calls list_all_coviu_submissions filtering by the appropriate date range or session context.
3. Upon locating the target submission, Claude calls get_single_coviu_submission_by_id to inspect the nested files array.
4. Finally, it invokes get_single_coviu_submission_file_by_id to retrieve the stream reference for the actual video/webm file.

flowchart TD
    A["Claude Prompt:<br>Fetch recording for session 8810"] --> B["get_single_coviu_session_summary_by_id"]
    B --> C{"Session Completed?"}
    C -->|Yes| D["list_all_coviu_submissions"]
    C -->|No| E["Return status:<br>Consultation still active"]
    D --> F["get_single_coviu_submission_by_id"]
    F --> G["get_single_coviu_submission_file_by_id<br>(Fetch binary reference)"]

Security and Access Control

Connecting an autonomous AI to a clinical platform requires strict governance. Truto MCP servers support highly granular access controls embedded directly into the cryptographic token URL:

• Method Filtering: Use config.methods to enforce read-only execution. Setting this to ["read"] ensures the server will only generate tools for get and list operations, physically blocking the LLM from executing a create or delete action.
• Tag Filtering: Coviu resources can be tagged in the Truto integration config. You can restrict a server using config.tags (e.g., ["scheduling"]) to only expose session-related tools, hiding clinical recording and submission tools entirely.
• Time-to-Live (TTL): Set an expires_at ISO datetime when generating the server. Once expired, the underlying KV storage automatically purges the token, and the URL will instantly return a 401 Unauthorized error.
• Require API Token Auth: For high-security environments, setting require_api_token_auth: true means possession of the URL is not enough. The MCP client must also pass a valid Truto API token in the Authorization header, enforcing a dual-layer identity check before tools are executed.

Automate Telehealth at Scale

Building custom API translation layers for LLMs is expensive, fragile, and inherently risky when dealing with sensitive clinical states. By leveraging a managed MCP server, you eliminate the boilerplate of OAuth lifecycles, cursor pagination, and schema mapping. Truto dynamically interprets Coviu's API definitions, rendering them as reliable, tightly-scoped tools that Claude can execute securely.

Stop writing custom integration code to parse waiting room logic. Connect your clinical platforms natively and let your AI orchestrate the workflows.