How to Use the Eventee MCP in OpenAI Agents SDK

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

Install openai-agents via pip, then initialize the MCP server using MCPServerStreamableHttp with your Vinkius endpoint. Pass this server instance in the mcpservers list when constructing your agent. The SDK will automatically discover all ten event management tools.

Q: How does the OpenAI Agents SDK handle Eventee API rate limits?

Set cacheToolsList=True in your connection parameters to avoid redundant schema lookups. For live endpoints like listeventaudiencequestions, use the SDK's built-in loop throttling to prevent your agent from hitting API rate limits during busy Q&A sessions.

Q: How do I check my Eventee account limits using this server?

Your agent can call geteventeeaccountmetadata to retrieve your current plan limits and API usage metrics. This allows your Python application to dynamically adjust polling frequencies based on remaining API credits.

Q: How is attendee data secured when using this MCP server?

All attendee contact information and names pulled via listeventregisteredattendees are processed in memory within Vinkius's zero-trust V8 sandbox. No personal data is stored on our servers, and communication between your agent and Eventee is fully encrypted.

Build production-grade event agents with the OpenAI Agents SDK to track speakers, monitor questions, and audit live engagement.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Eventee MCP to OpenAI Agents SDK

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

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Track Live Sessions with OpenAI Agents SDK

The `list_currently_active_events` tool lets your agent identify which event sessions are happening right now. This MCP tool pulls active event IDs directly from your Eventee account, giving your OpenAI Agents SDK runtime immediate context about live stages. Once the active event is identified, the agent uses `list_event_sessions` to pull the complete schedule. This setup lets you build guardrails in Python to verify if a session is running over time before the agent alerts the coordinator.

Automate Speaker and Attendee Coordination

The `list_event_speakers` tool retrieves the registered speakers for any specific event ID. Your OpenAI agent uses this data to cross-reference speaker profiles with real-time room assignments. If a speaker is delayed, the agent pulls the attendee list using `list_event_registered_attendees`. The OpenAI Agents SDK then coordinates a handoff to a messaging agent to notify those specific registered users of the schedule change.

Run Real-Time Audience Audits via MCP Server

The `quick_event_engagement_audit` tool generates a high-level summary of active sessions, speakers, and attendee counts. This tool gives your OpenAI agent a numeric snapshot of the event's current health without parsing huge logs. To handle audience feedback, the agent calls `list_event_audience_questions` to pull pending queries. The OpenAI Agents SDK runs these questions through your safety guardrails, filtering out spam before displaying them to the moderator.

Setup guide

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

Create your Agent

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

Run the agent

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

Install `openai-agents` via pip, then initialize the MCP server using `MCPServerStreamableHttp` with your Vinkius endpoint. Pass this server instance in the `mcp_servers` list when constructing your agent. The SDK will automatically discover all ten event management tools.

Yes. While the MCP server exposes all ten tools, you can control tool access at the agent level. Define your agent's system prompt or filter the tool list before passing it to the OpenAI agent constructor to restrict actions like retrieving attendee lists.

Set `cacheToolsList=True` in your connection parameters to avoid redundant schema lookups. For live endpoints like `list_event_audience_questions`, use the SDK's built-in loop throttling to prevent your agent from hitting API rate limits during busy Q&A sessions.

Your agent can call `get_eventee_account_metadata` to retrieve your current plan limits and API usage metrics. This allows your Python application to dynamically adjust polling frequencies based on remaining API credits.

All attendee contact information and names pulled via `list_event_registered_attendees` are processed in memory within Vinkius's zero-trust V8 sandbox. No personal data is stored on our servers, and communication between your agent and Eventee is fully encrypted.

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