How to Use the Deck of Cards MCP in OpenAI Agents SDK

Q: Can I create a custom deck for a game like Euchre with Deck of Cards and the OpenAI Agents SDK?

Yes. Your agent would use the createpartialdeck tool, passing in the specific card codes for a Euchre deck (9s through Aces). The OpenAI Agents SDK will format the request to the MCP server to get the exact deck you need.

Q: How do I manage a discard pile with Deck of Cards in the OpenAI Agents SDK?

Your agent would use the addtopile tool, specifying a name like 'discard'. To see what's in it, it would call listpile. This lets you build complex game logic directly through your agent.

Q: What's the best way to shuffle a deck?

If you're starting a new game, use shufflenewdeck to create a fresh, shuffled deck in one step. If you need to reshuffle mid-game, use reshuffledeck on the existing deck ID.

Build production-ready game logic or simulations with Deck of Cards tools, fully traced and secured by the OpenAI Agents SDK.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Deck of Cards MCP to OpenAI Agents SDK

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

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Create and Manage Decks

Your agent can build standard or custom decks for any game. Use `create_new_deck` for a 52-card deck or `create_partial_deck` to specify the exact cards you need, like for a game of Pinochle. The `shuffle_new_deck` tool gets a fresh, randomized deck ready for play. The OpenAI Agents SDK traces every call, so you have a complete audit trail of how decks are created and shuffled. This is critical for building fair, verifiable game mechanics in a production environment. Your agent doesn't just ask for a deck; it executes a tracked, auditable operation.

Control Card Flow with Guardrails

This server gives your agent fine-grained control over the game state. It can `draw_cards` from the main deck or manage separate piles for discards or player hands. Tools like `add_to_pile`, `list_pile`, and `draw_from_pile` let your agent move cards around with precision. Because the OpenAI Agents SDK can run guardrails before execution, you can prevent illegal moves, like an agent trying to draw from an empty pile. You define the rules, and the framework helps enforce them before the MCP Server is ever called.

Reshuffle and Reset the Game State

Keep the game moving or reset for a new round. The `reshuffle_deck` tool randomizes the existing deck, while `return_to_deck` and `return_pile_to_deck` put used cards back into circulation. It’s a direct way to manage the lifecycle of a game session. You can build specialized agents for different tasks. One agent could manage the deck using these tools, while another focuses on player strategy. The SDK's handoff feature lets them collaborate, passing control and context between them for more complex simulations. This MCP server provides the core functions they'll act upon.

Setup guide

Set up Deck of Cards 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 Deck of Cards tools at runtime.
3

Create your Agent

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

Run the agent

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

The SDK auto-discovers all 13 tools from the Deck of Cards MCP server. Your agent can then call functions like `draw_cards` or `create_new_deck` as part of its logic. The SDK handles the API calls and tracing for you.

Yes. Your agent would use the `create_partial_deck` tool, passing in the specific card codes for a Euchre deck (9s through Aces). The OpenAI Agents SDK will format the request to the MCP server to get the exact deck you need.

Your agent would use the `add_to_pile` tool, specifying a name like 'discard'. To see what's in it, it would call `list_pile`. This lets you build complex game logic directly through your agent.

If you're starting a new game, use `shuffle_new_deck` to create a fresh, shuffled deck in one step. If you need to reshuffle mid-game, use `reshuffle_deck` on the existing deck ID.

The server processes deck IDs, card codes like 'AS' for Ace of Spades, and pile names. Your connection is secured through the Vinkius endpoint token, and all operations run in an ephemeral sandbox. The OpenAI Agents SDK adds another layer with its pre-execution guardrails and full tracing.

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