How to Use the Cube.dev MCP in LangChain

Q: How does LangChain handle Cube.dev schema changes?

Your LangChain agent calls getmeta at the start of a session. This pulls the latest Cube.dev cubes dynamically, so your chain adapts to schema updates without requiring you to redeploy your code.

Q: Can I trace Cube.dev queries in LangChain runs with LangSmith?

Yes. Every tool call like loadquery or executecubesql passes through the LangChain adapter. LangSmith logs the inputs, raw payloads, and execution latencies automatically.

Q: Does this LangChain MCP integration support multiple Cube.dev environments?

It does. Your LangChain chain can run listenvironments and listdeployments to switch contexts. You just need to supply your CUBECLOUDAPIKEY to access these specific tools.

Q: How do I handle authentication for the Cube.dev metadata API?

Run generatemetatoken via the MCP Server inside your chain. This returns a JWT that your LangChain run can use to safely authenticate subsequent calls to the metadata endpoints.

Run analytical LangChain chains that query your Cube.dev semantic layer and check pre-aggregations directly inside your pipelines.

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 LangChain

Create your Vinkius account to connect Cube.dev to LangChain 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 LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Chain Cube.dev metadata discovery into LangChain runs

LangChain agents need to know what cubes are available before they write a prompt. This MCP server lets your LangChain chain call `list_entities` and `get_meta` to map out your Cube.dev semantic layer dynamically. Instead of guessing column names, your LangChain pipeline inspects physical dimensions and measures. Your chain feeds this Cube.dev schema directly into the next step, ensuring accurate analytical queries without hardcoded schemas.

Verify query health and run Cube.dev SQL on the fly

Stop letting your LangChain chains send broken requests to your Cube.dev semantic layer. Use `convert_query` to translate SQL drafts into proper REST API payloads, then hit `load_query` to fetch the actual aggregated numbers from Cube.dev. If a LangChain run feels sluggish, your chain can call `get_sql` to debug the exact Cube.dev query plan. Your LangChain agent can even invoke `execute_cube_sql` to test raw queries against the Cube.dev SQL API and log performance right inside LangSmith.

Automate Cube.dev pre-aggregations in LangChain

When running long LangChain chains on this MCP Server that rely on fresh Cube.dev data, stale caches ruin your results. Your LangChain agent can run `get_pre_aggregation_job_status` to make sure your Cube.dev tables are warm before kicking off heavy analytical steps. If the Cube.dev cache is cold, the LangChain agent triggers a rebuild using `trigger_pre_aggregation_job`. It loops until the job finishes, guaranteeing your LangChain pipeline never serves stale Cube.dev reports to your users.

Setup guide

Set up Cube.dev MCP in LangChain

Prerequisites

Python 3.10+ installed
langchain-mcp-adapters + langgraph packages
Active Vinkius subscription with a valid endpoint token

1

Install dependencies
Run pip install langchain-mcp-adapters langgraph langchain-openai. The MCP adapters package converts MCP tools into native LangChain BaseTool objects.
2

Connect via HTTP transport
Use MultiServerMCPClient with "transport": "http" pointing to your Vinkius endpoint. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.
3

Create a ReAct agent
Pass the discovered tools to create_react_agent() from LangGraph. The agent automatically routes Cube.dev tool calls through the MCP protocol.
4

Run with any LLM
Swap ChatOpenAI for ChatAnthropic, ChatGoogleGenerativeAI, or any LangChain-compatible model. The MCP tools work identically across all providers.

agent.py

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

async with MultiServerMCPClient({
    "cubedev-mcp": {
        "transport": "http",
        "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp",
    }
}) as client:
    tools = client.get_tools()

    agent = create_react_agent(
        ChatOpenAI(model="gpt-4o"),
        tools,
    )
    result = await agent.ainvoke({
        "messages": "List recent Cube.dev transactions"
    })
    print(result["messages"][-1].content)

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 LangChain

Your LangChain agent calls `get_meta` at the start of a session. This pulls the latest Cube.dev cubes dynamically, so your chain adapts to schema updates without requiring you to redeploy your code.

Yes. Every tool call like `load_query` or `execute_cube_sql` passes through the LangChain adapter. LangSmith logs the inputs, raw payloads, and execution latencies automatically.

It does. Your LangChain chain can run `list_environments` and `list_deployments` to switch contexts. You just need to supply your CUBE_CLOUD_API_KEY to access these specific tools.

Run `generate_meta_token` via the MCP Server inside your chain. This returns a JWT that your LangChain run can use to safely authenticate subsequent calls to the metadata endpoints.

Your analytical queries and database schemas stay secure. This MCP server acts as a local proxy, passing your metadata and `execute_cube_sql` payloads directly to your Cube.dev instance without storing any query parameters or database credentials.

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