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

# Claude Integration

> Use Syncline with Claude Desktop and Claude Code

## Overview

Integrate Syncline with Claude Desktop or Claude Code to give Claude the ability to schedule meetings, find availability, and manage calendars directly.

## Prerequisites

<Steps>
  <Step title="Install Syncline MCP Server">
    ```bash theme={null}
    npm install -g @kekwanulabs/syncline-mcp-server
    ```

    See [Installation](/mcp/installation) for details.
  </Step>

  <Step title="Get Platform API Key">
    Sign up at [syncline.run/developer/login](https://syncline.run/developer/login) to get your API key.
  </Step>

  <Step title="Have Claude Desktop or Claude Code">
    Download [Claude Desktop](https://claude.ai/download) or install [Claude Code](https://code.claude.com).
  </Step>
</Steps>

## Setup for Claude Desktop

### 1. Locate Configuration File

The Claude Desktop configuration file location varies by OS:

<Tabs>
  <Tab title="macOS">
    ```
    ~/Library/Application Support/Claude/claude_desktop_config.json
    ```
  </Tab>

  <Tab title="Windows">
    ```
    %APPDATA%\Claude\claude_desktop_config.json
    ```
  </Tab>

  <Tab title="Linux">
    ```
    ~/.config/Claude/claude_desktop_config.json
    ```
  </Tab>
</Tabs>

### 2. Add Syncline Configuration

Edit the config file and add the Syncline MCP server:

```json theme={null}
{
  "mcpServers": {
    "syncline": {
      "command": "npx",
      "args": ["-y", "@kekwanulabs/syncline-mcp-server"],
      "env": {
        "SYNCLINE_API_KEY": "sk_live_your_api_key_here"
      }
    }
  }
}
```

<Warning>
  Replace `sk_live_your_api_key_here` with your actual Syncline Platform API key from the developer dashboard.
</Warning>

### 3. Restart Claude Desktop

Close and reopen Claude Desktop for changes to take effect.

### 4. Verify Integration

In Claude Desktop, start a new conversation and try:

```
Schedule a 30-minute meeting between alice@example.com and bob@example.com tomorrow at 2pm
```

Claude should use the Syncline MCP tools to complete the request.

## Setup for Claude Code

Claude Code automatically detects MCP servers configured in the same format as Claude Desktop.

### Using Project-Specific Configuration

For project-specific MCP servers, create a `.claude/settings.json` file in your project:

```json theme={null}
{
  "mcpServers": {
    "syncline": {
      "command": "npx",
      "args": ["-y", "@kekwanulabs/syncline-mcp-server"],
      "env": {
        "SYNCLINE_API_KEY": "sk_live_your_api_key_here"
      }
    }
  }
}
```

Claude Code will automatically load this configuration when working in the project directory.

## What Claude Can Do

Once integrated, Claude can:

<CardGroup cols={2}>
  <Card title="Find Availability" icon="calendar-days">
    "When are Alice and Bob both free this week?"
  </Card>

  <Card title="Schedule Meetings" icon="calendar-plus">
    "Schedule a 30-min meeting with [alice@example.com](mailto:alice@example.com) tomorrow at 2pm"
  </Card>

  <Card title="Check Calendars" icon="clock">
    "Is [alice@example.com](mailto:alice@example.com) free on Friday afternoon?"
  </Card>

  <Card title="Update Preferences" icon="sliders">
    "Update my work hours to 10am-6pm on weekdays"
  </Card>
</CardGroup>

## Example Conversations

### Schedule a Meeting

<CodeGroup>
  ```plaintext User theme={null}
  Can you schedule a product demo with alice@example.com and bob@example.com?
  30 minutes, sometime tomorrow afternoon would be great.
  ```

  ```plaintext Claude theme={null}
  I'll help you schedule that meeting. Let me find available times tomorrow afternoon for Alice and Bob.

  *Uses find_mutual_availability tool*

  I found several available slots tomorrow afternoon. The best options are:
  - 2:00 PM - 2:30 PM (score: 0.95)
  - 3:00 PM - 3:30 PM (score: 0.89)
  - 4:00 PM - 4:30 PM (score: 0.82)

  Would you like me to book the 2:00 PM slot?
  ```

  ```plaintext User theme={null}
  Yes, 2 PM works!
  ```

  ```plaintext Claude theme={null}
  Perfect! I've scheduled the meeting.

  *Uses schedule_meeting tool*

  Meeting Details:
  - Title: Product Demo
  - Time: Tomorrow at 2:00 PM - 2:30 PM
  - Attendees: alice@example.com, bob@example.com
  - Google Meet: https://meet.google.com/abc-defg-hij

  Calendar invites have been sent to both attendees.
  ```
</CodeGroup>

### Find Availability

<CodeGroup>
  ```plaintext User theme={null}
  When are alice@example.com and bob@example.com both free this week?
  ```

  ```plaintext Claude theme={null}
  Let me check their availability for this week.

  *Uses find_mutual_availability tool*

  Here are the times when both Alice and Bob are available this week:

  **Monday:**
  - 2:00 PM - 5:00 PM

  **Tuesday:**
  - 10:00 AM - 11:30 AM
  - 2:00 PM - 4:00 PM

  **Wednesday:**
  - 9:00 AM - 12:00 PM
  - 3:00 PM - 5:00 PM

  **Thursday:**
  - All day (9 AM - 5 PM)

  **Friday:**
  - 9:00 AM - 10:00 AM
  - 1:00 PM - 3:00 PM

  Would you like me to schedule a meeting during any of these times?
  ```
</CodeGroup>

### Check Single Person's Calendar

<CodeGroup>
  ```plaintext User theme={null}
  Is alice@example.com free on Friday afternoon?
  ```

  ```plaintext Claude theme={null}
  Let me check Alice's calendar for Friday afternoon.

  *Uses check_availability tool*

  Looking at Friday afternoon (12 PM - 5 PM):

  **Free:**
  - 12:00 PM - 1:00 PM
  - 3:00 PM - 5:00 PM

  **Busy:**
  - 1:00 PM - 3:00 PM (Team Standup)

  Alice is free from 3 PM to 5 PM on Friday afternoon. Would you like to schedule something during that time?
  ```
</CodeGroup>

## Advanced Configuration

### Multiple API Keys

If you work with multiple Syncline accounts:

```json theme={null}
{
  "mcpServers": {
    "syncline-work": {
      "command": "npx",
      "args": ["-y", "@kekwanulabs/syncline-mcp-server"],
      "env": {
        "SYNCLINE_API_KEY": "sk_live_work_account_key"
      }
    },
    "syncline-personal": {
      "command": "npx",
      "args": ["-y", "@kekwanulabs/syncline-mcp-server"],
      "env": {
        "SYNCLINE_API_KEY": "sk_live_personal_account_key"
      }
    }
  }
}
```

Claude will have access to both servers and you can specify which to use:

```
Using the syncline-work server, schedule a meeting with the engineering team
```

### Custom Installation Path

If you installed Syncline locally instead of globally:

```json theme={null}
{
  "mcpServers": {
    "syncline": {
      "command": "node",
      "args": ["/path/to/your/project/node_modules/@kekwanulabs/syncline-mcp-server/dist/index.js"],
      "env": {
        "SYNCLINE_API_KEY": "sk_live_your_api_key_here"
      }
    }
  }
}
```

### Debug Mode

Enable debug logging to troubleshoot issues:

```json theme={null}
{
  "mcpServers": {
    "syncline": {
      "command": "npx",
      "args": ["-y", "@kekwanulabs/syncline-mcp-server"],
      "env": {
        "SYNCLINE_API_KEY": "sk_live_your_api_key_here",
        "DEBUG": "true"
      }
    }
  }
}
```

Logs will appear in Claude's developer console.

## Troubleshooting

### Tools Not Showing Up

If Claude doesn't see the Syncline tools:

1. **Verify configuration syntax** - JSON must be valid
2. **Check API key** - Ensure it starts with `sk_live_`
3. **Restart Claude** - Must restart after config changes
4. **Check server logs** - Enable debug mode to see errors

### Invalid API Key Error

```
Error: Invalid API key
```

**Solution:**

* Verify API key is correct in config file
* Ensure no extra spaces or quotes
* Get a fresh key from [developer dashboard](https://syncline.run/developer/login)

### Connection Timeout

```
Error: MCP server timeout
```

**Solution:**

* Check internet connection
* Verify firewall allows access to api.syncline.run
* Try running the server manually to test:

```bash theme={null}
npx @kekwanulabs/syncline-mcp-server
```

### Permission Denied

```
Error: EACCES: permission denied
```

**Solution:**

* Run with proper permissions
* Or install globally with sudo: `sudo npm install -g @kekwanulabs/syncline-mcp-server`

## Security Best Practices

<Warning>
  Never share your API key or commit it to version control!
</Warning>

### Use Environment Variables

Instead of hardcoding the API key in the config:

1. Set environment variable in your shell:

```bash theme={null}
export SYNCLINE_API_KEY=sk_live_your_api_key_here
```

2. Reference it in config:

```json theme={null}
{
  "mcpServers": {
    "syncline": {
      "command": "npx",
      "args": ["-y", "@kekwanulabs/syncline-mcp-server"],
      "env": {
        "SYNCLINE_API_KEY": "${SYNCLINE_API_KEY}"
      }
    }
  }
}
```

### Rotate Keys Regularly

Rotate your Platform API key every 90 days:

1. Generate new key in [developer dashboard](https://syncline.run/developer/login)
2. Update configuration file
3. Restart Claude Desktop/Code

### Audit Tool Usage

Monitor MCP tool usage in your [platform dashboard](https://syncline.run/developer/dashboard) to detect unexpected activity.

## What's Next

<CardGroup cols={3}>
  <Card title="Available Tools" icon="wrench" href="/mcp/find-mutual-availability">
    Explore all MCP tools
  </Card>

  <Card title="Protocol Spec" icon="book" href="/mcp/protocol-spec">
    Learn the MCP protocol
  </Card>

  <Card title="Build Custom Agent" icon="robot" href="/mcp/python-client">
    Create your own AI agent
  </Card>
</CardGroup>
