How to Use the Ayanza MCP in OpenAI Agents SDK

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

Install the library using pip install openai-agents in your project. Configure the MCP Server connection using MCPServerStreamableHttp with your Vinkius endpoint URL and pass it to the Agent constructor. This automatically registers tools like listprojects so your agent can use them immediately.

Q: How does cacheToolsList speed up Ayanza queries in OpenAI Agents SDK?

Setting cacheToolsList=True stops the SDK from fetching the schema on every single agent run. It stores the tool signatures locally, meaning calls to gettask execute much faster. Your production API latency drops significantly.

Q: What happens if an agent tries to delete a task without permission?

The deletetask call will fail at the API level, and the error returns to your agent. Your Python code catches this failure or lets the agent attempt to resolve it. You should use guardrails to block these calls before they reach the server.

Run production-grade OpenAI Agents SDK workflows that manage your Ayanza tasks and wikis with strict runtime guardrails.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Ayanza MCP to OpenAI Agents SDK

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

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Safely mutate Ayanza tasks with OpenAI Agents SDK

This MCP integration exposes `create_task` and `update_task` directly to your Python-based agent runtimes. By caching the tools list via `cacheToolsList=True`, your system avoids redundant HTTP requests during startup. Before any actual API execution, the SDK's built-in guardrails validate the proposed changes. If an agent tries to wipe out a sprint backlog using `delete_task`, your validation layer catches it instantly. Everything shows up in your OpenAI tracing dashboard for easy auditing.

Multi-agent handoffs for wiki and task coordination

Build a dedicated documentation agent that uses `list_wiki_pages` to read team knowledge bases via the MCP protocol. When it spots a missing requirement, it hands off the execution context to a project manager agent. This second agent takes over to run `get_project` and map out the dependencies. It then spins up the work items. The entire handoff happens in code, keeping your workspace structured without manual intervention.

Real-time workspace audits via this MCP Server

Monitoring team activity requires calling `list_users` alongside `list_tasks` to map out who is carrying the heaviest load. This MCP Server lets your agent query your member directory and active boards to get raw JSON payloads representing your actual team structure. Because Vinkius runs this server in a secure sandbox, your credentials never leak into the LLM context. Your agent queries the endpoint, pulls the team list, and generates reports. It does this without exposing raw API keys to the model.

Setup guide

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

Create your Agent

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

Run the agent

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

Install the library using `pip install openai-agents` in your project. Configure the MCP Server connection using `MCPServerStreamableHttp` with your Vinkius endpoint URL and pass it to the `Agent` constructor. This automatically registers tools like `list_projects` so your agent can use them immediately.

Yes, you control this through the SDK's agent definition. You limit the tool list passed to the constructor, preventing the agent from calling destructive operations like `delete_task`. This keeps your workspace safe even if the model behaves unexpectedly.

Setting `cacheToolsList=True` stops the SDK from fetching the schema on every single agent run. It stores the tool signatures locally, meaning calls to `get_task` execute much faster. Your production API latency drops significantly.

The `delete_task` call will fail at the API level, and the error returns to your agent. Your Python code catches this failure or lets the agent attempt to resolve it. You should use guardrails to block these calls before they reach the server.

Vinkius handles all authentication securely, keeping your API tokens isolated from the agent's prompts. Your workspace data, including wiki pages and task descriptions, travels over encrypted HTTPS directly to the sandbox. No data is stored or logged on the proxy layer.

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