How to Use the Camunda (BPMN Engine) MCP in OpenAI Agents SDK

Q: How do I connect the Camunda (BPMN Engine) MCP Server to the OpenAI Agents SDK?

Install the SDK first, then initialize the MCPServerStreamableHttp class with your Vinkius endpoint URL. Pass this instance in the mcpservers list when instantiating your Agent. Make sure to set cacheToolsList=True to avoid fetching the tool definitions on every single run.

Q: Can OpenAI Agents SDK handle complex process variables without failing validation?

Yes, the agent uses searchvariables and getvariable to read typed data from your process context. Because the server returns structured schemas, the OpenAI Agents SDK validates the variable payloads against your schema before passing them to your agent.

Deploy production-grade Camunda workflows directly through OpenAI Agents SDK with automatic tool discovery and built-in guardrails.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Camunda (BPMN Engine) MCP to OpenAI Agents SDK

Create your Vinkius account to connect Camunda (BPMN Engine) 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 Camunda (BPMN Engine) with OpenAI Agents SDK

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Run workflows safely from OpenAI Agents SDK

This MCP Server exposes 25 tools to your OpenAI Agents SDK instance, starting with the ability to kick off executions via `start_process_instance` and fetch XML configurations using `get_process_definition_xml`. Your production agents read the current state of any workflow, inspect variables, and make routing decisions based on live system data. OpenAI's built-in guardrails validate every single parameter before your agent attempts to execute a transition. This prevents the model from injecting invalid payloads or trying to trigger steps that do not exist in your active BPMN schema.

Manage human-in-the-loop tasks autonomously

This MCP Server provides direct access to user tasks, letting your agent assign work with `assign_user_task` or complete steps via `complete_user_task`. The agent queries active queues, inspects task forms with `get_user_task_form`, and unassigns stuck tasks using `unassign_user_task`. Instead of writing custom API integration code for every user task update, you pass the server directly to the OpenAI Agents SDK constructor. The agent automatically handles handoffs between specialized workers to process queue bottlenecks.

Resolve runtime incidents and worker jobs

This MCP Server enables automated incident response by exposing `get_incident` and `fail_job` directly to your agent. When a worker fails in your pipeline, the agent pulls down the stack trace, diagnoses the issue, and can trigger retries or throw specific BPMN errors with `throw_job_error`. By caching the tool list in your python code, you keep latency low while the agent polls for active jobs via `activate_jobs`. You get complete execution traces inside your OpenAI dashboard for every job completion or failure.

Setup guide

Set up Camunda (BPMN Engine) 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 Camunda (BPMN Engine) tools at runtime.
3

Create your Agent

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

Run the agent

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

Install the SDK first, then initialize the `MCPServerStreamableHttp` class with your Vinkius endpoint URL. Pass this instance in the `mcp_servers` list when instantiating your Agent. Make sure to set `cacheToolsList=True` to avoid fetching the tool definitions on every single run.

Yes, the agent uses `search_variables` and `get_variable` to read typed data from your process context. Because the server returns structured schemas, the OpenAI Agents SDK validates the variable payloads against your schema before passing them to your agent.

You control this at the Vinkius gateway level or by filtering the tools array in Python before passing it to the Agent constructor. This prevents the model from invoking destructive actions like failing jobs or reassigning tasks when it should only be reading process definitions.

The agent catches the failure, inspects the error trace using `search_incidents`, and decides whether to retry or escalate. It can execute `fail_job` to register the incident in your engine, keeping your external BPMN state perfectly synchronized.

Your process variables, BPMN XML schemas, and user task payloads remain strictly inside the isolated Vinkius V8 sandbox. Only the minimal parameters required to execute a specific tool like `complete_user_task` are ever sent to the OpenAI endpoint, meaning your core business logic and user details are never stored or used for model training.

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