How to Use the Fly.io Extended MCP in OpenAI Agents SDK

Q: How do I connect the Fly.io Extended MCP Server to my OpenAI Agents SDK pipeline?

Install the package via pip install openai-agents and initialize MCPServerStreamableHttp with your Vinkius endpoint. Pass this server instance in the mcpservers list when instantiating your Agent. Make sure to set cacheToolsList=True to speed up tool discovery during agent execution.

Q: How does the Fly.io Extended MCP Server handle machine leases during parallel runs in OpenAI Agents SDK?

The server provides createlease and releaselease tools to prevent multiple OpenAI agents from modifying the same machine simultaneously. Your Python agent acquires a lease before running updatemachine and releases it once the deployment completes, avoiding race conditions.

Spin up Fly.io machines directly from your OpenAI Agents SDK pipelines with this managed MCP Server.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Fly.io Extended MCP to OpenAI Agents SDK

Create your Vinkius account to connect Fly.io Extended 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 Fly.io Extended with OpenAI Agents SDK

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Automate Machine Lifecycles with OpenAI Agents SDK

`create_machine` allows your OpenAI agent to provision Fly.io compute instances dynamically during traffic spikes. By wrapping this tool in the OpenAI Agents SDK, you can build specialized agent handoffs that route infrastructure scaling tasks to a dedicated provisioning agent while a monitoring agent checks performance. You configure the agent with `cacheToolsList=True` to keep tool discovery fast and avoid unnecessary network roundtrips. When the agent triggers `stop_machine` or `start_machine`, each execution step is logged directly to your OpenAI tracing dashboard for auditing.

Scale Storage Volumes via OpenAI Agents

`extend_volume` gives your OpenAI agent the exact tool it needs to resize Fly.io volumes when disk space runs low. Instead of writing custom cron jobs, your python agent monitors disk metrics and calls `get_volume` to evaluate current allocations before executing the expansion. This MCP Server exposes storage actions like `create_volume` and `list_volume_snapshots` directly to the SDK. The OpenAI agent runs these tasks within your python runtime, ensuring that your automated storage policies execute only after passing your custom SDK guardrails.

Automated SSL Management for SaaS Apps

`create_acme_certificate` enables your OpenAI-driven agent to request Let's Encrypt certificates programmatically for new customer custom domains. The agent uses `check_certificate` to track DNS validation status without requiring manual SRE intervention. Your production pipeline handles tenant onboarding by chaining `create_app` with certificate generation. By defining these tools inside your `MCPServerStreamableHttp` configuration, the OpenAI agent handles the entire networking stack from app creation to SSL verification.

Setup guide

Set up Fly.io Extended 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 Fly.io Extended tools at runtime.
3

Create your Agent

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

Run the agent

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

Install the package via `pip install openai-agents` and initialize `MCPServerStreamableHttp` with your Vinkius endpoint. Pass this server instance in the `mcp_servers` list when instantiating your Agent. Make sure to set `cacheToolsList=True` to speed up tool discovery during agent execution.

Yes, you can control tool access using the OpenAI Agents SDK guardrails before passing the tools to the Agent constructor. For example, you can intercept calls to destructive tools like `delete_machine` or `delete_app` and require manual human approval in your Python code.

The server provides `create_lease` and `release_lease` tools to prevent multiple OpenAI agents from modifying the same machine simultaneously. Your Python agent acquires a lease before running `update_machine` and releases it once the deployment completes, avoiding race conditions.

Yes, you can run the MCP client within an async context manager in Python to handle non-blocking Fly.io operations. This is particularly useful when calling `wait_machine` to block the agent's execution until a newly created machine transitions to the running state.

Your Fly.io API tokens and machine configuration payloads are strictly isolated within Vinkius's zero-trust V8 sandbox. The MCP server only acts as an ephemeral proxy, meaning your infrastructure credentials are never persisted or exposed to the LLM context.

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