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

# AI Tool Integration

> Connect Claude Code, Cursor, Roo Code and other AI assistants to your MCP servers

# AI Tool Integration

<Info>
  Connect your favorite AI coding assistants to Requesty's MCP Gateway for seamless access to external tools and services. Works with Claude Code, Cursor, Roo Code, and any MCP-compatible tool.

  <Note>
    **[Set up MCP integration](https://app.requesty.ai/mcp-gateway)** in the Requesty Console.
  </Note>
</Info>

## Supported AI Tools

### Primary Integrations

<CardGroup cols={2}>
  <Card title="Claude Code" icon="robot">
    Anthropic's official CLI with native MCP support
  </Card>

  <Card title="Cursor" icon="cursor-click">
    AI-powered code editor with integrated MCP capabilities
  </Card>

  <Card title="Roo Code" icon="code">
    Advanced AI coding assistant with MCP protocol support
  </Card>

  <Card title="VS Code Extensions" icon="code-2">
    Various VS Code extensions supporting MCP protocol
  </Card>
</CardGroup>

### Protocol Support

| Tool Type             | Protocol                     | Status            |
| --------------------- | ---------------------------- | ----------------- |
| **HTTP-based Tools**  | streamable-http, SSE         | ✅ Fully Supported |
| **CLI Tools**         | HTTP API calls               | ✅ Fully Supported |
| **Editor Extensions** | HTTP/WebSocket               | ✅ Fully Supported |
| **STDIO Tools**       | Direct process communication | 🚧 Coming Soon    |

## Claude Code Integration

### Automatic Discovery

Claude Code automatically discovers MCP servers through your Requesty API configuration:

<Steps>
  <Step title="API Key Configuration">
    Claude Code uses your Requesty API key for authentication
  </Step>

  <Step title="Server Discovery">
    Automatically detects available MCP servers in your organization
  </Step>

  <Step title="Tool Loading">
    Loads all enabled tools from registered MCP servers
  </Step>

  <Step title="Ready to Use">
    Tools appear in Claude Code's available functions automatically
  </Step>
</Steps>

### Configuration

No additional configuration needed - Claude Code works out of the box with Requesty:

```bash theme={"dark"}
# Claude Code automatically uses your Requesty API key
# and discovers available MCP servers
claude --help
```

### Usage Example

```bash theme={"dark"}
# Claude Code can now use MCP tools directly
claude "Search for React components in our codebase and create a new one"
# This might use GitHub MCP server to search code
# and file system MCP tools to create new files
```

## Cursor Integration

### Setup Process

<Steps>
  <Step title="Open Cursor Settings">
    Navigate to **Settings → Features → MCP Integration**
  </Step>

  <Step title="Add Requesty Provider">
    Configure Requesty as your MCP provider
  </Step>

  <Step title="API Key Configuration">
    Enter your Requesty API key for authentication
  </Step>

  <Step title="Server Sync">
    Cursor will sync available MCP servers from your organization
  </Step>
</Steps>

### Configuration File

Add to your Cursor settings:

```json theme={"dark"}
{
  "requesty": {
    "url": "https://router.requesty.ai/v1/mcp",
    "headers": {
      "Authorization": "Bearer YOUR_REQUESTY_API_KEY"
    }
  }
}
```

### Features

<Tabs>
  <Tab title="Code Assistant">
    * **Contextual Tools**: MCP tools appear in coding context
    * **Smart Suggestions**: Cursor suggests relevant MCP tools
    * **Inline Actions**: Execute MCP tools directly in the editor
    * **Real-time Updates**: Live sync with Requesty MCP servers
  </Tab>

  <Tab title="Chat Interface">
    * **Tool Access**: Use MCP tools in Cursor's chat
    * **Multi-tool Workflows**: Chain multiple MCP operations
    * **Error Handling**: Graceful error handling and retry logic
    * **Progress Tracking**: Visual feedback for long-running operations
  </Tab>
</Tabs>

## Roo Code Integration

### Connection Setup

<Steps>
  <Step title="Configuration File">
    Create or update your Roo Code configuration
  </Step>

  <Step title="MCP Provider">
    Set Requesty as your MCP provider
  </Step>

  <Step title="Authentication">
    Configure your Requesty API key
  </Step>

  <Step title="Tool Discovery">
    Roo Code will discover available tools automatically
  </Step>
</Steps>

### Configuration

Add to your `roo.config.json`:

```json theme={"dark"}
{
  "requesty": {
    "url": "https://router.requesty.ai/v1/mcp",
    "headers": {
      "Authorization": "Bearer YOUR_REQUESTY_API_KEY"
    }
  }
}
```

### Advanced Features

* **Tool Chaining**: Combine multiple MCP tools in single workflows
* **Context Awareness**: Tools receive relevant context automatically
* **Performance Optimization**: Intelligent caching and request batching
* **Custom Workflows**: Create reusable workflows with MCP tools

## VS Code Extensions

### MCP Protocol Extensions

Several VS Code extensions support MCP protocol:

<AccordionGroup>
  <Accordion title="AI Coding Assistants">
    * **GitHub Copilot**: Can use MCP tools for enhanced context
    * **Tabnine**: MCP integration for better code suggestions
    * **CodeT5**: Enhanced code generation with MCP tools
    * **Custom Extensions**: Build your own MCP-enabled extensions
  </Accordion>

  <Accordion title="Setup Instructions">
    1. Install MCP-compatible VS Code extension
    2. Configure extension settings to use Requesty MCP endpoint
    3. Add your Requesty API key to extension configuration
    4. Enable MCP tool discovery in extension settings
  </Accordion>
</AccordionGroup>

### Extension Configuration

Example for MCP-enabled VS Code extensions:

```json theme={"dark"}
{
  "requesty": {
    "url": "https://router.requesty.ai/v1/mcp",
    "headers": {
      "Authorization": "Bearer YOUR_REQUESTY_API_KEY"
    }
  }
}
```

## Custom Tool Integration

### MCP Client Libraries

For custom integrations, use MCP client libraries:

<Tabs>
  <Tab title="Python">
    ```python theme={"dark"}
    from mcp_client import MCPClient

    client = MCPClient(
        url="https://router.requesty.ai/v1/mcp",
        headers={"Authorization": "Bearer YOUR_REQUESTY_API_KEY"}
    )

    # Discover available tools
    tools = client.list_tools()

    # Execute a tool
    result = client.call_tool("github_search", {
        "query": "React components",
        "repository": "my-org/my-repo"
    })
    ```
  </Tab>

  <Tab title="JavaScript/TypeScript">
    ```typescript theme={"dark"}
    import { MCPClient } from '@mcp/client';

    const client = new MCPClient({
      url: 'https://router.requesty.ai/v1/mcp',
      headers: { 'Authorization': 'Bearer YOUR_REQUESTY_API_KEY' }
    });

    // Discover tools
    const tools = await client.listTools();

    // Execute tool
    const result = await client.callTool('notion_search', {
      query: 'project documentation',
      database_id: 'your-database-id'
    });
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={"dark"}
    package main

    import (
        "github.com/mcp/client-go"
    )

    func main() {
        client := mcp.NewClient(&mcp.Config{
            URL: "https://router.requesty.ai/v1/mcp",
            Headers: map[string]string{
                "Authorization": "Bearer YOUR_REQUESTY_API_KEY",
            },
        })

        // List available tools
        tools, err := client.ListTools()
        if err != nil {
            log.Fatal(err)
        }

        // Execute a tool
        result, err := client.CallTool("linear_create_issue", map[string]interface{}{
            "title":       "New feature request",
            "description": "Detailed description here",
            "team_id":     "your-team-id",
        })
    }
    ```
  </Tab>
</Tabs>

## Authentication Flow

### API Key Management

<Steps>
  <Step title="Requesty API Key">
    Your AI tool authenticates with Requesty using your API key
  </Step>

  <Step title="Organization Context">
    Requesty identifies your organization and available MCP servers
  </Step>

  <Step title="MCP Server Authentication">
    Requesty handles authentication with individual MCP servers using configured keys
  </Step>

  <Step title="Tool Execution">
    Requests are proxied to the appropriate MCP server with proper authentication
  </Step>
</Steps>

### Security Benefits

<CardGroup cols={2}>
  <Card title="Centralized Authentication" icon="shield">
    Single API key for access to all MCP servers
  </Card>

  <Card title="Key Isolation" icon="lock">
    MCP server keys are never exposed to AI tools
  </Card>

  <Card title="Access Control" icon="user-check">
    Organization-level control over tool access
  </Card>

  <Card title="Audit Trail" icon="file-text">
    Complete logging of all MCP tool usage
  </Card>
</CardGroup>

## Best Practices

### For Users

* **Regular Updates**: Keep AI tools updated for latest MCP features
* **Tool Familiarization**: Learn what each MCP tool does and when to use it
* **Error Handling**: Understand how to troubleshoot tool execution issues
* **Context Awareness**: Provide clear context when requesting tool usage

### For Administrators

* **Tool Curation**: Only enable tools that your team actually needs
* **Performance Monitoring**: Track tool usage and performance metrics
* **Security Reviews**: Regular audits of enabled tools and permissions
* **User Training**: Educate users on available tools and best practices

***

<Card title="Next Steps" icon="arrow-right">
  Once your AI tools are connected, explore [MCP Analytics](/features/mcp-analytics) to monitor usage or learn about [Server Management](/features/mcp-server-management) to add more tools.
</Card>