How to Use the Cube.dev MCP in OpenAI Agents SDK

Q: How do I set up Cube.dev with OpenAI Agents SDK using MCP?

Install openai-agents and initialize the MCP server streamable HTTP client pointing to your Vinkius endpoint. Pass this server instance directly into your Agent constructor's mcpservers list. The SDK automatically discovers all fifteen Cube tools.

Q: Can my OpenAI Agents SDK agent handle Cube.dev Cloud deployments?

Yes, if you provide your CUBECLOUDAPIKEY. Your agent can call listdeployments and listenvironments to monitor your cloud setups. This allows your OpenAI agents to coordinate across different staging and production data environments.

Q: How does OpenAI Agents SDK handle Cube.dev query translation?

The agent uses convertquery to translate raw SQL strings into Cube's native REST API format. This ensures that any natural language request processed by your OpenAI agent correctly formats into a valid Cube payload before execution.

Q: How do I verify Cube.dev connection status?

Your agent runs checklive and checkready to confirm the semantic layer is accessible. If these checks fail, your agent can halt execution or notify your team instead of sending broken queries to a dead endpoint.

Get production-grade Cube.dev semantic layer access inside your OpenAI Agents SDK workflow with strict runtime safety.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Cube.dev MCP to OpenAI Agents SDK

Create your Vinkius account to connect Cube.dev to OpenAI Agents SDK and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup Cube.dev with OpenAI Agents SDK

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Safe SQL execution via OpenAI Agents SDK

The `execute_cube_sql` tool lets your agents query data without breaking things. By calling this tool, your agent pulls raw metrics directly through Cube's SQL API. The SDK's built-in guardrails ensure the agent doesn't run wild queries, keeping database load controlled. For debugging, the agent can use `get_sql` to inspect the exact query structure before running it. This prevents bad SQL from ever hitting your database, giving your production pipelines a reliable layer of defense.

Automated pre-aggregation job management

The `trigger_pre_aggregation_job` tool keeps your dashboards fast without manual babysitting. Your agent monitors performance and rebuilds stale tables when data updates. The agent then tracks progress using `get_pre_aggregation_job_status` to confirm the cache is ready. If a job stalls, the OpenAI dashboard traces the failure instantly, so you know exactly what went wrong.

Dynamic metadata exploration with this MCP Server

This MCP Server exposes `list_entities` to map out your cubes and views on the fly. Agents need to understand your schema before they can query it. Once the layout is clear, the agent targets specific tables using `get_entity` to build precise queries. This schema discovery happens entirely in the background, making your multi-agent handoffs incredibly smooth.

Setup guide

Set up Cube.dev MCP in OpenAI Agents SDK

Prerequisites

Python 3.10+ installed
openai-agents package (pip install openai-agents)
Active Vinkius subscription with a valid endpoint token

1

Install the SDK

Run pip install openai-agents to install the OpenAI Agents SDK. The MCP integration is built-in — no extra dependencies needed.
2

Connect via SSE transport

Use MCPServerSse with your Vinkius endpoint URL. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. The SDK auto-discovers all Cube.dev tools at runtime.
3

Create your Agent

Pass the MCP to Agent(mcp_servers=[server]). The agent receives Cube.dev tools as native definitions — JSON schemas resolve automatically.
4

Run the agent

Call Runner.run(agent, prompt) to execute. The agent invokes the appropriate Cube.dev tools and returns structured results. Copy the full example on the right to get started.

agent.py

import asyncio
from agents import Agent, Runner
from agents.mcp import MCPServerSse

async def main():
    async with MCPServerSse(
        url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
    ) as server:
        agent = Agent(
            name="Cube.dev Agent",
            instructions="You have access to Cube.dev tools.",
            mcp_servers=[server],
        )
        result = await Runner.run(agent, "List recent transactions")
        print(result.final_output)

asyncio.run(main())

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Cube.dev. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect Cube.dev now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about Cube.dev MCP in OpenAI Agents SDK

Install `openai-agents` and initialize the MCP server streamable HTTP client pointing to your Vinkius endpoint. Pass this server instance directly into your Agent constructor's `mcp_servers` list. The SDK automatically discovers all fifteen Cube tools.

Yes, if you provide your CUBE_CLOUD_API_KEY. Your agent can call `list_deployments` and `list_environments` to monitor your cloud setups. This allows your OpenAI agents to coordinate across different staging and production data environments.

The agent uses `convert_query` to translate raw SQL strings into Cube's native REST API format. This ensures that any natural language request processed by your OpenAI agent correctly formats into a valid Cube payload before execution.

Your agent runs `check_live` and `check_ready` to confirm the semantic layer is accessible. If these checks fail, your agent can halt execution or notify your team instead of sending broken queries to a dead endpoint.

Yes, because all raw SQL queries and metadata payloads stay within your isolated Vinkius container. We use ephemeral sandboxes to execute tools like `load_query`, meaning your proprietary schema definitions are never cached or exposed to public training sets.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript