### Install Roundtable AI MCP Server

Source: https://context7.com/askbudi/roundtable/llms.txt

Install Roundtable AI using pip or UV/UVX. Use `uvx` for faster installations. Check available AI tools with `--check` and start the server with all or specific agents.

```bash
pip install roundtable-ai
```

```bash
uvx roundtable-ai@latest
```

```bash
roundtable-ai --check
```

```bash
roundtable-ai
```

```bash
roundtable-ai --agents codex,claude,gemini
```

--------------------------------

### Install and Run Roundtable AI

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Commands to install the package and execute the server with specific agent configurations.

```bash
# Install Roundtable AI
pip install roundtable-ai

# Check available AI tools
roundtable-ai --check

# Start with all available tools
roundtable-ai

# Use specific assistants only
roundtable-ai --agents codex,claude
```

--------------------------------

### Install Roundtable AI

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Commands to install the package using pip or UVX.

```bash
pip install roundtable-ai
```

```bash
uvx roundtable-ai@latest
```

--------------------------------

### Configure Cursor MCP

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Installation links and configuration files for Cursor.

```text
cursor://anysphere.cursor-deeplink/mcp/install?name=roundtable-ai&config=eyJ0eXBlIjoic3RkaW8iLCJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyJyb3VuZHRhYmxlLWFpQGxhdGVzdCJdLCJlbnYiOnsiQ0xJX01DUF9TVUJBR0VOVFMiOiJjb2RleCxjbGF1ZGUsY3Vyc29yLGdlbWluaSJ9fQo=
```

```json
{
  "mcpServers": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

```json
{
  "mcpServers": {
    "roundtable-ai": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "roundtable-ai@latest"
      ],
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

--------------------------------

### Performance Optimization Analysis

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Example prompt for analyzing API latency and database performance.

```sql
-- Duration: 2455.112 ms
SELECT c.name, COUNT(o.id) AS total_orders, SUM(p.amount) AS revenue
FROM companies c, orders o, payments p
WHERE c.id = o.company_id
  AND o.id = p.order_id
  AND c.region = 'North America'
GROUP BY c.name
ORDER BY revenue DESC;
```

```text
Seq Scan on orders (cost=0.00..52000.00 rows=100000)
  Filter: (status = 'completed')
  Rows Removed by Filter: 134,201
```

```javascript
// 40% CPU time
orders.map(o => ({ ...o, json: JSON.stringify(o) }));

// N+1 query problem
for (const id of orderIds) {
  await fetchInventory(id);
}
```

--------------------------------

### Multi-Agent Task Prompt

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Example prompt structure for delegating tasks to multiple specialized sub-agents.

```markdown
The user dashboard is randomly slow for enterprise customers.

Use Gemini SubAgent to analyze frontend performance issues in the React components, especially expensive re-renders and inefficient data fetching.

Use Codex SubAgent to examine the backend API endpoint for N+1 queries and database bottlenecks.

Use Claude SubAgent to review the infrastructure logs and identify memory/CPU pressure during peak hours.
```

--------------------------------

### Multi-Stack Debugging Prompt

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Example prompt for debugging production issues using specialized sub-agents.

```json
{
  "timestamp": "2024-09-24T10:05:21.123Z",
  "level": "error",
  "message": "API request failed for /api/v1/user/profile",
  "error": {
    "status": 500,
    "statusText": "Internal Server Error"
  }
}
```

```text
ERROR: Exception in ASGI application
File "/app/services/user_service.py", line 42, in get_user_profile
  user_data = await db.fetch_one(query)
ValueError: Database connection is not available
```

--------------------------------

### Verification Steps

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Steps to verify the Roundtable AI integration after installation.

```APIDOC
## Verification

### Description
Verify that Roundtable AI is correctly installed and integrated.

### Steps
1. **Check server availability**: Run `roundtable-ai --check` in your terminal.
2. **Test connection**: Check your IDE's AI assistant panel for "Roundtable AI".
```

--------------------------------

### Check Gemini CLI Availability

Source: https://context7.com/askbudi/roundtable/llms.txt

Verifies if the Gemini CLI is installed and configured on the system.

```python
# MCP tool invocation example
result = await client.call_tool("check_gemini_availability", {})
# Returns: "✅ **Gemini CLI Available**\n📋 **Default Models:** gemini-2.5-pro, gemini-2.5-flash"
# Or: "❌ Gemini subagent is not enabled in this server instance"
```

--------------------------------

### Configure VS Code with UVX

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Add Roundtable AI server configuration to VS Code's settings.json when using UVX for installation.

```json
{
  "mcp.servers": {
    "roundtable-ai": {
      "command": "uvx",
      "args": ["roundtable-ai@latest"],
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

--------------------------------

### Check Cursor CLI Availability

Source: https://context7.com/askbudi/roundtable/llms.txt

Verifies if the Cursor Agent CLI is installed and configured on the system.

```python
# MCP tool invocation example
result = await client.call_tool("check_cursor_availability", {})
# Returns: "✅ **Cursor Agent CLI Available**"
# Or: "❌ **Cursor Agent CLI Unavailable:** Cursor CLI not found"
```

--------------------------------

### Add Roundtable AI to Claude Code CLI

Source: https://context7.com/askbudi/roundtable/llms.txt

Integrate Roundtable AI with Claude Code CLI using a one-liner command. This example shows how to add Roundtable AI using both pip and UVX installations, specifying the desired agents.

```bash
# One-liner for Claude Code using pip installation
claude mcp add roundtable-ai -- roundtable-ai --agents gemini,claude,codex,cursor
```

```bash
# Using UVX for installation
claude mcp add roundtable-ai -- uvx roundtable-ai@latest --agents gemini,claude,codex,cursor
```

--------------------------------

### Check Claude CLI Availability

Source: https://context7.com/askbudi/roundtable/llms.txt

Verifies if the Claude Code CLI is installed and configured on the system.

```python
# MCP tool invocation example
result = await client.call_tool("check_claude_availability", {})
# Returns: "✅ **Claude Code CLI Available**\n📋 **Default Models:** sonnet-4, opus-4.1"
# Or: "❌ **Claude Code Setup Failed:** claude_code_sdk is required but not installed"
```

--------------------------------

### Configure VS Code with pip

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Add Roundtable AI server configuration to VS Code's settings.json when using pip for installation.

```json
{
  "mcp.servers": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

--------------------------------

### Availability Check Tools

Source: https://context7.com/askbudi/roundtable/llms.txt

Endpoints to verify if specific AI CLI agents are installed and configured correctly on the system.

```APIDOC
## check_claude_availability

### Description
Checks if Claude Code CLI is available and configured properly.

### Method
call_tool

### Request Example
{
  "instruction": "check_claude_availability"
}

## check_cursor_availability

### Description
Checks if Cursor Agent CLI is available and configured properly.

### Method
call_tool

## check_gemini_availability

### Description
Checks if Gemini CLI is available and configured properly.

### Method
call_tool
```

--------------------------------

### Check Codex Availability via Python MCP Client

Source: https://context7.com/askbudi/roundtable/llms.txt

Example of how an MCP client can call the `check_codex_availability` tool. The result indicates whether the Codex CLI is available and lists default models, or states if the subagent is not enabled.

```python
# MCP tool invocation example (from an MCP client)
result = await client.call_tool("check_codex_availability", {})
# Returns: "✅ **Codex CLI Available**\n📋 **Default Models:** gpt-5, gpt-4o, claude-3.5-sonnet"
# Or: "❌ Codex subagent is not enabled in this server instance"
```

--------------------------------

### Roundtable AI Command Line Verification

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Use these commands to verify the Roundtable AI installation and connection. `roundtable-ai --check` verifies server availability, and testing the connection typically involves checking the AI assistant panel in your IDE.

```bash
# Check server availability
roundtable-ai --check

# Test connection (varies by IDE)
# Most IDEs will show "Roundtable AI" in their AI assistant panel
```

--------------------------------

### Configure Server via Environment Variables

Source: https://context7.com/askbudi/roundtable/llms.txt

Initialize ServerConfig by parsing environment variables or by direct instantiation.

```python
from roundtable_mcp_server.server import ServerConfig, parse_config_from_env
import os

# Set environment variables before parsing
os.environ["CLI_MCP_SUBAGENTS"] = "codex,gemini"
os.environ["CLI_MCP_WORKING_DIR"] = "/home/user/projects"
os.environ["CLI_MCP_DEBUG"] = "true"
os.environ["CLI_MCP_VERBOSE"] = "true"

# Parse configuration from environment
config = parse_config_from_env()

print(f"Enabled subagents: {config.subagents}")   # ['codex', 'gemini']
print(f"Working directory: {config.working_dir}") # '/home/user/projects'
print(f"Debug mode: {config.debug}")              # True
print(f"Verbose mode: {config.verbose}")          # True

# Or create config directly
config = ServerConfig(
    subagents=["codex", "claude", "cursor", "gemini"],
    working_dir="/path/to/project",
    debug=True,
    verbose=False
)
```

--------------------------------

### Configure Windsurf with UVX

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Add Roundtable AI server configuration to Windsurf's mcp_config.json using UVX.

```json
{
  "mcpServers": {
    "roundtable-ai": {
      "command": "uvx",
      "args": ["roundtable-ai@latest"],
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

--------------------------------

### Implement Custom CLI Adapter

Source: https://context7.com/askbudi/roundtable/llms.txt

Extend the BaseCLI abstract class to create new CLI providers. Implement check_availability and execute_with_streaming to satisfy the contract.

```python
from claudable_helper.cli.base import BaseCLI, CLIType
from claudable_helper.models.messages import Message
from typing import Dict, Any, Optional, List, AsyncGenerator

class CustomCLI(BaseCLI):
    """Example custom CLI adapter implementation."""

    def __init__(self):
        super().__init__(CLIType.CODEX)  # Use appropriate CLIType
        self._session_store = {}

    async def check_availability(self) -> Dict[str, Any]:
        """Check if the CLI tool is available."""
        # Implementation checks if CLI binary exists and works
        return {
            "available": True,
            "configured": True,
            "models": ["model-1", "model-2"],
            "default_models": ["model-1"],
            "error": None  # Set error message if unavailable
        }

    async def execute_with_streaming(
        self,
        instruction: str,
        project_path: str,
        session_id: Optional[str] = None,
        log_callback=None,
        images: Optional[List[Dict[str, Any]]] = None,
        model: Optional[str] = None,
        is_initial_prompt: bool = False,
    ) -> AsyncGenerator[Message, None]:
        """Execute instruction and yield Message objects in real-time."""
        # Map unified model name to CLI-specific name
        cli_model = self._get_cli_model_name(model) or "default-model"

        # Yield messages as they arrive from the CLI
        yield Message(
            id="unique-id",
            project_id=project_path,
            role="assistant",
            message_type="chat",
            content="Processing your request...",
            session_id=session_id
        )

    async def get_session_id(self, project_id: str) -> Optional[str]:
        return self._session_store.get(project_id)

    async def set_session_id(self, project_id: str, session_id: str) -> None:
        self._session_store[project_id] = session_id
```

--------------------------------

### Configure Claude Desktop MCP

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Configuration settings for Claude Desktop.

```json
{
  "mcpServers": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

```json
{
  "mcpServers": {
    "roundtable-ai": {
      "command": "uvx",
      "args": ["roundtable-ai@latest"],
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

--------------------------------

### Configure Windsurf with pip

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Add Roundtable AI server configuration to Windsurf's mcp_config.json using pip.

```json
{
  "mcpServers": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

--------------------------------

### Configure OpenAI Codex with UVX

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Set up Roundtable AI in OpenAI Codex's config.toml using UVX. Note the 'mcp_servers' key.

```toml
# IMPORTANT: the top-level key is 'mcp_servers' rather than 'mcpServers'.
[mcp_servers.roundtable-ai]
command = "uvx"
args = ["roundtable-ai@latest"]
env = { "CLI_MCP_SUBAGENTS" = "codex,claude,cursor,gemini" }
```

--------------------------------

### Configure Visual Studio 2022

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Set up Roundtable AI for Visual Studio 2022 by creating an mcp_config.json file in the project root. Uses 'stdio' transport.

```json
{
  "servers": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "transport": "stdio",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

--------------------------------

### Command Alternatives

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Alternative commands for running the Roundtable AI MCP server.

```APIDOC
## Command Alternatives

### Description
Equivalent commands for launching the Roundtable AI MCP server across different environments.

### Commands
- `roundtable-ai` (primary command)
- `roundtable-mcp-server` (descriptive alias)
- `python -m roundtable_mcp_server` (Python module)
- `npx @roundtable/mcp-server` (NPM package - coming soon)
```

--------------------------------

### Configure OpenAI Codex with pip

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Set up Roundtable AI in OpenAI Codex's config.toml using pip. Note the 'mcp_servers' key.

```toml
# IMPORTANT: the top-level key is 'mcp_servers' rather than 'mcpServers'.
[mcp_servers.roundtable-ai]
command = "roundtable-ai"
args = []
env = { "CLI_MCP_SUBAGENTS" = "codex,claude,cursor,gemini" }
```

--------------------------------

### Configure GitHub Copilot

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Add Roundtable AI server configuration for GitHub Copilot.

```json
{
  "github.copilot.mcp.servers": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

--------------------------------

### Configure Roundtable AI via CLI and Environment Variables

Source: https://context7.com/askbudi/roundtable/llms.txt

Configure the MCP server using command-line arguments for options like agents, debug mode, and help, or set environment variables for persistent configuration such as enabled agents, working directory, and debug logging.

```bash
roundtable-ai --help
```

```bash
# Environment variables for configuration
export CLI_MCP_SUBAGENTS="codex,claude,cursor,gemini"  # Specify enabled agents
export CLI_MCP_WORKING_DIR="/path/to/project"         # Default working directory
export CLI_MCP_DEBUG=true                             # Enable debug logging
export CLI_MCP_IGNORE_AVAILABILITY=true               # Enable all agents regardless of availability
export CLI_MCP_VERBOSE=true                           # Show detailed tool execution output
```

--------------------------------

### Configure JetBrains IDEs

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Configure Roundtable AI for JetBrains IDEs via the AI Assistant settings. Uses 'stdio' transport.

```json
{
  "name": "roundtable-ai",
  "command": "roundtable-ai",
  "transport": "stdio",
  "env": {
    "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  }
}
```

--------------------------------

### Advanced Configuration - Command Line Options

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Command-line options for the Roundtable AI CLI.

```APIDOC
## Advanced Configuration - Command Line Options

### Description
Available command-line options for the `roundtable-ai` executable.

### Options
- `roundtable-ai --help` - Show this message and exit.
- `--agents TEXT` - Comma-separated list of agents (gemini,claude,codex,cursor).
- `--check` - Check availability of all AI tools.
- `--debug` - Enable debug logging.
- `--version` - Show version information.
```

--------------------------------

### Configure Zed Editor

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Add Roundtable AI server configuration to Zed's settings.json.

```json
{
  "context_servers": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

--------------------------------

### LM Studio Configuration

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Configuration for LM Studio to integrate with Roundtable AI.

```APIDOC
## LM Studio Integration

### Description
Configure LM Studio to use Roundtable AI as its MCP server.

### Method
Manual Configuration in LM Studio

### Endpoint
N/A

### Request Body
```json
{
  "mcpServers": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```
```

--------------------------------

### Configure Roundtable AI for Perplexity Desktop

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Set up Roundtable AI as an MCP server within Perplexity settings by defining its command and environment variables for sub-agents.

```json
{
  "mcpConfig": {
    "servers": {
      "roundtable-ai": {
        "command": "roundtable-ai",
        "env": {
          "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
        }
      }
    }
  }
}
```

--------------------------------

### Add Roundtable AI server via Rovo CLI

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Use the Rovo CLI to add Roundtable AI as an MCP server.

```bash
# Add MCP server
rovo mcp add roundtable-ai roundtable-ai
```

--------------------------------

### Configure OpenAI Codex in `config.toml`

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Edit your `config.toml` file to set up the Roundtable AI integration for OpenAI Codex. This involves defining the MCP server command and environment variables.

```toml
[mcp_servers.roundtable-ai]
command = "roundtable-ai"
env = { CLI_MCP_SUBAGENTS = "codex,claude,cursor,gemini" }
```

--------------------------------

### Configure Roundtable AI for Crush

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Create or edit crush.json to set up Roundtable AI as an MCP server, specifying the command, transport, and environment variables for sub-agents.

```json
{
  "mcp": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "transport": "stdio",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

--------------------------------

### Advanced Configuration - Environment Variables

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Advanced environment variable settings for Roundtable AI.

```APIDOC
## Advanced Configuration - Environment Variables

### Description
Advanced environment variables for fine-tuning Roundtable AI behavior.

### Variables
- **CLI_MCP_SUBAGENTS** (string) - Specify which assistants to enable (e.g., `codex,gemini`).
- **CLI_MCP_IGNORE_AVAILABILITY** (boolean) - Enable all tools regardless of availability.
- **CLI_MCP_DEBUG** (boolean) - Enable debug logging.
```

--------------------------------

### Opencode Configuration

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Configuration for Opencode to integrate with Roundtable AI.

```APIDOC
## Opencode Integration

### Description
Configure Opencode to use Roundtable AI as its MCP server.

### Method
Add to `opencode_config.json`

### Endpoint
N/A

### Request Body
```json
{
  "mcpServers": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```
```

--------------------------------

### Troubleshooting

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Common issues and solutions for Roundtable AI integration.

```APIDOC
## Troubleshooting

### Description
Common problems and their solutions when integrating Roundtable AI.

### Issues & Solutions
1. **Server not found**: Ensure `roundtable-ai` is in your system's PATH.
2. **Permission denied**: Run `chmod +x $(which roundtable-ai)`.
3. **Config not loaded**: Verify file paths and JSON/TOML syntax.
4. **No AI tools detected**: Run `roundtable-ai --check` to confirm tool availability.
```

--------------------------------

### Environment Variables Reference

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Reference for environment variables used in Roundtable AI configuration.

```APIDOC
## Environment Variables Reference

### Description
Environment variables to control Roundtable AI behavior.

### Variables
- **CLI_MCP_SUBAGENTS** (string) - Required - Specify which AI assistants to enable (e.g., `codex,claude,cursor,gemini`).
- **CLI_MCP_DEBUG** (boolean) - Optional - Enable debug logging.
- **CLI_MCP_IGNORE_AVAILABILITY** (boolean) - Optional - Override availability checking.
```

--------------------------------

### Zencoder Configuration

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Configuration for Zencoder to integrate with Roundtable AI.

```APIDOC
## Zencoder Integration

### Description
Configure Zencoder to use Roundtable AI as its MCP server.

### Method
Configure via Zencoder settings panel

### Endpoint
N/A

### Request Body
```json
{
  "mcp_configuration": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```
```

--------------------------------

### Configure AI Model Mappings

Source: https://context7.com/askbudi/roundtable/llms.txt

Define the mapping between unified model names and provider-specific identifiers for Cursor, Codex, and Gemini.

```python
MODEL_MAPPING["cursor"] = {
    "gpt-5": "gpt-5",
    "sonnet-4": "sonnet-4",
    "opus-4.1": "opus-4.1",
    "sonnet-4-thinking": "sonnet-4-thinking",
}

# Codex models
MODEL_MAPPING["codex"] = {
    "gpt-5": "gpt-5",
    "gpt-4o": "gpt-4o",
    "gpt-4o-mini": "gpt-4o-mini",
    "claude-3.5-sonnet": "claude-3.5-sonnet",
}

# Gemini models
MODEL_MAPPING["gemini"] = {
    "gemini-2.5-pro": "gemini-2.5-pro",
    "gemini-2.5-flash": "gemini-2.5-flash",
}
```

--------------------------------

### Configure Roundtable AI in Cursor IDE

Source: https://context7.com/askbudi/roundtable/llms.txt

Configure Roundtable AI in Cursor IDE by creating or updating the `.cursor/mcp.json` file. This JSON configuration specifies the server type, command, arguments, and environment variables for Roundtable AI.

```json
{
  "mcpServers": {
    "roundtable-ai": {
      "type": "stdio",
      "command": "uvx",
      "args": ["roundtable-ai@latest"],
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

--------------------------------

### Kiro Configuration

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Configuration for Kiro to integrate with Roundtable AI.

```APIDOC
## Kiro Integration

### Description
Configure Kiro to use Roundtable AI as its MCP server.

### Method
Configure in `~/.kiro/config.json`

### Endpoint
N/A

### Request Body
```json
{
  "mcpServers": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```
```

--------------------------------

### Add Roundtable AI Server in BoltAI Settings

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Configure BoltAI settings under Plugins > MCP Servers by adding Roundtable AI with its name, command, and environment variables for sub-agents.

```text
CLI_MCP_SUBAGENTS=codex,claude,cursor,gemini
```

--------------------------------

### Check CLI Availability Programmatically

Source: https://context7.com/askbudi/roundtable/llms.txt

Use CLIAvailabilityChecker to verify CLI tool status and manage the local cache. Results are stored in ~/.roundtable/ by default.

```python
import asyncio
from roundtable_mcp_server.availability_checker import CLIAvailabilityChecker

async def check_cli_availability():
    # Initialize the checker (stores results in ~/.roundtable/)
    checker = CLIAvailabilityChecker()

    # Check all CLI tools in parallel and save results
    results = await checker.perform_availability_check(save_results=True)

    # Print formatted report
    checker.print_availability_report(results)
    # Output:
    # ============================================================
    # 🔍 CLI AVAILABILITY REPORT
    # ============================================================
    # 📅 Check time: 2024-09-24T10:05:21.123456
    # 📊 Total CLIs checked: 4
    # ✅ Available: 3
    #
    # ✅ CODEX
    #    Status: ✅ Codex CLI Available
    # ✅ CLAUDE
    #    Status: ✅ Claude Code CLI Available
    # ❌ CURSOR
    #    Status: ❌ Cursor CLI failed with exit code 1
    #    Error: cursor: command not found
    # ✅ GEMINI
    #    Status: ✅ Gemini CLI Available

    # Get list of available CLIs from cached results
    available_clis = checker.get_available_clis()
    print(f"Available: {available_clis}")  # ['codex', 'claude', 'gemini']

    return results

asyncio.run(check_cli_availability())
```

--------------------------------

### Manage Chat Interactions with Message Class

Source: https://context7.com/askbudi/roundtable/llms.txt

Instantiate, serialize, and update chat messages using the Message model. Requires importing Message, MessageType, and MessageStatus from claudable_helper.models.messages.

```python
from claudable_helper.models.messages import Message, MessageType, MessageStatus
from datetime import datetime

# Create a new message
message = Message(
    content="Analyzing the codebase for performance issues...",
    message_type=MessageType.ASSISTANT,  # USER, ASSISTANT, SYSTEM, TOOL, ERROR
    status=MessageStatus.STREAMING,      # PENDING, STREAMING, COMPLETED, FAILED
    session_id="session-123",
    project_id="/home/user/project",
    model="sonnet-4",
    metadata={"cli_type": "claude", "tool_name": "Read"}
)

# Convert to dictionary for serialization
message_dict = message.to_dict()

# Reconstruct from dictionary
restored_message = Message.from_dict(message_dict)

# Update message during streaming
message.update_content("Analysis complete. Found 3 issues.")
message.update_status(MessageStatus.COMPLETED)
```

--------------------------------

### OpenAI Codex Configuration

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Configuration for OpenAI Codex to integrate with Roundtable AI.

```APIDOC
## OpenAI Codex Integration

### Description
Configure OpenAI Codex to use Roundtable AI as its MCP server.

### Method
Edit `config.toml`

### Endpoint
N/A

### Request Body
```toml
[mcp_servers.roundtable-ai]
command = "roundtable-ai"
env = { CLI_MCP_SUBAGENTS = "codex,claude,cursor,gemini" }
```
```

--------------------------------

### Configure Zencoder for Roundtable AI

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Set up Roundtable AI integration within Zencoder's settings panel using this configuration. It specifies the MCP server command and environment variables for sub-agents.

```json
{
  "mcp_configuration": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

--------------------------------

### Identify Node.js Performance Hotspots

Source: https://context7.com/askbudi/roundtable/llms.txt

Code snippet highlighting CPU-intensive operations and N+1 query patterns.

```javascript
// 40% CPU time
orders.map(o => ({ ...o, json: JSON.stringify(o) }));

// N+1 query problem
for (const id of orderIds) {
  await fetchInventory(id);
}
```

--------------------------------

### Add Roundtable AI to Qodo Gen Configuration

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Include Roundtable AI in the Qodo Gen configuration file under 'mcp_servers', specifying the command and environment variables for sub-agents.

```json
{
  "mcp_servers": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

--------------------------------

### Add Roundtable AI Server in Warp Settings

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Configure Warp settings under Features > AI > MCP Servers to add Roundtable AI, including its name, command, and environment variables for sub-agents.

```json
{
  "name": "roundtable-ai",
  "command": "roundtable-ai",
  "env": {
    "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  }
}
```

--------------------------------

### Roundtable AI Command Line Options

Source: https://github.com/askbudi/roundtable/blob/main/README.md

These command-line options allow you to control Roundtable AI's behavior, including agent selection, debug logging, and version information.

```bash
roundtable-ai --help

Options:
  --agents TEXT     Comma-separated list of agents (gemini,claude,codex,cursor)
  --check          Check availability of all AI tools
  --debug          Enable debug logging
  --version        Show version information
  --help           Show this message and exit
```

--------------------------------

### Configure Roundtable AI in OpenAI Codex CLI

Source: https://context7.com/askbudi/roundtable/llms.txt

Configure Roundtable AI in the OpenAI Codex CLI by editing `~/.codex/config.toml`. This TOML configuration specifies the command, arguments, and environment variables for the Roundtable AI MCP server.

```toml
# IMPORTANT: the top-level key is 'mcp_servers' rather than 'mcpServers'
[mcp_servers.roundtable-ai]
command = "uvx"
args = ["roundtable-ai@latest"]
env = { "CLI_MCP_SUBAGENTS" = "codex,claude,cursor,gemini" }
```

--------------------------------

### Available MCP Tools

Source: https://github.com/askbudi/roundtable/blob/main/README.md

List of AI tools available through Roundtable AI's MCP.

```APIDOC
## Available MCP Tools

### Description
This section lists the AI assistants and their corresponding task execution commands available through the Roundtable AI MCP.

### Availability Checks
- `check_codex_availability` - Verify Codex CLI status.
- `check_claude_availability` - Verify Claude Code CLI status.
- `check_cursor_availability` - Verify Cursor CLI status.
- `check_gemini_availability` - Verify Gemini CLI status.

### Unified Task Execution
- `execute_codex_task` - Run coding tasks through Codex.
- `execute_claude_task` - Run coding tasks through Claude Code.
- `execute_cursor_task` - Run coding tasks through Cursor.
- `execute_gemini_task` - Run coding tasks through Gemini.
```

--------------------------------

### Map Unified Model Names

Source: https://context7.com/askbudi/roundtable/llms.txt

Update the MODEL_MAPPING dictionary to define provider-specific model names for unified usage.

```python
from claudable_helper.cli.base import MODEL_MAPPING

# Unified model names work across all providers
# Claude Code models
MODEL_MAPPING["claude"] = {
    "opus-4.1": "claude-opus-4-1-20250805",
    "sonnet-4": "claude-sonnet-4-20250514",
    "opus-4": "claude-opus-4-20250514",
    "haiku-3.5": "claude-3-5-haiku-20241022",
}
```

--------------------------------

### Invoke Gemini SubAgent for Code Analysis

Source: https://context7.com/askbudi/roundtable/llms.txt

Executes a coding task using the Gemini subagent tool. Requires an absolute project path and a valid model selection.

```python
result = await client.call_tool("gemini_subagent", {
    "instruction": "Analyze the entire frontend codebase for performance issues, especially expensive re-renders and inefficient data fetching patterns",
    "project_path": "/home/user/myproject",  # ABSOLUTE path required
    "model": "gemini-2.5-pro",               # Options: gemini-2.5-pro, gemini-2.5-flash
    "session_id": "perf-analysis",
    "is_initial_prompt": True
})
```

--------------------------------

### Configure Claude Code MCP

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Commands to add the Roundtable AI MCP server to Claude Code.

```bash
claude mcp add roundtable-ai -- roundtable-ai --agents gemini,claude,codex,cursor
```

```bash
claude mcp add roundtable-ai -- uvx roundtable-ai@latest --agents gemini,claude,codex,cursor
```

--------------------------------

### Advanced Environment Variables Configuration

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Configure advanced Roundtable AI settings using environment variables. `CLI_MCP_SUBAGENTS` selects specific agents, `CLI_MCP_IGNORE_AVAILABILITY` forces all tools to be enabled, and `CLI_MCP_DEBUG` enables detailed logging.

```bash
# Specify which assistants to enable
export CLI_MCP_SUBAGENTS="codex,gemini"


# Enable all tools regardless of availability
export CLI_MCP_IGNORE_AVAILABILITY=true

# Enable debug logging
export CLI_MCP_DEBUG=true
```

--------------------------------

### Analyze Slow SQL Query

Source: https://context7.com/askbudi/roundtable/llms.txt

SQL query used for performance analysis of order and payment data.

```sql
-- Duration: 2455.112 ms
SELECT c.name, COUNT(o.id) AS total_orders, SUM(p.amount) AS revenue
FROM companies c, orders o, payments p
WHERE c.id = o.company_id AND o.id = p.order_id AND c.region = 'North America'
GROUP BY c.name ORDER BY revenue DESC;
```

--------------------------------

### Trae Configuration

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Configuration for Trae to integrate with Roundtable AI.

```APIDOC
## Trae Integration

### Description
Configure Trae to use Roundtable AI as its MCP server.

### Method
Add to Trae workspace configuration

### Endpoint
N/A

### Request Body
```json
{
  "mcp": {
    "servers": {
      "roundtable-ai": {
        "command": "roundtable-ai",
        "env": {
          "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
        }
      }
    }
  }
}
```
```

--------------------------------

### Execute Coding Task with Cursor Subagent

Source: https://context7.com/askbudi/roundtable/llms.txt

Invokes the Cursor Agent CLI to perform codebase analysis and code changes.

```python
# MCP tool invocation - execute a coding task with Cursor Agent
result = await client.call_tool("cursor_subagent", {
    "instruction": "Search the codebase for all files that might have similar database connection issues",
    "project_path": "/home/user/myproject",  # ABSOLUTE path required
    "model": "sonnet-4",                      # Options: gpt-5, sonnet-4, opus-4.1, sonnet-4-thinking
    "session_id": "debug-session",
    "is_initial_prompt": True
})

# Example response:
# "**Cursor Agent Response:**
# Found 4 files with potential database connection issues:
#
# 1. `services/user_service.py` - Line 42: No connection pooling
# 2. `services/order_service.py` - Line 28: Missing retry logic
# 3. `api/handlers/checkout.py` - Line 95: Connection not properly closed
# 4. `workers/sync_job.py` - Line 15: Hardcoded connection timeout"
```

--------------------------------

### Add Roundtable AI to Claude Code

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Command to register the Roundtable AI MCP server within the Claude Code environment.

```bash
claude mcp add roundtable-ai -- roundtable-ai --agents gemini,claude,codex,cursor
```

--------------------------------

### Configure Trae Workspace for Roundtable AI

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Add this configuration to your Trae workspace settings to integrate Roundtable AI. It specifies the MCP server command and environment variables for sub-agents.

```json
{
  "mcp": {
    "servers": {
      "roundtable-ai": {
        "command": "roundtable-ai",
        "env": {
          "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
        }
      }
    }
  }
}
```

--------------------------------

### Subagent Execution Tools

Source: https://context7.com/askbudi/roundtable/llms.txt

Endpoints to execute coding tasks using specific AI agents (Codex, Claude, Cursor, Gemini).

```APIDOC
## codex_subagent

### Description
Executes a coding task using the Codex CLI agent.

### Parameters
#### Request Body
- **instruction** (string) - Required - The coding task instruction.
- **project_path** (string) - Required - Absolute path to the project.
- **model** (string) - Optional - Model selection (gpt-5, gpt-4o, gpt-4o-mini, claude-3.5-sonnet).
- **session_id** (string) - Optional - ID for conversation continuity.
- **is_initial_prompt** (boolean) - Optional - Flag for first prompt in session.

## claude_subagent

### Description
Executes a coding task using the Claude Code CLI agent.

### Parameters
#### Request Body
- **instruction** (string) - Required - The coding task instruction.
- **project_path** (string) - Required - Absolute path to the project.
- **model** (string) - Optional - Model selection (sonnet-4, opus-4.1).
- **session_id** (string) - Optional - ID for conversation continuity.
- **is_initial_prompt** (boolean) - Optional - Flag for first prompt in session.

## cursor_subagent

### Description
Executes a coding task using the Cursor Agent CLI.

### Parameters
#### Request Body
- **instruction** (string) - Required - The coding task instruction.
- **project_path** (string) - Required - Absolute path to the project.
- **model** (string) - Optional - Model selection (sonnet-4, gpt-5, opus-4.1, sonnet-4-thinking).
- **session_id** (string) - Optional - ID for conversation continuity.
- **is_initial_prompt** (boolean) - Optional - Flag for first prompt in session.
```

--------------------------------

### Execute Coding Task with Claude Subagent

Source: https://context7.com/askbudi/roundtable/llms.txt

Invokes the Claude Code CLI agent for reasoning-heavy tasks and complex debugging.

```python
# MCP tool invocation - execute a coding task with Claude Code
result = await client.call_tool("claude_subagent", {
    "instruction": "Review the authentication middleware and identify potential security vulnerabilities",
    "project_path": "/home/user/myproject",  # ABSOLUTE path required
    "model": "sonnet-4",                      # Options: sonnet-4 (recommended), opus-4.1 (10x cost)
    "session_id": "auth-review-session",      # For conversation continuity
    "is_initial_prompt": False                # False for follow-up prompts
})

# Example response:
# "**Claude Code Response:**
# After reviewing the authentication middleware, I identified the following security concerns:
#
# 1. **JWT Token Validation**: The token expiry check uses client time - should use server time
# 2. **Session Fixation**: Session ID not regenerated after login
# 3. **Rate Limiting**: No rate limiting on login endpoint
#
# I've implemented fixes for issues #1 and #2. Issue #3 requires Redis setup."
```

--------------------------------

### Roo Code Configuration

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Configuration for Roo Code to integrate with Roundtable AI.

```APIDOC
## Roo Code Integration

### Description
Configure Roo Code to use Roundtable AI as its MCP server.

### Method
Configure in Roo Code project settings

### Endpoint
N/A

### Request Body
```json
{
  "ai_assistants": {
    "mcp_servers": {
      "roundtable-ai": {
        "command": "roundtable-ai",
        "env": {
          "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
        }
      }
    }
  }
}
```
```

--------------------------------

### Configure Roo Code for Roundtable AI

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Set up Roundtable AI integration in Roo Code project settings with this configuration. It defines the MCP server command and environment variables for sub-agents.

```json
{
  "ai_assistants": {
    "mcp_servers": {
      "roundtable-ai": {
        "command": "roundtable-ai",
        "env": {
          "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
        }
      }
    }
  }
}
```

--------------------------------

### Configure Augment Code for Roundtable AI

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Add this configuration to your Augment Code workspace settings to integrate Roundtable AI. It includes the server command, transport type, and environment variables for sub-agents.

```json
{
  "mcpServers": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "transport": "stdio",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```

--------------------------------

### Augment Code Configuration

Source: https://github.com/askbudi/roundtable/blob/main/README.md

Configuration for Augment Code to integrate with Roundtable AI.

```APIDOC
## Augment Code Integration

### Description
Configure Augment Code to use Roundtable AI as its MCP server.

### Method
Add to Augment Code workspace settings

### Endpoint
N/A

### Request Body
```json
{
  "mcpServers": {
    "roundtable-ai": {
      "command": "roundtable-ai",
      "transport": "stdio",
      "env": {
        "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
      }
    }
  }
}
```
```

--------------------------------

### Environment Variables Reference

Source: https://github.com/askbudi/roundtable/blob/main/README.md

These environment variables control the behavior of the Roundtable AI CLI. `CLI_MCP_SUBAGENTS` specifies which AI assistants to enable, `CLI_MCP_DEBUG` enables debug logging, and `CLI_MCP_IGNORE_AVAILABILITY` overrides availability checks.

```bash
# Specify which AI assistants to enable
CLI_MCP_SUBAGENTS="codex,claude,cursor,gemini"


# Enable debug logging
CLI_MCP_DEBUG=true

# Override availability checking
CLI_MCP_IGNORE_AVAILABILITY=true
```

--------------------------------

### Debug Production Issue JSON Log

Source: https://context7.com/askbudi/roundtable/llms.txt

Represents a structured error log for debugging API failures.

```json
{
  "timestamp": "2024-09-24T10:05:21.123Z",
  "level": "error",
  "message": "API request failed for /api/v1/user/profile",
  "error": { "status": 500, "statusText": "Internal Server Error" }
}
```

--------------------------------

### Execute Coding Task with Codex Subagent

Source: https://context7.com/askbudi/roundtable/llms.txt

Invokes the Codex CLI agent to perform file operations, shell commands, or code refactoring.

```python
# MCP tool invocation - execute a coding task with Codex
result = await client.call_tool("codex_subagent", {
    "instruction": "Analyze the database queries in user_service.py and optimize any N+1 query patterns",
    "project_path": "/home/user/myproject",  # ABSOLUTE path required
    "model": "gpt-5",                         # Options: gpt-5, gpt-4o, gpt-4o-mini, claude-3.5-sonnet
    "session_id": "optional-session-id",      # For conversation continuity
    "is_initial_prompt": True                 # True for first prompt in session
})

# Example response:
# "**Codex Response:**
# I've analyzed the database queries in user_service.py and found 2 N+1 query patterns:
#
# 1. Line 42: Fetching user profiles in a loop - converted to batch query
# 2. Line 78: Loading related orders individually - added JOIN clause
#
# 🔧 **Tools Used (3):**
# • **Read** `user_service.py`
# • **Edit** `user_service.py`
# • **Bash** `pytest tests/test_user_service.py`"
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.