How to Use the Plecto MCP in OpenAI Agents SDK

Q: How do I connect the OpenAI Agents SDK to Plecto?

Install the SDK, then instantiate the MCPServerStreamableHttp client with your Vinkius URL. Pass that server object to your Agent's constructor. The tools are discovered automatically.

Q: Can my OpenAI agent create new dashboards in Plecto?

No, this MCP server is for managing data within existing dashboards. Your agent can use createdataregistration to add data and listkpidashboards to see what's there, but it can't create new dashboards or widgets.

Q: What's the best way to use Plecto and the OpenAI Agents SDK for performance?

Set cacheToolsList=True when you initialize your Agent. This prevents the SDK from re-fetching the tool list on every run. It's a small change that makes a big difference for production agents.

Build production agents with the OpenAI Agents SDK that safely write data to Plecto dashboards without needing custom API code.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers — Included with Plan

Connect Plecto MCP to OpenAI Agents SDK

Create your Vinkius account to connect Plecto to OpenAI Agents SDK — we handle the hosting, security, and runtime updates so you don't have to. No server setup required.

GDPR Included with Plan

Setup Plecto with OpenAI Agents SDK

Ask AI about this MCP

ChatGPT

Claude

Perplexity Vinkius runs on Gemini

Gemini

Grok

Push Sales Data to Dashboards

Your agent can log new sales or any other metric directly into Plecto. Use the `create_data_registration` tool to add a new data entry from any system—a CRM webhook, a Slack command, you name it. It's how you get real-time data onto your dashboards without manual CSV uploads. Because you're using the OpenAI Agents SDK, you get built-in guardrails. You can configure your agent to require human confirmation before it pushes a new registration, preventing bad data from hitting your live dashboards. It's a safety net for your automated Plecto workflows.

Audit Plecto with Your OpenAI Agent

Give your agent visibility into your entire Plecto setup. It can pull lists of all your dashboards, widgets, and data sources using `list_kpi_dashboards`, `list_widgets`, and `list_data_sources`. This is great for building internal tools that need to know what's configured in Plecto. Your specialized agents can work together. One agent could monitor for new employees via `list_account_employees` and another could verify their data registrations with `list_data_registrations`. The SDK's handoff feature lets you build a full-stack Plecto management system.

Sync Team Structures and KPIs

Keep your Plecto teams in sync with your source of truth. An agent can use `list_organizational_teams` to check the current team setup and compare it against your HR system. It's a simple way to automate user provisioning for your dashboards. You can even have an agent that fetches specific employee details with `get_employee` or pulls the logic behind a metric with `list_formulas`. This MCP server gives your OpenAI agents the context they need to manage performance data correctly.

Setup guide

Set up Plecto 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 Plecto tools at runtime.
3

Create your Agent

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

Run the agent

Call Runner.run(agent, prompt) to execute. The agent invokes the appropriate Plecto 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="Plecto Agent",
            instructions="You have access to Plecto 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 Plecto. 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 Plecto 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 Plecto MCP in OpenAI Agents SDK

Install the SDK, then instantiate the `MCPServerStreamableHttp` client with your Vinkius URL. Pass that server object to your Agent's constructor. The tools are discovered automatically.

No, this MCP server is for managing data *within* existing dashboards. Your agent can use `create_data_registration` to add data and `list_kpi_dashboards` to see what's there, but it can't create new dashboards or widgets.

Set `cacheToolsList=True` when you initialize your Agent. This prevents the SDK from re-fetching the tool list on every run. It's a small change that makes a big difference for production agents.

Only the data required for a specific tool call is sent. For example, if your agent calls `get_employee` with an ID, that ID is part of the request. The OpenAI platform processes the call, but the data itself is handled by the Vinkius MCP server.

Your Plecto data, like employee details or registration entries, is processed within the Vinkius zero-trust environment. The OpenAI agent only invokes the tools; it doesn't store your Plecto data long-term. Your Vinkius endpoint token secures the connection.

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