How to Use the Civo (Cloud-native Kubernetes Cloud Provider API) MCP in OpenAI Agents SDK

Q: How do I start managing Civo (Cloud-native Kubernetes Cloud Provider API) with the OpenAI Agents SDK?

First, pip install openai-agents. Then create an MCPServerStreamableHttp instance using your Vinkius endpoint URL. You'll pass that into the Agent constructor and the Civo tools are discovered automatically.

Q: Can my OpenAI agent create a new Kubernetes cluster on Civo?

Yes. The agent can use the createcluster tool. A good approach is to have the agent first call listregions and listsizes to decide on the right configuration before creating the cluster.

Use the OpenAI Agents SDK to build production agents that safely manage your Civo cloud infrastructure.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Civo (Cloud-native Kubernetes Cloud Provider API) MCP to OpenAI Agents SDK

Create your Vinkius account to connect Civo (Cloud-native Kubernetes Cloud Provider API) 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 Civo (Cloud-native Kubernetes Cloud Provider API) with OpenAI Agents SDK

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Spin Up and Manage Civo Compute

Your agent can now provision entire environments on Civo. It can query for available instance sizes with `list_sizes`, then fire up a new machine using `create_instance`. This isn't just for one-off tasks; you can build agents that manage fleets of instances. Here's where the OpenAI SDK shines. You can create specialized agents, handing off tasks between them. For example, a 'provisioning' agent could create a cluster with `create_cluster`, then pass the cluster ID to a 'maintenance' agent that handles reboots with `reboot_instance`. The built-in tracing lets you see every step.

Configure Networks and Firewalls

Let an agent handle your Civo network setup. It can create private networks with `create_network` and then lock them down by creating a firewall using `create_firewall`. From there, it can add specific ingress and egress rules with `create_firewall_rule`. This is perfect for building agents that enforce security policies. You can design an agent that scans your configuration, finds open ports, and automatically applies firewall rules to fix them. The SDK's guardrails give you a chance to review and approve risky actions before they run.

Manage Teams and Monitor Costs

This MCP Server connects your agent directly to Civo's administrative functions. You can have an agent add new developers to a project with `add_team_member` or change their permissions with `update_team_member_status`. It's a simple way to automate user onboarding. On the finance side, you can build a cost-monitoring agent. Have it periodically call `get_charges` to see your hourly usage and `get_quota` to check if you're approaching any limits. If costs spike, the agent can send an alert or even stop non-essential services with `stop_instance`.

Setup guide

Set up Civo (Cloud-native Kubernetes Cloud Provider API) 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 Civo (Cloud-native Kubernetes Cloud Provider API) tools at runtime.
3

Create your Agent

Pass the MCP to Agent(mcp_servers=[server]). The agent receives Civo (Cloud-native Kubernetes Cloud Provider API) tools as native definitions — JSON schemas resolve automatically.
4

Run the agent

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

First, `pip install openai-agents`. Then create an `MCPServerStreamableHttp` instance using your Vinkius endpoint URL. You'll pass that into the `Agent` constructor and the Civo tools are discovered automatically.

Yes. The agent can use the `create_cluster` tool. A good approach is to have the agent first call `list_regions` and `list_sizes` to decide on the right configuration before creating the cluster.

Vinkius handles the Civo API authentication for you. Your agent only needs the single Vinkius endpoint token, which the SDK uses to securely connect to the server.

The OpenAI framework is built for creating specialized agents. You can give a 'network-agent' access to only the `create_network` and `create_firewall` tools, while a 'compute-agent' gets `create_instance` and `reboot_instance`. The automatic discovery of the MCP toolset makes this easy to configure.

The server handles your Civo API credentials, instance details, and network configurations. Vinkius isolates each request in an ephemeral, single-use sandbox. Your Vinkius token is the only credential your agent needs to handle.

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