How to Use the Kibo Commerce MCP in OpenAI Agents SDK

Q: What happens if an agent tries to modify Kibo inventory?

This specific server only exposes read operations like getinventorystatus and listlocations. The OpenAI guardrails will block any hallucinated attempts to write data, keeping your stock levels secure.

Connect the Kibo Commerce MCP server to your OpenAI Agents SDK system. Build production-ready retail agents with strict safety guardrails.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Kibo Commerce MCP to OpenAI Agents SDK

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

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Kibo Commerce MCP Server for production

Your OpenAI agents need real-world retail data without breaking things. When an agent calls `get_inventory_status`, the SDK's built-in guardrails validate the action before touching the Kibo API. You get real-time stock counts for any SKU while maintaining strict execution constraints. Handoffs work perfectly here. You can build a specialized inventory agent that monitors `list_locations` and hands off to an order-routing agent when stock runs low. Every call to `get_location_details` shows up in your OpenAI tracing dashboard, so you know exactly why the agent routed an order to a specific warehouse.

Traceable order routing

Managing commerce orders requires high visibility. Your agents pull live transaction data using `list_orders` and drill down into specific line items with `get_order_details`. Since this runs through the OpenAI framework, every step is logged and completely traceable. You don't want agents guessing about fulfillment. By combining `get_site_settings` with order data, the agent knows your exact platform configurations before making decisions. If a customer asks about a delayed shipment, the agent fetches the exact status and you see the entire reasoning chain in your logs.

Safe catalog exploration

Exploring your Kibo catalog directly from Python requires zero manual mapping. The SDK auto-discovers `list_products` and `list_categories` the moment you connect the server. Set `cacheToolsList=True` in your setup, and your agents won't waste time re-fetching tool definitions. Agents can pull specific item metadata using `get_product_details` to answer customer inquiries or audit product descriptions. Using OpenAI's framework means you can apply safety constraints that prevent the agent from exposing sensitive wholesale pricing while browsing the catalog.

Setup guide

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

Create your Agent

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

Run the agent

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

Install the openai-agents package via pip. Create an MCPServerStreamableHttp instance with your Kibo server URL and pass it to your agent's mcp_servers list. The SDK will auto-discover all ten commerce tools immediately.

Yes, every tool invocation is tracked natively. When your agent runs get_order_details or list_customers, the payload and latency appear directly in your OpenAI tracing dashboard.

Pass cacheToolsList=True when configuring the MCP server in your Python code. This stops the agent from pulling the tool schema on every single request, speeding up catalog queries.

This specific server only exposes read operations like get_inventory_status and list_locations. The OpenAI guardrails will block any hallucinated attempts to write data, keeping your stock levels secure.

The server processes sensitive PII when your agent calls list_customers or get_order_details. Vinkius isolates this data in a V8 sandbox that destroys itself after the request finishes. Your OpenAI client receives the exact payload over an ephemeral connection, leaving no persistent data behind on our infrastructure.

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