> ## Documentation Index
> Fetch the complete documentation index at: https://developer.meetergo.com/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP Server

> Connect AI applications to meetergo documentation using the Model Context Protocol

The meetergo MCP (Model Context Protocol) server allows AI applications to search and retrieve information from our documentation in real-time.

## Overview

MCP is an open protocol that enables AI assistants like Claude, ChatGPT, and custom AI applications to access external knowledge bases. With meetergo's hosted MCP server, your AI application can:

* Search across the entire meetergo knowledge base
* Find relevant API references and code examples
* Access up-to-date documentation without manual updates
* Provide accurate answers about meetergo features and integration

```mermaid theme={null}
sequenceDiagram
    participant User
    participant AI Application
    participant meetergo MCP Server
    participant Documentation

    User->>AI Application: "How do I book an appointment via API?"
    AI Application->>meetergo MCP Server: SearchMeetergo("book appointment API")
    meetergo MCP Server->>Documentation: Query knowledge base
    Documentation-->>meetergo MCP Server: Relevant docs & examples
    meetergo MCP Server-->>AI Application: Structured results
    AI Application->>User: Accurate answer with code examples
```

## MCP Server URL

Use the following URL to connect AI applications to meetergo documentation:

```
https://developer.meetergo.com/mcp
```

## Available Tools

### SearchMeetergo

Search across the meetergo knowledge base to find relevant information, code examples, API references, and guides.

**Use this tool when you need to:**

* Answer questions about meetergo
* Find specific documentation
* Understand how features work
* Locate implementation details

The search returns contextual content with titles and direct links to the documentation pages.

**Parameters:**

| Parameter | Type   | Required | Description                                     |
| --------- | ------ | -------- | ----------------------------------------------- |
| `query`   | string | Yes      | The search query to find relevant documentation |

**Example Request:**

```json theme={null}
{
  "tool": "SearchMeetergo",
  "parameters": {
    "query": "webhook events booking created"
  }
}
```

**Example Response:**

```json theme={null}
{
  "results": [
    {
      "title": "Webhook Events",
      "url": "https://developer.meetergo.com/developer-docs/webhooks/events",
      "content": "The booking.created event fires when a new booking is confirmed..."
    },
    {
      "title": "Webhooks Overview",
      "url": "https://developer.meetergo.com/developer-docs/webhooks/overview",
      "content": "Configure webhooks to receive real-time notifications..."
    }
  ]
}
```

## Integration Examples

### Claude Desktop

Add meetergo's MCP server to your Claude Desktop configuration:

<Steps>
  <Step title="Open Claude Desktop settings">
    Navigate to Claude Desktop → Settings → Developer → MCP Servers
  </Step>

  <Step title="Add the meetergo server">
    Click "Add Server" and enter the following configuration:

    ```json theme={null}
    {
      "mcpServers": {
        "meetergo": {
          "url": "https://developer.meetergo.com/mcp"
        }
      }
    }
    ```
  </Step>

  <Step title="Restart Claude Desktop">
    Close and reopen Claude Desktop to activate the MCP server
  </Step>
</Steps>

Once configured, Claude can automatically search meetergo documentation when you ask questions about the platform.

### Cursor IDE

Add meetergo documentation access to Cursor:

<Steps>
  <Step title="Open Cursor settings">
    Press `Cmd+,` (Mac) or `Ctrl+,` (Windows/Linux) to open settings
  </Step>

  <Step title="Navigate to MCP configuration">
    Search for "MCP" in settings or navigate to Features → MCP Servers
  </Step>

  <Step title="Add the meetergo server">
    Add a new MCP server with URL:

    ```
    https://developer.meetergo.com/mcp
    ```
  </Step>
</Steps>

### Claude Code CLI

Add meetergo's MCP server to your Claude Code configuration:

```bash theme={null}
claude mcp add meetergo --transport sse https://developer.meetergo.com/mcp
```

Or manually add to your `~/.claude/settings.json`:

```json theme={null}
{
  "mcpServers": {
    "meetergo": {
      "url": "https://developer.meetergo.com/mcp",
      "transport": "sse"
    }
  }
}
```

### Custom AI Applications

For custom AI applications using the MCP protocol, connect to the server using the standard MCP client:

```typescript theme={null}
import { MCPClient } from '@modelcontextprotocol/sdk';

const client = new MCPClient({
  serverUrl: 'https://developer.meetergo.com/mcp'
});

// Search meetergo documentation
const results = await client.callTool('SearchMeetergo', {
  query: 'how to create a booking'
});

console.log(results);
```

### Python Example

```python theme={null}
from mcp import MCPClient

client = MCPClient(server_url="https://developer.meetergo.com/mcp")

# Search for documentation
results = client.call_tool(
    "SearchMeetergo",
    {"query": "availability API endpoint"}
)

for result in results:
    print(f"{result['title']}: {result['url']}")
```

## Use Cases

<CardGroup cols={2}>
  <Card title="AI Customer Support" icon="headset">
    Build support bots that can accurately answer questions about meetergo integration and features
  </Card>

  <Card title="Developer Assistants" icon="code">
    Enhance your IDE AI assistant with meetergo-specific knowledge for faster development
  </Card>

  <Card title="Documentation Chatbots" icon="comments">
    Create conversational interfaces for your meetergo documentation
  </Card>

  <Card title="Internal Tools" icon="screwdriver-wrench">
    Build internal tools that help your team work with meetergo APIs
  </Card>
</CardGroup>

## Best Practices

<Check>
  **Be specific with queries** - More specific queries return more relevant results
</Check>

<Check>
  **Combine with API calls** - Use MCP for documentation lookup, then make actual API calls for operations
</Check>

<Check>
  **Cache frequent queries** - If your application makes repeated similar queries, consider caching results
</Check>

<Check>
  **Handle empty results** - Always handle cases where no relevant documentation is found
</Check>

<Warning>
  The MCP server provides **read-only** access to documentation. To perform actual operations like creating bookings, use the [meetergo REST API](/api-reference/introduction).
</Warning>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Connection refused or timeout">
    * Verify the URL is correct: `https://developer.meetergo.com/mcp`
    * Check your network connection and firewall settings
    * Ensure your MCP client supports SSE (Server-Sent Events) transport
  </Accordion>

  <Accordion title="Empty search results">
    * Try broader search terms
    * Check spelling of technical terms
    * Search for related concepts if exact term isn't found
  </Accordion>

  <Accordion title="MCP client compatibility">
    * Ensure your MCP client is up to date
    * meetergo's MCP server uses the standard MCP protocol
    * Check the [MCP specification](https://modelcontextprotocol.io) for compatibility requirements
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup cols={2}>
  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Explore the full meetergo REST API documentation
  </Card>

  <Card title="Quickstart Guide" icon="rocket" href="/developer-docs/quickstart">
    Get started with meetergo API integration
  </Card>
</CardGroup>