> For the complete documentation index, see [llms.txt](https://docs.dapta.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.dapta.ai/dcal/developers/mcp-server.md).

# Connect an AI assistant (MCP)

Let an AI assistant such as Claude, ChatGPT, Cursor, Claude Code or Codex find your open times and hold, book, move, confirm, decline or cancel dCal meetings for you. Connect it to dCal's MCP server a

dCal has its own MCP server, at `https://mcp.dcal.ai/mcp`, so that an AI assistant you already use can work with your calendar in plain words: find a free time, hold it, book a meeting, move it, answer a booking request or cancel it. This page shows where the setup lives in dCal, the two ways to connect, and how to keep it safe.

***

## What MCP is

MCP, the Model Context Protocol, is an open standard that lets an AI assistant use the tools of other apps. dCal's MCP server address is `https://mcp.dcal.ai/mcp`. Once your assistant is connected, you can ask it something like "find a free 30-minute slot next Tuesday for John Doe and book it". The assistant asks dCal for your open times, books the meeting, and tells you what it did. Your guest gets the same emails as when they book on your page.

> **💡 Tip:** This page is about dCal's own MCP server. To run your Dapta agents, flows and analytics from an AI assistant, see [Dapta MCP](https://docs.dapta.ai/dapta-mcp/mcp.md). To let a Text Agent or a Voice Agent book on dCal with no code, see [Let your Dapta agent book](https://docs.dapta.ai/dcal/dapta-agents.md).

***

## Two ways to connect

|                | Sign in                                                                                                  | API key                                                                               |
| -------------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
| Made for       | Claude, ChatGPT, Claude Code, Codex, Cursor, OpenClaw, Hermes and other apps that support MCP sign-in    | Agents and scripts that run with no one to sign in, and any agent that sends a header |
| How            | Add the MCP address in the app and sign in with your Dapta account. No key.                              | Create a key, put it in an environment variable, and add the server to your agent.    |
| What it can do | Everything your owner or admin access allows: every tool, on every event type                            | Only the access you tick, for example read only or a single event type                |
| In dCal        | **Connect your agent**, one tab per app                                                                  | **API and webhooks** > **API keys**                                                   |
| Steps          | [Connect Claude or ChatGPT by signing in](https://docs.dapta.ai/dcal/developers/connect-with-sign-in.md) | This page, from [Create a key for your assistant](#create-a-key-for-your-assistant)   |

Signing in is the easiest way. Use a key when the assistant should have narrower access, or when your agent cannot sign in.

***

## Before you start

* You are an **owner** or **admin** of your dCal workspace. Only they see **Connect your agent**, **Tools** and **API and webhooks** in the left menu, and can connect an assistant or create keys. A member who opens one of those pages sees **You don’t have access**: ask an owner or an admin.
* Your assistant can connect to an MCP server over HTTP. If it cannot but it runs commands in a terminal, see [No MCP in your agent? Use the agent skill](#no-mcp-in-your-agent-use-the-agent-skill).

***

## The agent pages in dCal

Everything about AI agents sits in the left menu:

<figure><img src="https://3835013762-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FCy5rSNtQmtqYCGzJlNEB%2Fuploads%2Fgit-blob-d94bd5ffa3254f03ecc79517cfbed00a8509e0a3%2Fdcal-dashboard-tour-07-api-and-webhooks.png?alt=media" alt="The left menu with Connect your agent, Tools and the open API and webhooks group boxed, the group showing API keys (selected), Webhooks and API docs with its external-link arrow"><figcaption><p>Only owners and admins see these items.</p></figcaption></figure>

| Page                                | What it holds                                                                                                                                                                                                                                                                  |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Connect your agent**              | The steps to connect Claude, ChatGPT, Claude Code, Codex, Cursor, OpenClaw or Hermes by signing in, one tab per app, with the MCP address and a first request to try. No key is involved. [app.dcal.ai/admin/developers/connect](https://app.dcal.ai/admin/developers/connect) |
| **Tools**                           | The 33 tools in six groups, **Open times**, **Booking**, **Holds**, **Your bookings**, **Booking requests** and **Account and event types**, each in plain words with an example request. [app.dcal.ai/admin/developers/tools](https://app.dcal.ai/admin/developers/tools)     |
| **API and webhooks** > **API keys** | Your **API keys** and **No MCP in your agent?**, the agent skill to download. [app.dcal.ai/admin/developers/keys](https://app.dcal.ai/admin/developers/keys)                                                                                                                   |
| **API and webhooks** > **Webhooks** | The messages dCal sends to your systems when a booking changes. See [Webhooks](https://docs.dapta.ai/dcal/integrations/webhooks.md). [app.dcal.ai/admin/developers/webhooks](https://app.dcal.ai/admin/developers/webhooks)                                                    |
| **API and webhooks** > **API docs** | Opens the API reference for your own code, in a new tab. [api.dcal.ai/docs](https://api.dcal.ai/docs)                                                                                                                                                                          |

The banner and the **Connect your agent** card on **Home** open the connect page, and so do older links to [app.dcal.ai/admin/developers](https://app.dcal.ai/admin/developers) and [app.dcal.ai/admin/settings/developer](https://app.dcal.ai/admin/settings/developer).

<figure><img src="https://3835013762-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FCy5rSNtQmtqYCGzJlNEB%2Fuploads%2Fgit-blob-009bc3880f072ad95498e46102418257d2e20127%2Fdcal-mcp-server-01-connect-your-agent.png?alt=media" alt="The top of the Connect your agent page: the MCP eyebrow, the heading Connect Claude, ChatGPT, Codex or Cursor to dCal, its intro and a Tools button at the top right, then the Connect with your account card with its Recommended badge and three points, and the tabs Claude, ChatGPT, Claude Code, Codex, Cursor, OpenClaw and Hermes"><figcaption><p><strong>Connect your agent</strong> starts with signing in: no key to create.</p></figcaption></figure>

> **💡 Tip:** **API docs**, inside **API and webhooks**, opens the API reference in a new tab. **Docs**, further down the left menu, opens these help pages, also in a new tab.

Every setup on **Connect your agent** signs in: the page has no steps for a key. To connect with a key, follow the steps below. On a self-hosted copy where sign-in for AI apps is off, the page says **The connector is not available on this installation** instead (see [Self-hosting](https://docs.dapta.ai/dcal/developers/self-hosting.md#ai-assistants-analytics-and-search-engines)).

***

## Create a key for your assistant

With a key, your assistant proves who it is without signing in. A key belongs to your whole workspace and can do only what you allow.

**Step 1:** In the left menu, open **API and webhooks** > **API keys**, or go straight to [app.dcal.ai/admin/developers/keys](https://app.dcal.ai/admin/developers/keys).

**Step 2:** Click **Create key**, in the **API keys** header. Type a **Name** that says which assistant uses it, for example `Cursor on Jane's laptop`.

**Step 3:** Under **Access this key grants**, tick only what the assistant needs. **Check free times** is ticked for you. A label on each line tells you whether the access only looks (**Read**), changes your calendar (**Write**) or cannot be undone (**Destructive**).

| Access                                                     | Label       | What the assistant can then do                                                                                                               |
| ---------------------------------------------------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| **See event types**                                        | Read        | List your event types and get their public links.                                                                                            |
| **Check free times**                                       | Read        | Find the open times of any of your event types, personal or team.                                                                            |
| **Read bookings**                                          | Read        | List bookings and the requests waiting for your answer, and read one booking in full, including what the guest wrote.                        |
| **Create, hold, reschedule, confirm and decline bookings** | Write       | Hold a time, book meetings on any event type of your workspace, move them, and confirm or decline booking requests. Your guests are emailed. |
| **Cancel bookings**                                        | Destructive | Cancel meetings and email your guests. A cancellation cannot be undone.                                                                      |
| **See connected calendars**                                | Read        | Nothing over MCP. It is used by the [Cal.com-compatible API](https://docs.dapta.ai/dcal/developers/cal-com-compatible-api.md).               |

Common choices:

* An assistant that answers questions about your schedule: **See event types**, **Check free times** and **Read bookings**.
* An assistant that also books and answers requests for you: add **Create, hold, reschedule, confirm and decline bookings**.
* Add **Cancel bookings** only if you want the assistant to cancel meetings.

**Step 4:** Under **Event types**, keep **All event types**, or choose **Only these event types** and tick the ones the assistant may use. The list shows your own event types and every team's, with the team's name in parentheses. With a limited key, the tools that need a key cannot see or book any other event type, nor read the bookings made on them. The tools for public booking pages still work on any public page, as they do for anyone.

**Step 5:** Under **Expires**, choose **Never**, **In 30 days**, **In 90 days** or **In 365 days**. An expired key stops working, just like a revoked one.

<figure><img src="https://3835013762-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FCy5rSNtQmtqYCGzJlNEB%2Fuploads%2Fgit-blob-968841f789f6f661f31bb5831a3129b8e314dffa%2Fdcal-mcp-server-02-create-key-dialog.png?alt=media" alt="The Create key dialog with the name Cursor on Jane&#x27;s laptop and three boxed sections: Access this key grants with four lines ticked (three Read, one Write), Event types with Only these event types and Intro call ticked, and Expires set to In 90 days"><figcaption><p>A key for a booking assistant: four kinds of access, one event type, and an expiry date.</p></figcaption></figure>

***

**Step 6:** Click **Create key**. The button stays disabled until the key has a name, at least one access and, with **Only these event types**, at least one event type. The key appears once, above the list, under the line *Copy this now*. Select it and copy it: there is no copy button, and once you reload or leave the page dCal cannot show it again.

> **⚠️ Note:** Treat the key like a password: anyone who holds it can act on your workspace within its access. Keep it on your own computer or server. Never paste it into a chat, a shared document, a config file you commit, or a URL.

The key's row in the list then shows what it may do: its access, **All event types** or how many it is limited to, when it expires, and **Last used** with a date, or **Never used**. Dates are in UTC and written as year, month and day, for example `2026-11-03`.

<figure><img src="https://3835013762-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FCy5rSNtQmtqYCGzJlNEB%2Fuploads%2Fgit-blob-051d409f660cf25793c6c6cd889cd4b77bc7ee2d%2Fdcal-mcp-server-03-key-row.png?alt=media" alt="The API keys header with its Create key button, above a key row with the name Cursor on Jane&#x27;s laptop, the start and end of the key, chips for the four kinds of access it grants, the line Only 1 event type(s), Expires 2027-01-18, Never used, and the Revoke button"><figcaption><p>Each key shows its access, its event types, its expiry and when it was last used.</p></figcaption></figure>

***

## Connect your assistant with a key

**Step 7:** Put the key in your environment:

```bash
export DAPTA_CALENDARS_API_KEY="dcl_your_key_here"
```

Replace `dcl_your_key_here` with your key and run the line in the terminal you start your assistant from. Every setup below reads the key from the variable `DAPTA_CALENDARS_API_KEY`, the same one the agent skill uses, so the key itself is never pasted into a config file or a link.

**Step 8:** Add the server to your assistant with the setup for it below. Each one registers the server as `dcal`, the name the connect page uses; a setup made earlier under the name `dapta-calendars` keeps working.

### Cursor

Paste this into `.cursor/mcp.json` (one project) or `~/.cursor/mcp.json` (all projects):

```json
{
  "mcpServers": {
    "dcal": {
      "url": "https://mcp.dcal.ai/mcp",
      "headers": {
        "Authorization": "Bearer ${env:DAPTA_CALENDARS_API_KEY}"
      }
    }
  }
}
```

Cursor reads the key from your environment when it starts. To connect Cursor by signing in instead, use the **Cursor** tab on **Connect your agent**: see [Connect Claude or ChatGPT by signing in](https://docs.dapta.ai/dcal/developers/connect-with-sign-in.md#cursor).

### Claude Code

Run this once in your terminal:

```bash
claude mcp add --transport http dcal https://mcp.dcal.ai/mcp \
  --header 'Authorization: Bearer ${DAPTA_CALENDARS_API_KEY}'
```

Keep the single quotes around the header. They stop your shell from filling in the variable, so Claude Code saves the name `${DAPTA_CALENDARS_API_KEY}` and reads your key each time it starts, instead of saving the key itself. To connect Claude Code by signing in instead, use the **Claude Code** tab on **Connect your agent**: see [Connect Claude or ChatGPT by signing in](https://docs.dapta.ai/dcal/developers/connect-with-sign-in.md#claude-code). The two cannot share the name `dcal`: give one of them another name.

### Codex

Add this to `~/.codex/config.toml`, or to `.codex/config.toml` in a trusted project:

```toml
[mcp_servers.dcal]
url = "https://mcp.dcal.ai/mcp"
bearer_token_env_var = "DAPTA_CALENDARS_API_KEY"
```

### Other agents

Any agent or SDK that speaks MCP over HTTP needs two things:

|                             |                                                        |
| --------------------------- | ------------------------------------------------------ |
| **Server address**          | `https://mcp.dcal.ai/mcp`                              |
| **Header on every request** | `Authorization: Bearer <your DAPTA_CALENDARS_API_KEY>` |

The server takes `POST` requests with a JSON body (`Content-Type: application/json`) over Streamable HTTP, with no session to open or close. Send the key only in the `Authorization` header: a request that puts a key in the address is refused. Call the server from your own server or a local app, not from a web page: a request that carries a browser's `Origin` header is refused.

### Claude, ChatGPT, OpenClaw and Hermes

These apps connect by signing in, with no key, from their tabs on **Connect your agent**. Their steps are in [Connect Claude or ChatGPT by signing in](https://docs.dapta.ai/dcal/developers/connect-with-sign-in.md).

***

## Check the connection

**Step 9:** Ask your assistant something that only reads, for example:

> Which workspace are you connected to in dCal, and what are you allowed to do there?

The assistant calls the `whoami` tool and answers with the workspace's name, its owner's name and time zone, and what it may do. With a key, the key's row in **API keys** then shows **Last used** with a date.

If the assistant reports that it cannot connect, or dCal answers `Invalid, expired or revoked API key.`, check that the variable holds the whole key, that the assistant was started from the terminal where you set it, and that the key is not revoked or expired.

***

## No MCP in your agent? Use the agent skill

Some agents run commands in a terminal but cannot connect to an MCP server. For them, **API and webhooks** > **API keys** ends with **No MCP in your agent?** and the **Download the skill** button: a zip that teaches any agent with a terminal to use the dCal API with an API key. Only owners and admins can download it.

**Step 1:** Create a key with the access the agent needs, and set it in your terminal as `DAPTA_CALENDARS_API_KEY`, as in [Connect your assistant with a key](#connect-your-assistant-with-a-key). The skill never contains a key: the agent reads it from that variable.

**Step 2:** Click **Download the skill**. The button reads **Preparing the skill…** while dCal builds the zip, then your browser saves `dapta-calendars-skill.zip`.

**Step 3:** Unzip it where your agent reads it. The `INSTALL.md` inside has the exact commands for Claude Code, Codex and Cursor, and a request that checks your key. For Claude Code, for all your projects:

```bash
unzip -o dapta-calendars-skill.zip -d ~/.claude/skills/
```

For Codex, the folder goes into your project, with a section in `AGENTS.md` that points to it. For Cursor, it goes into your project, with a rule in `.cursor/rules/`. Running the same commands again updates the skill.

The zip unpacks to a `dapta-calendars` folder:

| File                     | What it holds                                                                                   |
| ------------------------ | ----------------------------------------------------------------------------------------------- |
| `SKILL.md`               | The instructions the agent follows, under the title "dCal API".                                 |
| `INSTALL.md`             | How to set the key and install the skill in Claude Code, Codex and Cursor.                      |
| `reference/endpoints.md` | The API routes the agent can call.                                                              |
| `reference/mcp-tools.md` | The MCP tools, whether each one reads, writes or is destructive, and the access each one needs. |
| `reference/openapi.json` | The machine-readable description of the API, with dCal's API address filled in.                 |

The skill is written in English. If the download fails, the line under the button says why: sign in again when your session has ended, or try again a moment later.

***

## What an assistant can and cannot do

**Tools**, in the left menu, lists the 33 tools in six groups, each in plain words with an example request, such as "When am I free for a 30-minute call this week?". You never call a tool yourself: you ask in your own words and the assistant picks the right one. The page shows no tool names and no access labels; the table below gives both.

| The assistant can                                                                                                           | Tool                                                                                                           | What a key needs                                                                                                             |
| --------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Find the open times of an event on a public booking page                                                                    | `find_available_slots`                                                                                         | Nothing on a public page                                                                                                     |
| Find the open times of a team event on a public team page                                                                   | `find_team_slots`                                                                                              | Nothing on a public page                                                                                                     |
| Hold a time on a public booking page for about 10 minutes while the guest decides                                           | `hold_slot`                                                                                                    | Nothing on a public page                                                                                                     |
| Book a time on a public booking page, as a guest would                                                                      | `book_meeting`                                                                                                 | Nothing                                                                                                                      |
| Book with a team on a public team page; a host free in their own working hours is picked                                    | `book_team_meeting`                                                                                            | Nothing on a public page                                                                                                     |
| Say which workspace and which access it has                                                                                 | `whoami`                                                                                                       | Any key, or a sign-in                                                                                                        |
| List the workspaces it can act in                                                                                           | `list_my_accounts`                                                                                             | Any key, or a sign-in                                                                                                        |
| List your event types and get an event's public link                                                                        | `list_event_types`, `get_booking_page_link`                                                                    | **See event types**                                                                                                          |
| Find the open times of one of your event types by its ID                                                                    | `find_available_slots`, `find_team_slots`                                                                      | **Check free times**                                                                                                         |
| List bookings and pending requests, and read one booking in full                                                            | `list_bookings`, `list_pending_bookings`, `get_booking`                                                        | **Read bookings**                                                                                                            |
| Hold, book, move, confirm or decline on any of your event types                                                             | `hold_slot`, `create_booking`, `book_team_meeting`, `reschedule_booking`, `confirm_booking`, `decline_booking` | **Create, hold, reschedule, confirm and decline bookings**                                                                   |
| Cancel a booking                                                                                                            | `cancel_booking`                                                                                               | **Cancel bookings**                                                                                                          |
| Put an event of your own on your calendar, alone or with up to 10 people, at any time, once or repeating, with a video link | `create_event`                                                                                                 | **Create, hold, reschedule, confirm and decline bookings**, with no event type limit                                         |
| See when you and other people are free before putting a meeting on your calendar                                            | `check_attendee_availability`                                                                                  | **Check free times** (a key also needs **Create, hold, reschedule, confirm and decline bookings**), with no event type limit |

A sign-in can use every tool. The inputs and answers of every tool, and the common flows, are in the [MCP tools reference](https://docs.dapta.ai/dcal/developers/mcp-tools.md).

What an assistant cannot do: edit your event types, hours or settings, or manage webhooks, API keys, members or teams. A key reaches only its own workspace. A sign-in reaches the workspaces where you are an owner or admin: see [If you belong to several workspaces](https://docs.dapta.ai/dcal/developers/connect-with-sign-in.md#if-you-belong-to-several-workspaces).

For your own code, **API and webhooks** > **API docs** opens the API reference, [api.dcal.ai/docs](https://api.dcal.ai/docs), in a new tab. Its introduction links the OpenAPI document, [api.dcal.ai/openapi.json](https://api.dcal.ai/openapi.json), the machine-readable description of every route a key can call. See [REST API](https://docs.dapta.ai/dcal/developers/rest-api.md#openapi-document).

How bookings made by an assistant behave:

* **Only offered times.** The assistant can book only a start time dCal offers, the same times your booking page shows. A time that was just taken is refused, and the assistant looks for another. A time past the event's booking window is answered like any time the event does not offer.
* **A time can be held first.** On a one-host event, `hold_slot` keeps a time for about 10 minutes while the assistant confirms the details with your guest: no slot list offers it, and the MCP booking tools do not book it for anyone else. The assistant then books it with the hold's ID. A hold that is not used simply expires.
* **Requests wait for an answer.** On an event with **Requires confirmation**, the assistant can list the requests waiting for you, then confirm or decline each one. Confirming checks your calendar first and refuses a time that filled up meanwhile.
* **No double bookings on a retry.** Every booking, hold, move, confirmation or decline carries a key the assistant makes up for that one action. If it sends the same action twice, dCal answers with the first result and books nothing new. Cancelling a booking that is already cancelled simply succeeds again.
* **Your guests are emailed.** A booking, a move, a confirmation, a decline or a cancellation sends your guest the usual email, so a good assistant asks you before it acts.
* **A move gives the booking a new ID.** The old ID is linked to the new one, and your webhooks receive `booking.rescheduled` with both.
* **Moving, declining and cancelling are marked destructive.** They replace, turn down or call off a booking and email your guest. Apps that honor that mark ask you before they run one.
* **Booking links point to your booking pages.** The links the assistant gets for your events start with `https://book.dcal.ai`, followed by your custom link when you have one. A link to one of your pages that starts with `app.dcal.ai` also works as input.

***

## Keep it safe

* **Give each assistant its own key, with only the access it needs.** Limit it to the event types it works with, and set an expiry when the work has an end date.
* **A sign-in has your full owner or admin access.** Connect by signing in only the apps you trust with that. For less, use a key.
* **Keys never travel in configs or links.** Every setup reads the key from an environment variable, and a sign-in needs no key at all.
* **What your guests typed is handled as data, not instructions.** Names, emails, phone numbers, notes, answers and reasons, plus event titles, host names and locations, reach the assistant cleaned: hidden characters, HTML and markdown images are removed, links keep only their visible text, and each value is cut to a maximum length. `get_booking` puts everything a guest typed under `invitee_supplied` and tells the assistant never to follow instructions found there. `list_bookings` and `list_pending_bookings` return no names, notes or answers, only the domain of each guest's email.
* **Each connection is limited to its workspaces.** Anything outside them, or outside a key's event types, answers as if it did not exist.
* **Calls are rate limited.** Each key, and each signed-in person, can make bursts of up to 30 read calls, refilling 1 per second, and up to 10 calls that book, hold, move, confirm, decline or cancel, refilling 1 every 5 seconds. Calls with no key, and calls from a sign-in that reaches no workspace yet, are counted per address. dCal counts on each of its servers separately, so treat these numbers as approximate.
* **Each call is logged without your data.** dCal keeps one line per tool call with who called (a key's prefix, or the sign-in), the tool, the result and the time it took, never the key, a guest's details or what they wrote.

***

## Revoke a key

**Step 1:** On **API and webhooks** > **API keys**, click **Revoke** on the key's row.

**Step 2:** Confirm in the **Revoke this key?** dialog. dCal shows **Key revoked.** and marks the row **revoked**. There is no undo.

<figure><img src="https://3835013762-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FCy5rSNtQmtqYCGzJlNEB%2Fuploads%2Fgit-blob-c19b5defea025d1855ce46415276b62a706f0b52%2Fdcal-mcp-server-06-revoke-dialog.png?alt=media" alt="The Revoke this key? dialog naming the key Cursor on Jane&#x27;s laptop, with the Cancel and Revoke buttons"><figcaption><p>A revoked key stops working on the assistant's next call.</p></figcaption></figure>

From its next call, the assistant gets `Invalid, expired or revoked API key.` To replace a key, create the new one first, update the variable, restart the assistant, then revoke the old key.

To end a signed-in connection, remove the connector in the app. An owner can also cut it off at once by removing that person's admin role. See [Disconnect](https://docs.dapta.ai/dcal/developers/connect-with-sign-in.md#disconnect).

## Related

* [Connect Claude or ChatGPT by signing in](https://docs.dapta.ai/dcal/developers/connect-with-sign-in.md): connect with your Dapta account, no key.
* [MCP tools reference](https://docs.dapta.ai/dcal/developers/mcp-tools.md): every tool's inputs, answers and errors.
* [API keys](https://docs.dapta.ai/dcal/developers/api-keys.md): keys for your own systems and the REST API.
* [Security and privacy](https://docs.dapta.ai/dcal/security-and-privacy.md): how keys and guest data are protected.
* [Let your Dapta agent book](https://docs.dapta.ai/dcal/dapta-agents.md): the no-code way for a Dapta agent to book on dCal.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.dapta.ai/dcal/developers/mcp-server.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
