How to Use the FireHydrant MCP in OpenAI Agents SDK

Q: How does FireHydrant connect to my OpenAI Agents SDK pipeline?

You register the server using the MCPServerStreamableHttp class. Pass the endpoint URL from Vinkius directly into your agent constructor, and the MCP server auto-discovers all twelve incident management tools.

Q: How do I handle performance caching for tool definitions?

Set cacheToolsList=True in your server configuration. This avoids fetching tool schemas on every single turn, reducing latency when calling listservices or getteam over the MCP connection.

FireHydrant incident response runs on autopilot with OpenAI Agents SDK, keeping your on-call engineers sane.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect FireHydrant MCP to OpenAI Agents SDK

Create your Vinkius account to connect FireHydrant 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 FireHydrant with OpenAI Agents SDK

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Declare outages instantly using OpenAI Agents SDK

The `create_incident` tool lets your agent kick off active incident response workflows the second a system alert fires. By pairing this with `list_teams`, the agent finds the exact on-call rotation and assigns ownership without wasting critical minutes during a high-severity outage. OpenAI Agents SDK manages these calls using native guardrails to prevent accidental triggers. You define the boundary, and the agent executes the correct setup steps while feeding real-time updates back to your team.

Track live mitigations via the MCP Server

The `update_incident` tool gives your agent direct control over the status of active incidents as they progress toward resolution. Running `list_runbooks` allows the agent to pull active playbooks and check which tasks are complete. This MCP Server integration allows you to build multi-agent handoffs. One agent tracks the technical fix, while a specialized communication agent runs `add_incident_note` to post status updates to stakeholders.

Audit changes and compile retrospectives

The `list_change_events` tool allows your agent to look up recent system changes that might have triggered the current failure. It compares these events against active services via `list_services` to pinpoint the exact deployment that broke the build. Once the incident closes, the agent calls `list_retrospectives` to pull historical context. This lets you generate post-mortem drafts inside the OpenAI dashboard, backed by actual incident timelines.

Setup guide

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

Create your Agent

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

Run the agent

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

You register the server using the `MCPServerStreamableHttp` class. Pass the endpoint URL from Vinkius directly into your agent constructor, and the MCP server auto-discovers all twelve incident management tools.

Yes. You control tool exposure by setting strict system prompts or configuring the agent's tool filters. This prevents the agent from running destructive actions like `update_incident` without explicit human confirmation.

Yes, the server handles async calls natively. Your python code runs the agent within an async context manager, allowing the model to poll `get_incident` without blocking your main event loop.

Set `cacheToolsList=True` in your server configuration. This avoids fetching tool schemas on every single turn, reducing latency when calling `list_services` or `get_team` over the MCP connection.

Vinkius runs the server in a zero-trust, ephemeral V8 isolate sandbox. Your incident details, team rosters, and service configurations never persist on the host, ensuring absolute isolation.

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