Skip to content
Back to search

roundtable

Zero-configuration MCP server that unifies multiple AI coding assistants (Codex, Claude Code, Cursor, Gemini) through intelligent auto-discovery and standardized interface

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/yylo-dev--roundtable/badge.svg)](/listings/yylo-dev--roundtable)

HTML

<a href="/listings/yylo-dev--roundtable"><img src="/api/listings/yylo-dev--roundtable/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

# 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

**One-liner for Claude Code:**

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

**Try this multi-agent prompt in your IDE:**

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.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 1,028 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Roundtable AI MCP Server
  2. [![PyPI version](https://badge.fury.io/py/roundtable-ai.svg)](https://badge.fury.io/py/roundtable-ai)
  3. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  4. [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
  5. [![Install Roundtable AI MCP Server in Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](cursor://anysphere.cursor-deeplink/mcp/install?name=roundtable-ai&config=eyJ0eXBlIjoic3RkaW8iLCJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyJyb3VuZHRhYmxlLWFpQGxhdGVzdCJdLCJlbnYiOnsiQ0xJX01DUF9TVUJBR0VOVFMiOiJjb2RleCxjbGF1ZGUsY3Vyc29yLGdlbWluaSJ9fQo=)
  6. Stop copy-pasting between AI models. Roundtable AI is a local MCP server that lets your primary AI assistant delegate tasks to specialized models like Gemini, Claude, Codex, and Cursor. Solve complex engineering problems in parallel, directly from your IDE.
  7. **Key Features:**
  8. - **Context Continuity**: Shared project context across all sub-agents
  9. - **Parallel Execution**: All agents work simultaneously
  10. - **Model Specialization**: Right AI for each task (Gemini's 1M context, Claude's reasoning, Codex's implementation)
  11. - **Zero Markup**: Uses your existing CLI tools and API subscriptions
  12. - **26+ IDE Support**: Works with Claude Code, Cursor, VS Code, JetBrains, and more
  13. ## Table of Contents
  14. - [Quick Start](#quick-start)
  15. - [What is Roundtable AI](#what-is-roundtable-ai)
  16. - [Technical Architecture](#technical-architecture)
  17. - [Why Multi-Agent vs Single AI](#why-multi-agent-vs-single-ai)
  18. - [Real-World Examples](#real-world-examples)
  19. - [Installation](#installation)
  20. - [IDE Integration](#ide-integration)
  21. - [Advanced Configuration](#advanced-configuration)
  22. - [Contributing](#contributing)
  23. - [License](#license)
  24. ## Quick Start
  25. ```bash
  26. # Install Roundtable AI
  27. pip install roundtable-ai
  28. # Check available AI tools
  29. roundtable-ai --check
  30. # Start with all available tools
  31. roundtable-ai
  32. # Use specific assistants only
  33. roundtable-ai --agents codex,claude
  34. ```
  35. **One-liner for Claude Code:**
  36. ```bash
  37. claude mcp add roundtable-ai -- roundtable-ai --agents gemini,claude,codex,cursor
  38. ```
  39. **Try this multi-agent prompt in your IDE:**
  40. ```markdown
  41. The user dashboard is randomly slow for enterprise customers.
  42. Use Gemini SubAgent to analyze frontend performance issues in the React components, especially expensive re-renders and inefficient data fetching.
  43. Use Codex SubAgent to examine the backend API endpoint for N+1 queries and database bottlenecks.
  44. Use Claude SubAgent to review the infrastructure logs and identify memory/CPU pressure during peak hours.
  45. ```
  46. ## What is Roundtable AI
  47. Roundtable AI is a local Model Context Protocol (MCP) server that coordinates specialized AI sub-agents to solve complex engineering problems. Instead of manually switching between different AI tools, you delegate tasks from a single prompt in your IDE, and Roundtable manages the coordination, context sharing, and response synthesis.
  48. ### Key Benefits
  49. - **Context Continuity**: The primary agent provides shared, rich context to all sub-agents
  50. - **Parallel Execution**: All agents work simultaneously, drastically reducing wait time
  51. - **Model Specialization**: Use the right AI for each task - Gemini's 1M context for analysis, Claude's reasoning for logic, Codex for implementation
  52. - **No Extra Cost**: Uses your existing CLI tools and API subscriptions with zero markup
  53. - **Single Interface**: One prompt, multiple specialized responses, automatically synthesized
  54. ## Technical Architecture
  55. ```text
  56. +----------------------------------+
  57. | Your IDE (VS Code, Cursor, etc.) |
  58. | (Primary AI Assistant) |
  59. +----------------+-----------------+
  60. |
  61. (1. User prompt with subagent delegation)
  62. |
  63. +----------------v-----------------+
  64. | Roundtable MCP Server |
  65. | (localhost) |
  66. +----------------+-----------------+
  67. |
  68. (2. Dispatches tasks to sub-agent CLIs in parallel)
  69. |
  70. +--------------------v--------------------+
  71. | |
  72. | +-----------+ +-----------+ +-----------+ |
  73. | | Gemini | | Claude | | Codex | |
  74. | | (Analysis)| | (Logic) | | (Implement)| |
  75. | +-----------+ +-----------+ +-----------+ |
  76. | |
  77. +--------------------^--------------------+
  78. |
  79. (3. Sub-agents execute using local tools,
  80. e.g., read_file, run_shell_command)
  81. |
  82. +----------------+-----------------+
  83. | Roundtable MCP Server |
  84. | (Aggregates & Synthesizes) |
  85. +----------------+-----------------+
  86. |
  87. (4. Returns a single, synthesized response)
  88. |
  89. +----------------v-----------------+
  90. | Your IDE (Primary AI Assistant) |
  91. +----------------------------------+
  92. ```
  93. ### How It Works
  94. 1. **Context Continuity**: The initial prompt and relevant file/project context are packaged by the primary agent. The MCP server passes this "context bundle" to each sub-agent, ensuring all participants have the same ground truth without manual copy-pasting.
  95. 2. **Model Specialization**: Use the right model for the job. Leverage Gemini's 1M context for codebase analysis, Claude's reasoning for logic and implementation, and Codex's proficiency for code generation and reviews, all in one workflow.
  96. 3. **No Extra Cost**: Roundtable invokes the CLI tools you already have installed and configured. It uses your existing API keys and subscriptions. We add no markup. The cost is exactly what you would pay running the tools manually.
  97. ## Why Multi-Agent vs Single AI
  98. Because manual context-switching is slow, error-prone, and prevents deep analysis.
  99. ### The Multi-Tab Workflow ❌
  100. - Manually copy-paste code and context between different AI chats
  101. - Each agent starts fresh, unaware of other conversations or files
  102. - You wait for one agent to finish before starting the next
  103. - You are responsible for merging disparate, often conflicting, advice
  104. - High risk of pasting outdated code or incorrect context
  105. ### The Roundtable Workflow ✅
  106. - Delegate tasks from a single prompt in your IDE
  107. - The primary agent provides shared, rich context to all sub-agents
  108. - All agents work in parallel, drastically reducing wait time
  109. - The final output automatically synthesizes the best insights from each model
  110. - The entire workflow is a single, deterministic, and repeatable command
  111. ## Real-World Examples
  112. Each example includes real code, logs, and explicit delegation to specialized sub-agents. Copy the whole block and paste it into your IDE assistant.
  113. 1) Multi-Stack Debugging — Virtual War Room for Production Issues
  114. ```markdown
  115. I'm debugging a critical production issue. The user sees a "Failed to load data" message.
  116. Here is the browser console output:
  117. ```json
  118. {
  119. "timestamp": "2024-09-24T10:05:21.123Z",
  120. "level": "error",
  121. "message": "API request failed for /api/v1/user/profile",
  122. "error": {
  123. "status": 500,
  124. "statusText": "Internal Server Error"
  125. }
  126. }
  127. ```
  128. Here is the backend server log:
  129. ```
  130. ERROR: Exception in ASGI application
  131. File "/app/services/user_service.py", line 42, in get_user_profile
  132. user_data = await db.fetch_one(query)
  133. ValueError: Database connection is not available
  134. ```
  135. Use Gemini SubAgent to analyze the logs from both stacks, correlate the events, and form a hypothesis about the root cause.
  136. Use Codex SubAgent to analyze the Python backend traceback and suggest a specific code fix for the database connection error.
  137. Use Claude SubAgent to review the frontend error handling and recommend more resilient patterns.
  138. Use Cursor SubAgent to search the codebase for other files that might have similar database connection issues.
  139. At the end, aggregate all findings into a single incident report with root cause analysis and prioritized fixes.
  140. ```
  141. 2) Performance Optimization — API Latency & Database Query Tuning
  142. ```markdown
  143. Our checkout API p95 latency increased from 220ms to 780ms. Need optimization strategy.
  144. PostgreSQL slow query log:
  145. ```sql
  146. -- Duration: 2455.112 ms
  147. SELECT c.name, COUNT(o.id) AS total_orders, SUM(p.amount) AS revenue
  148. FROM companies c, orders o, payments p
  149. WHERE c.id = o.company_id
  150. AND o.id = p.order_id
  151. AND c.region = 'North America'
  152. GROUP BY c.name
  153. ORDER BY revenue DESC;
  154. ```
  155. EXPLAIN ANALYZE shows:
  156. ```
  157. Seq Scan on orders (cost=0.00..52000.00 rows=100000)
  158. Filter: (status = 'completed')
  159. Rows Removed by Filter: 134,201
  160. ```
  161. Node.js hotspot from profiling:
  162. ```javascript
  163. // 40% CPU time
  164. orders.map(o => ({ ...o, json: JSON.stringify(o) }));
  165. // N+1 query problem
  166. for (const id of orderIds) {
  167. await fetchInventory(id);
  168. }
  169. ```
  170. Use Claude SubAgent to analyze the EXPLAIN plan and identify why the query is slow.
  171. Use Codex SubAgent to rewrite the SQL with proper JOINs and suggest indexes.
  172. Use Gemini SubAgent to fix the N+1 query problem with batch fetching.
  173. Use Cursor SubAgent to find all instances of JSON.stringify in hot code paths.
  174. Aggregate findings into a performance optimization plan with measurable improvements.
  175. ```
  176. ## Installation
  177. ### Using pip (Standard)
  178. ```bash
  179. pip install roundtable-ai
  180. ```
  181. ### Using UV/UVX (Recommended for faster installs)
  182. ```bash
  183. uvx roundtable-ai@latest
  184. ```
  185. ## IDE Integration
  186. Roundtable AI supports 26+ MCP-compatible clients. Here are the top 7:
  187. ### 1. Claude Code
  188. **Using pip:**
  189. ```bash
  190. claude mcp add roundtable-ai -- roundtable-ai --agents gemini,claude,codex,cursor
  191. ```
  192. **Using UVX:**
  193. ```bash
  194. claude mcp add roundtable-ai -- uvx roundtable-ai@latest --agents gemini,claude,codex,cursor
  195. ```
  196. ### 2. Cursor
  197. **One-Click Install:**
  198. [![Install Roundtable AI MCP Server in Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](cursor://anysphere.cursor-deeplink/mcp/install?name=roundtable-ai&config=eyJ0eXBlIjoic3RkaW8iLCJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyJyb3VuZHRhYmxlLWFpQGxhdGVzdCJdLCJlbnYiOnsiQ0xJX01DUF9TVUJBR0VOVFMiOiJjb2RleCxjbGF1ZGUsY3Vyc29yLGdlbWluaSJ9fQo=)
  199. Or use this direct link:
  200. ```
  201. cursor://anysphere.cursor-deeplink/mcp/install?name=roundtable-ai&config=eyJ0eXBlIjoic3RkaW8iLCJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyJyb3VuZHRhYmxlLWFpQGxhdGVzdCJdLCJlbnYiOnsiQ0xJX01DUF9TVUJBR0VOVFMiOiJjb2RleCxjbGF1ZGUsY3Vyc29yLGdlbWluaSJ9fQo=
  202. ```
  203. **Manual Installation:**
  204. **File:** `.cursor/mcp.json`
  205. **Using pip:**
  206. ```json
  207. {
  208. "mcpServers": {
  209. "roundtable-ai": {
  210. "command": "roundtable-ai",
  211. "env": {
  212. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  213. }
  214. }
  215. }
  216. }
  217. ```
  218. **Using UVX:**
  219. ```json
  220. {
  221. "mcpServers": {
  222. "roundtable-ai": {
  223. "type": "stdio",
  224. "command": "uvx",
  225. "args": [
  226. "roundtable-ai@latest"
  227. ],
  228. "env": {
  229. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  230. }
  231. }
  232. }
  233. }
  234. ```
  235. ### 3. Claude Desktop
  236. **File:** `~/.config/claude_desktop_config.json`
  237. **Using pip:**
  238. ```json
  239. {
  240. "mcpServers": {
  241. "roundtable-ai": {
  242. "command": "roundtable-ai",
  243. "env": {
  244. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  245. }
  246. }
  247. }
  248. }
  249. ```
  250. **Using UVX:**
  251. ```json
  252. {
  253. "mcpServers": {
  254. "roundtable-ai": {
  255. "command": "uvx",
  256. "args": ["roundtable-ai@latest"],
  257. "env": {
  258. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  259. }
  260. }
  261. }
  262. }
  263. ```
  264. ### 4. VS Code
  265. **Add to `settings.json`:**
  266. **Using pip:**
  267. ```json
  268. {
  269. "mcp.servers": {
  270. "roundtable-ai": {
  271. "command": "roundtable-ai",
  272. "env": {
  273. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  274. }
  275. }
  276. }
  277. }
  278. ```
  279. **Using UVX:**
  280. ```json
  281. {
  282. "mcp.servers": {
  283. "roundtable-ai": {
  284. "command": "uvx",
  285. "args": ["roundtable-ai@latest"],
  286. "env": {
  287. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  288. }
  289. }
  290. }
  291. }
  292. ```
  293. ### 5. OpenAI Codex
  294. **File:** `~/.codex/config.toml`
  295. **Using pip:**
  296. ```toml
  297. # IMPORTANT: the top-level key is 'mcp_servers' rather than 'mcpServers'.
  298. [mcp_servers.roundtable-ai]
  299. command = "roundtable-ai"
  300. args = []
  301. env = { "CLI_MCP_SUBAGENTS" = "codex,claude,cursor,gemini" }
  302. ```
  303. **Using UVX:**
  304. ```toml
  305. # IMPORTANT: the top-level key is 'mcp_servers' rather than 'mcpServers'.
  306. [mcp_servers.roundtable-ai]
  307. command = "uvx"
  308. args = ["roundtable-ai@latest"]
  309. env = { "CLI_MCP_SUBAGENTS" = "codex,claude,cursor,gemini" }
  310. ```
  311. ### 6. Windsurf
  312. **File:** `~/.codeium/windsurf/mcp_config.json`
  313. **Using pip:**
  314. ```json
  315. {
  316. "mcpServers": {
  317. "roundtable-ai": {
  318. "command": "roundtable-ai",
  319. "env": {
  320. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  321. }
  322. }
  323. }
  324. }
  325. ```
  326. **Using UVX:**
  327. ```json
  328. {
  329. "mcpServers": {
  330. "roundtable-ai": {
  331. "command": "uvx",
  332. "args": ["roundtable-ai@latest"],
  333. "env": {
  334. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  335. }
  336. }
  337. }
  338. }
  339. ```
  340. ### 7. Gemini CLI
  341. **File:** `~/.gemini/settings.json`
  342. **Using pip:**
  343. ```json
  344. {
  345. "mcpServers": {
  346. "roundtable-ai": {
  347. "command": "roundtable-ai",
  348. "env": {
  349. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  350. }
  351. }
  352. }
  353. }
  354. ```
  355. **Using UVX:**
  356. ```json
  357. {
  358. "mcpServers": {
  359. "roundtable-ai": {
  360. "command": "uvx",
  361. "args": ["roundtable-ai@latest"],
  362. "env": {
  363. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  364. }
  365. }
  366. }
  367. }
  368. ```
  369. ### Additional IDE Support
  370. Roundtable AI integrates with **26+ different IDEs and AI coding tools**:
  371. #### JetBrains IDEs (IntelliJ, PyCharm, WebStorm, etc.)
  372. **Settings Path**: `Settings > Tools > AI Assistant > Model Context Protocol (MCP)`
  373. ```json
  374. {
  375. "name": "roundtable-ai",
  376. "command": "roundtable-ai",
  377. "transport": "stdio",
  378. "env": {
  379. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  380. }
  381. }
  382. ```
  383. #### GitHub Copilot
  384. ```json
  385. {
  386. "github.copilot.mcp.servers": {
  387. "roundtable-ai": {
  388. "command": "roundtable-ai",
  389. "env": {
  390. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  391. }
  392. }
  393. }
  394. }
  395. ```
  396. ---
  397. ### 🖥️ Desktop IDEs
  398. <details>
  399. <summary><b>JetBrains AI Assistant</b> - IntelliJ, PyCharm, WebStorm, etc.</summary>
  400. 1. **Settings Path**: `Settings > Tools > AI Assistant > Model Context Protocol (MCP)`
  401. 2. **Add New Server**: Click "+" to add new MCP server
  402. 3. **Configuration**:
  403. ```json
  404. {
  405. "name": "roundtable-ai",
  406. "command": "roundtable-ai",
  407. "transport": "stdio",
  408. "env": {
  409. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini",
  410. }
  411. }
  412. ```
  413. 4. **Apply & Restart**: Apply settings and restart the IDE
  414. </details>
  415. <details>
  416. <summary><b>Visual Studio 2022</b> - Microsoft's Flagship IDE</summary>
  417. Create `mcp_config.json` in your project root:
  418. ```json
  419. {
  420. "servers": {
  421. "roundtable-ai": {
  422. "command": "roundtable-ai",
  423. "transport": "stdio",
  424. "env": {
  425. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  426. }
  427. }
  428. }
  429. }
  430. ```
  431. **Alternative**: Use Extensions > Manage Extensions > Search for "Roundtable AI"
  432. </details>
  433. <details>
  434. <summary><b>Zed</b> - High-Performance Code Editor</summary>
  435. Add to `settings.json` (Cmd/Ctrl + ,):
  436. ```json
  437. {
  438. "context_servers": {
  439. "roundtable-ai": {
  440. "command": "roundtable-ai",
  441. "env": {
  442. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  443. }
  444. }
  445. }
  446. }
  447. ```
  448. **Extension Alternative**: Search for "Roundtable AI" in Zed Extensions
  449. </details>
  450. ---
  451. ### 💻 CLI Tools
  452. <details>
  453. <summary><b>Gemini CLI</b> - Google's Gemini Command-Line Interface</summary>
  454. Edit `~/.gemini/settings.json`:
  455. ```json
  456. {
  457. "mcpServers": {
  458. "roundtable-ai": {
  459. "command": "roundtable-ai",
  460. "env": {
  461. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  462. }
  463. }
  464. }
  465. }
  466. ```
  467. </details>
  468. <details>
  469. <summary><b>Rovo Dev CLI</b> - Atlassian's Development CLI</summary>
  470. Configure via `rovo config` command:
  471. ```bash
  472. # Add MCP server
  473. rovo mcp add roundtable-ai roundtable-ai
  474. # Verify
  475. rovo mcp list
  476. ```
  477. **Manual configuration** in `~/.rovo/config.json`:
  478. ```json
  479. {
  480. "mcpServers": {
  481. "roundtable-ai": {
  482. "command": "roundtable-ai",
  483. "env": {
  484. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  485. }
  486. }
  487. }
  488. }
  489. ```
  490. </details>
  491. <details>
  492. <summary><b>Amazon Q Developer CLI</b> - Amazon's AI Development Assistant</summary>
  493. Edit configuration in `~/.aws/q-developer/config.json`:
  494. ```json
  495. {
  496. "mcpServers": {
  497. "roundtable-ai": {
  498. "command": "roundtable-ai",
  499. "env": {
  500. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  501. }
  502. }
  503. }
  504. }
  505. ```
  506. </details>
  507. <details>
  508. <summary><b>Crush</b> - Terminal-Based AI Assistant</summary>
  509. Create or edit `crush.json` in your project:
  510. ```json
  511. {
  512. "mcp": {
  513. "roundtable-ai": {
  514. "command": "roundtable-ai",
  515. "transport": "stdio",
  516. "env": {
  517. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  518. }
  519. }
  520. }
  521. }
  522. ```
  523. </details>
  524. <details>
  525. <summary><b>Warp</b> - AI-Powered Terminal</summary>
  526. Configure via Warp settings:
  527. 1. **Open Settings**: Cmd/Ctrl + ,
  528. 2. **Navigate to**: Features > AI > MCP Servers
  529. 3. **Add Server**:
  530. ```json
  531. {
  532. "name": "roundtable-ai",
  533. "command": "roundtable-ai",
  534. "env": {
  535. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  536. }
  537. }
  538. ```
  539. </details>
  540. ---
  541. ### 🤖 AI Assistants
  542. <details>
  543. <summary><b>Claude Desktop</b> - Anthropic's Desktop Application</summary>
  544. Edit `~/.config/claude_desktop_config.json`:
  545. ```json
  546. {
  547. "mcpServers": {
  548. "roundtable-ai": {
  549. "command": "roundtable-ai",
  550. "env": {
  551. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  552. }
  553. }
  554. }
  555. }
  556. ```
  557. </details>
  558. <details>
  559. <summary><b>Cline</b> - AI Assistant Extension</summary>
  560. **One-Click Install**:
  561. 1. Open Cline MCP Server Marketplace
  562. 2. Search for "Roundtable AI"
  563. 3. Click "Install"
  564. **Manual Configuration** in `cline_mcp_settings.json`:
  565. ```json
  566. {
  567. "mcpServers": {
  568. "roundtable-ai": {
  569. "command": "roundtable-ai",
  570. "env": {
  571. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  572. }
  573. }
  574. }
  575. }
  576. ```
  577. </details>
  578. <details>
  579. <summary><b>BoltAI</b> - AI Assistant Application</summary>
  580. 1. **Open BoltAI Settings**
  581. 2. **Navigate to**: Plugins > MCP Servers
  582. 3. **Add New Server**:
  583. - Name: `roundtable-ai`
  584. - Command: `roundtable-ai`
  585. - Environment Variables:
  586. ```
  587. CLI_MCP_SUBAGENTS=codex,claude,cursor,gemini
  588. ```
  589. </details>
  590. <details>
  591. <summary><b>Perplexity Desktop</b> - AI Search and Research Assistant</summary>
  592. Configure in Perplexity settings:
  593. ```json
  594. {
  595. "mcpConfig": {
  596. "servers": {
  597. "roundtable-ai": {
  598. "command": "roundtable-ai",
  599. "env": {
  600. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  601. }
  602. }
  603. }
  604. }
  605. }
  606. ```
  607. </details>
  608. <details>
  609. <summary><b>Qodo Gen</b> - AI Code Generation and Analysis Tool</summary>
  610. Add to Qodo Gen configuration:
  611. ```json
  612. {
  613. "mcp_servers": {
  614. "roundtable-ai": {
  615. "command": "roundtable-ai",
  616. "env": {
  617. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  618. }
  619. }
  620. }
  621. }
  622. ```
  623. </details>
  624. ---
  625. ### 🛠️ Specialized Tools
  626. <details>
  627. <summary><b>Opencode</b> - Open-Source AI Code Editor</summary>
  628. Add to `opencode_config.json`:
  629. ```json
  630. {
  631. "mcpServers": {
  632. "roundtable-ai": {
  633. "command": "roundtable-ai",
  634. "env": {
  635. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  636. }
  637. }
  638. }
  639. }
  640. ```
  641. </details>
  642. <details>
  643. <summary><b>OpenAI Codex</b> - OpenAI's Code Generation Model Interface</summary>
  644. Edit `config.toml`:
  645. ```toml
  646. [mcp_servers.roundtable-ai]
  647. command = "roundtable-ai"
  648. env = { CLI_MCP_SUBAGENTS = "codex,claude,cursor,gemini" }
  649. ```
  650. </details>
  651. <details>
  652. <summary><b>Kiro</b> - AI Development Assistant</summary>
  653. Configure in `~/.kiro/config.json`:
  654. ```json
  655. {
  656. "mcpServers": {
  657. "roundtable-ai": {
  658. "command": "roundtable-ai",
  659. "env": {
  660. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  661. }
  662. }
  663. }
  664. }
  665. ```
  666. </details>
  667. <details>
  668. <summary><b>Trae</b> - AI Development Environment</summary>
  669. Add to Trae workspace configuration:
  670. ```json
  671. {
  672. "mcp": {
  673. "servers": {
  674. "roundtable-ai": {
  675. "command": "roundtable-ai",
  676. "env": {
  677. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  678. }
  679. }
  680. }
  681. }
  682. }
  683. ```
  684. </details>
  685. <details>
  686. <summary><b>LM Studio</b> - Local Language Model Interface</summary>
  687. **One-Click Install**:
  688. 1. Navigate to **Program > Install > Edit mcp.json**
  689. 2. Search for "Roundtable AI" in marketplace
  690. 3. Click "Install"
  691. **Manual Configuration**:
  692. ```json
  693. {
  694. "mcpServers": {
  695. "roundtable-ai": {
  696. "command": "roundtable-ai",
  697. "env": {
  698. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  699. }
  700. }
  701. }
  702. }
  703. ```
  704. </details>
  705. <details>
  706. <summary><b>Zencoder</b> - AI-Powered Coding Assistant</summary>
  707. Configure via Zencoder settings panel:
  708. ```json
  709. {
  710. "mcp_configuration": {
  711. "roundtable-ai": {
  712. "command": "roundtable-ai",
  713. "env": {
  714. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  715. }
  716. }
  717. }
  718. }
  719. ```
  720. </details>
  721. <details>
  722. <summary><b>Augment Code</b> - AI-Powered Code Completion</summary>
  723. Add to Augment Code workspace settings:
  724. ```json
  725. {
  726. "mcpServers": {
  727. "roundtable-ai": {
  728. "command": "roundtable-ai",
  729. "transport": "stdio",
  730. "env": {
  731. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  732. }
  733. }
  734. }
  735. }
  736. ```
  737. </details>
  738. <details>
  739. <summary><b>Roo Code</b> - AI Development Environment</summary>
  740. Configure in Roo Code project settings:
  741. ```json
  742. {
  743. "ai_assistants": {
  744. "mcp_servers": {
  745. "roundtable-ai": {
  746. "command": "roundtable-ai",
  747. "env": {
  748. "CLI_MCP_SUBAGENTS": "codex,claude,cursor,gemini"
  749. }
  750. }
  751. }
  752. }
  753. }
  754. ```
  755. </details>
  756. ---
  757. ### 🔧 Configuration Tips
  758. #### Environment Variables Reference
  759. ```bash
  760. # Specify which AI assistants to enable
  761. CLI_MCP_SUBAGENTS="codex,claude,cursor,gemini"
  762. # Enable debug logging
  763. CLI_MCP_DEBUG=true
  764. # Override availability checking
  765. CLI_MCP_IGNORE_AVAILABILITY=true
  766. ```
  767. #### Command Alternatives
  768. All IDEs support these equivalent commands:
  769. - `roundtable-ai` (primary command)
  770. - `roundtable-mcp-server` (descriptive alias)
  771. - `python -m roundtable_mcp_server` (Python module)
  772. - `npx @roundtable/mcp-server` (NPM package - coming soon)
  773. #### Verification
  774. After installation, verify the integration works:
  775. ```bash
  776. # Check server availability
  777. roundtable-ai --check
  778. # Test connection (varies by IDE)
  779. # Most IDEs will show "Roundtable AI" in their AI assistant panel
  780. ```
  781. #### Troubleshooting
  782. 1. **Server not found**: Ensure `roundtable-ai` is in your PATH
  783. 2. **Permission denied**: Run `chmod +x $(which roundtable-ai)`
  784. 3. **Config not loaded**: Check file paths and JSON syntax
  785. 4. **No AI tools detected**: Run `roundtable-ai --check` first
  786. ## Available MCP Tools
  787. Once integrated, you get access to:
  788. ### Availability Checks
  789. - `check_codex_availability` - Verify Codex CLI status
  790. - `check_claude_availability` - Verify Claude Code CLI status
  791. - `check_cursor_availability` - Verify Cursor CLI status
  792. - `check_gemini_availability` - Verify Gemini CLI status
  793. ### Unified Task Execution
  794. - `execute_codex_task` - Run coding tasks through Codex
  795. - `execute_claude_task` - Run coding tasks through Claude Code
  796. - `execute_cursor_task` - Run coding tasks through Cursor
  797. - `execute_gemini_task` - Run coding tasks through Gemini
  798. ## Advanced Configuration
  799. ### Environment Variables
  800. ```bash
  801. # Specify which assistants to enable
  802. export CLI_MCP_SUBAGENTS="codex,gemini"
  803. # Enable all tools regardless of availability
  804. export CLI_MCP_IGNORE_AVAILABILITY=true
  805. # Enable debug logging
  806. export CLI_MCP_DEBUG=true
  807. ```
  808. ### Command Line Options
  809. ```bash
  810. roundtable-ai --help
  811. Options:
  812. --agents TEXT Comma-separated list of agents (gemini,claude,codex,cursor)
  813. --check Check availability of all AI tools
  814. --debug Enable debug logging
  815. --version Show version information
  816. --help Show this message and exit
  817. ```
  818. ## Contributing
  819. 1. Fork the repository
  820. 2. Create a feature branch (`git checkout -b feature/amazing-feature`)
  821. 3. Commit your changes (`git commit -m 'Add some amazing feature'`)
  822. 4. Push to the branch (`git push origin feature/amazing-feature`)
  823. 5. Open a Pull Request
  824. ## License
  825. This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
  826. ---
  827. **Built for developers who value their time.** Stop context-switching between AI tools and start solving problems faster with coordinated multi-agent workflows.
  828. For more examples, advanced usage patterns, and troubleshooting guides, visit our [GitHub repository](https://github.com/askbudi/roundtable).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.