← All guides
On this page
  1. Home
  2. Guides
  3. How can a poker AI agent use MCP?
Guide Build a product · 02/03 AI agents 12 min Intermediate

How can a poker AI agent use MCP?

An AI agent can use the official Pokerai MCP server only for a controlled training scenario or a hand that has already ended. The agent discovers the server's exposed tools at runtime, validates the returned data, and leaves interpretation and high-impact decisions to a human.

Updated Maintained by Pokerai API

Direct answer: configure the official MCP server with a Pokerai API key, let the MCP client discover its available tools, and call only a tool whose returned schema matches a completed-hand or training task. Pokerai API supplies verifiable cards, equity, strategy, and other tool facts; an LLM may explain or orchestrate them, never replace the solver. Treat every result as source data for a human-reviewed explanation, never as live real-money advice.

Quick facts

Official MCP servergithub.com/pokerai-bet/mcp and package @pokerai/mcp
AuthenticationThe MCP server uses a Pokerai API key; keep it in the server environment, not in prompts or browser code.
Tool contractDiscover tool names and input schemas from the running official server. This guide does not assume an unpublished tool name or registry listing.
GroundingUse the API-backed structured result for verifiable cards, equity, strategy, and other documented facts; LLM prose is explanation or orchestration, not solver output.
Allowed useTraining, coaching, hand review, study, and research.
Not allowedReal-time assistance at real-money tables is prohibited.

Tool-calling flow

Keep the agent loop small and inspectable. MCP transports the tool request; Pokerai API remains the source for the tool's API-backed result.

  1. Connect — Start the official MCP server using its README and provide the API key through server-side configuration.
  2. Discover — Ask the MCP client for the server's current tool list and schemas. Do not infer a tool name from this page, a model's memory, or an unverified registry entry.
  3. Validate — Confirm the request comes from a controlled training scenario or a completed hand and is a permitted offline training, review, study, coaching, or research task; normalize the supplied poker inputs against the discovered schema.
  4. Call — Call one discovered tool with the minimum required arguments, then retain the raw structured result and request metadata in the application's audit trail.
  5. Review — Have a human review the agent's explanation, uncertainty, and use of mixed frequencies before presenting high-impact educational or product output.

Minimal verifiable agent loop

This is protocol-level pseudocode, not a claimed tool name. It is verifiable because the agent first reads the running server's actual tool list and schema before it makes a call.

tools = mcp.list_tools()
selected = choose_tool(tools, task="offline preflop study")
assert selected.name in {tool.name for tool in tools}
assert selected.schema validates request

result = mcp.call_tool(
  name=selected.name,
  arguments=request
)

human_review(result.structured_content)
write_study_note(result.structured_content)

For a concrete request and response shape, use the discovered tool schema together with the official OpenAPI snapshot. If the server does not expose a suitable tool, do not substitute a guessed HTTP call or fabricate a tool result.

Human review and no-RTA boundary

A language model can summarize data incorrectly or overstate confidence. Require human review for study notes, coaching material, and high-impact product output; show mixed frequencies as distributions rather than a single recommended move. Pokerai API must not be used for real-time assistance at real-money tables. Do not connect the agent to a live hand feed, automate actions, or present its output as a decision to take during play.

Data boundaries

  • Send only the poker inputs needed for the selected study task. Avoid API keys, account details, and unrelated personal data in prompts or tool arguments.
  • Pokerai API requests are stateless; do not turn hand content into marketing attribution data or retain it longer than the application's review workflow requires.
  • Keep the API key and raw tool response in trusted server-side systems. Redact secrets and user identifiers from agent traces, support tickets, and shared examples.
  • Use the documented API contract as the authority for input and response semantics; the agent's prose is an explanation, not a replacement for the source data.

Official implementation links