用 PokerAI 预解数据与实时 Solver 打造低延迟扑克分析产品
用 PokerAI 读取预解的 Flop 策略,在查询完成后立即显示动作频率。本文用一手真实的 200NL 3-bet 演示完整接入过程,包括筛选场景、切换动作和牌面,以及把双方范围带入 Turn 和 River 的实时求解。
/flop/tree 和 /flop/node 读取当前节点的策略。响应返回后即可显示各动作的频率。用户选定下一张牌时,再沿行动路径更新双方范围,提交该街的 Solver。计算期间,之前的策略仍可查看。什么时候用预解加实时 Solver?
如果 Cache 目录没有这手牌的结果,或者你想自选后两街的范围和下注尺寸,可以先用预解策略展示 Flop,再逐街求解。这条路径对 Free、Starter、Builder 和 Pro 均开放,按各套餐的 presolved 和 solve 额度使用。示例仍需要有可读取的 Flop 预解场景。
先按实际动作转换双方范围,再用转换结果独立求解 Turn 和 River。这样得到的是对完整三街树纳什均衡的一种逐街近似。后续策略取决于传入的范围、筹码、可用尺寸和求解结果。页面可以先展示 Flop,后两街待各自求解返回。
200NL 3-bet 牌局的核心事实
本例使用翻前策略包 6max_RC_100bb_200NL。MP(中间位)开池,SB(小盲)3-bet。SB 持 A♥K♥,Flop 为 4♣8♦9♥。进入翻牌时,底池为 19 BB,剩余有效筹码为 91 BB。
| 街与牌面 | 动作 | 下一步 |
|---|---|---|
| Flop4♣ 8♦ 9♥ | SB 下注 13 BB MP 跟注 | 发 A♠ |
| TurnA♠ | SB 下注 14 BB MP 跟注 | 发 7♦ |
| River7♦ | SB 下注 22 BB MP 跟注 | 摊牌 |
沿图中的路径查询,SB 在三条街分别下注 13、14、22 BB,MP 每次跟注。这条线路沿用 Cache API 实战 中的示例牌局。下面用 SB 作为 OOP、MP 作为 IP,演示如何将这条路径交给实时 Solver。
查找已覆盖的场景
向 /availability 传入翻前策略包、翻牌和场景,确认预解库能否读取这手牌。任何有效 API key 均可免费查询。
curl 'https://pokerai.bet/v1/gto/availability' \
-H "Authorization: Bearer $POKERAI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{"type":"flop","request":{"preflop_pack":"6max_RC_100bb_200NL","board":"4c8d9h","pot_type":"3BET","positions":{"raiser":"MP","three_bettor":"SB","hero":"SB"}}}'
继续接入前,检查 status: "available"、match: "exact" 以及 resolved_preflop_pack。旧 Flop 端点在指定包缺少场景时可能回退到默认包。如果需要复现同一牌局,先核对解析结果,再决定是否让用户切换数据来源。
读取 Flop 策略
用 /flop/tree 打开 Flop 决策树。由你的后端发起请求并保管 API key。拿到根节点的 token 后,向 /flop/node 传入 hole_cards: "AhKh",读取 A♥K♥ 的策略。
- 1. 查找可用场景
/availability免费核对预解场景 - 2. 读取并展示策略
/flop/tree和/flop/node读取一次树扣 1 次 presolved,节点续查免费 - 3. 转换范围并求解
/flop/projected-range、/turn/projected-range和/solver为 Turn 和 River 分别提交求解
下方请求读取 Flop 根节点并消耗 1 次 presolved 额度。示例中的 post 和 waitForTree 等函数见完整代码。
const spot = {
preflop_pack: "6max_RC_100bb_200NL",
board: "4c8d9h",
pot_type: "3BET",
positions: { hero: "SB", raiser: "MP", three_bettor: "SB" },
};
const hand = "AhKh";
const available = await post("/availability", { type: "flop", request: spot });
if (available.status !== "available" || available.match !== "exact" ||
available.resolved_preflop_pack !== spot.preflop_pack) {
throw new Error("This exact presolved Flop spot is not available.");
}
const flop = await post("/flop/tree", { ...spot, hole_cards: hand });
const root = flop.nodes.find((entry) => entry.node === "root" && entry.is_hero);
if (!root?.token) throw new Error("The expected SB root is unavailable.");
const flopStrategy = await post("/flop/node", {
node: root.token,
hole_cards: hand,
});
把响应中的 strategy 渲染成动作频率,并保留树中返回的节点 token 供后续查询。响应里的 node: "root" 可作为路径标签。续查时,请求体的 node 接收对应的 token。
如果你已读取整个范围的策略矩阵,切换手牌时可以直接取对应行。切换到新的动作节点时,再发起一次读取。
沿动作查询 Turn 和 River
Flop 上,SB 下注 13 BB,MP 跟注。对手跟注后,Turn 发出 A♠。沿同一条线路,SB 再下注 14 BB,MP 再次跟注,River 发出 7♦。转换范围时要包含每街的最后一次跟注,否则会漏掉对手选择跟注时对范围的筛选。
| 街与牌面 | 进入该街的底池 | 有效筹码 |
|---|---|---|
| Flop4♣ 8♦ 9♥ | 19 BB | 91 BB |
| TurnA♠ | 45 BB | 78 BB |
| River7♦ | 73 BB | 64 BB |
Flop 跟注后,转换双方范围
先用 /flop/node 确认下注后的对手节点包含跟注,然后向 /flop/projected-range 传入原场景及含 /CALL 的动作路径。这个端点从预解树读取有效范围并计算双方在行动后剩余的范围。
const action = flopStrategy.strategy.find((row) => row.action === "bet" &&
!row.allin && row.amount_bb === 13);
const afterBet = flop.nodes.find((entry) => entry.node === "root/BET_13" &&
!entry.is_hero);
if (!action || !afterBet?.token) throw new Error("The 13 BB Flop branch is unavailable.");
const opponent = await post("/flop/node", { node: afterBet.token });
if (!opponent.actions?.some((row) => row.action === "call")) {
throw new Error("The Flop call branch is unavailable.");
}
const turnRanges = await post("/flop/projected-range", {
...spot,
node_id: afterBet.node + "/CALL",
normalize: false,
bluff_discount_ratio: 1,
});
用 range_oop_new_raw 和 range_ip_new_raw 取得双方带权重的手牌组合。范围转换按上一街的公牌计算,提交 Solver 前须删除与新公牌冲突的组合,其余组合和权重原样传入。此例只在显示策略时指定 AhKh,求解和范围转换沿用双方整份范围。若直接调用 /v1/gto/range 并自行组装决策树,起始范围取 Flop 树的 ranges.effective。
A♠ 发出后,提交 Turn
向 /solver 传入四张牌 4c8d9hAs、过滤掉 A♠ 后的双方范围,以及牌局底池和有效筹码。Solver 的公开下注尺寸参数使用整数底池百分比。实测中,31 在 45 BB 底池中返回了 14 BB 的下注分支。使用返回的实际尺寸继续查询。
if (!turnRanges.range_oop_new_raw || !turnRanges.range_ip_new_raw) {
throw new Error("Turn ranges are unavailable.");
}
const turnBoard = ["4c", "8d", "9h", "As"];
const turn = await post("/solver", {
board: turnBoard.join(""),
oop_range: rangeForBoard(turnRanges.range_oop_new_raw, turnBoard),
ip_range: rangeForBoard(turnRanges.range_ip_new_raw, turnBoard),
pot: flop.pot + 2 * action.amount_bb,
effective_stack: flop.effective_stack - action.amount_bb,
hero: "OOP",
bet_sizes: { turn: [31] },
donk_sizes: { turn: [31] },
});
const turnTree = await waitForTree(turn.solve);
const turnRoot = turnTree.nodes.find((entry) => entry.node === "root" && entry.is_hero);
if (!turnRoot?.token) throw new Error("The expected Turn root is unavailable.");
const turnStrategy = await post("/solver/node", {
node: turnRoot.token,
hole_cards: hand,
});
if (!Array.isArray(turnStrategy.strategy)) throw new Error("Turn strategy is unavailable.");
Turn 跟注后,提交 River
Turn 查询用 /turn/projected-range、Turn 的 solve handle 和对应行动路径。实时树使用 root/BET 14.000000 一类格式,取实际返回的路径再拼接末尾的 /CALL。转换完成后,从双方范围中去掉含 7♦ 的组合,用五张牌 4c8d9hAs7d 提交 River 的新 solve。
const selected = await selectBetCall(turnTree, turnStrategy, 14);
const riverRanges = await post("/turn/projected-range", {
solve: turn.solve,
node_id: selected.entry.node + "/CALL",
normalize: false,
bluff_discount_ratio: 1,
});
if (!riverRanges.range_oop_new_raw || !riverRanges.range_ip_new_raw) {
throw new Error("River ranges are not ready.");
}
const riverBoard = [...turnBoard, "7d"];
const river = await post("/solver", {
board: riverBoard.join(""),
oop_range: rangeForBoard(riverRanges.range_oop_new_raw, riverBoard),
ip_range: rangeForBoard(riverRanges.range_ip_new_raw, riverBoard),
pot: Number((turnTree.pot + 2 * selected.bb).toFixed(2)),
effective_stack: Number((turnTree.effective_stack - selected.bb).toFixed(2)),
hero: "OOP",
bet_sizes: { river: [30] },
donk_sizes: { river: [30] },
});
const riverTree = await waitForTree(river.solve);
const riverRoot = riverTree.nodes.find((entry) => entry.node === "root" && entry.is_hero);
if (!riverRoot?.token) throw new Error("The expected River root is unavailable.");
const riverStrategy = await post("/solver/node", {
node: riverRoot.token,
hole_cards: hand,
});
if (!Array.isArray(riverStrategy.strategy)) throw new Error("River strategy is unavailable.");
const showDown = await selectBetCall(riverTree, riverStrategy, 22);
console.log({ turn: selected.bb, river: showDown.bb });
原线路的 River 下注是 22 BB,实测中上例的尺寸配置返回了这条分支。界面显示 Solver 返回的实际金额和频率。沿跟注进入摊牌后,可在最后一次读取完成时用 /solver/release 归还资源。
求解期间继续展示策略
把策略和求解状态放在同一处。用户选择 Turn 或 River 后,保留上一街已取得的策略,同时显示当前街正在计算。用原 solve handle 轮询 /solver/tree,等到 spot_status: "queryable",再用返回的节点 token 调用 /solver/node。
提交遇到 429 busy 时,由用户选择何时再试。遇到 no_nodes、error 或 expired 时,结束当前等待。若提交超时、结果未知,保留原界面状态,避免自动触发第二次付费提交。用户改选动作或牌面时,按请求上下文忽略迟到的旧响应。
请求耗时与额度
Flop 的 0.077 秒包含预解树和节点读取。Turn 的 2.258 秒从修正输入、提交 Solver 开始计,首次 Flop 范围转换另计 0.079 秒。River 的 2.191 秒从转换 Turn 范围开始,包含提交、轮询和节点读取。图中的 Cache 数据是同一手牌的单次策略读取实测。
| 路径 | 耗时 | 轮次 | |
|---|---|---|---|
| Flop4♣ 8♦ 9♥ | |||
| Cache 策略 | 4.425 秒 | A | |
| 旧端点策略 | 0.077 秒 | D | |
| TurnA♠ | |||
| Cache 策略 | 1.348 秒 | B | |
| 旧端点策略 | 2.258 秒 | E | |
| River7♦ | |||
| Cache 策略 | 1.319 秒 | C | |
| 旧端点策略 | 2.191 秒 | E | |
| API 操作 | 扣减额度 |
|---|---|
用 /availability 核对场景 |
0 |
通过 /flop/tree 读取一棵预解树 |
1 次 presolved |
| 用有效 token 续查普通 Flop 或 Solver 节点 | 0 |
用 /flop/projected-range 更新 Flop 双方范围 |
1 次 presolved |
通过 /solver 启动新的 Turn 或 River 求解 |
1 次 solve/新计算 |
轮询 /solver/tree、转换 Turn 范围或释放 solve |
0 |
按示例走完三街需 2 次 presolved,最多再用 2 次 solve 额度。 若已有完全匹配的 solve 并直接返回,请以实际 solve_quota 回执核对。普通节点展示和轮询复用原 token 或 handle。
运行完整接入示例
接入页面时,保留位置、手牌、公牌和动作路径。Flop 策略加载完成后即可显示,Turn 和 River 各自处理加载和错误状态。相同的牌面、范围、底池、有效筹码和尺寸配置,优先复用同一次在途提交。
将下面的辅助函数放在前面四段 JavaScript 代码之前,在 Node.js ES 模块中运行。向生产 API 运行示例会使用账号额度。
const API = "https://pokerai.bet/v1/gto";
const key = process.env.POKERAI_API_KEY;
if (!key) throw new Error("Set POKERAI_API_KEY on your backend.");
async function post(path, body, timeoutMs = 15_000) {
const response = await fetch(API + path, {
method: "POST",
headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
body: JSON.stringify(body),
signal: AbortSignal.timeout(timeoutMs),
});
const payload = await response.json();
if (!response.ok) throw new Error(`${path}: HTTP ${response.status} (${payload.error ?? payload.status ?? "unknown"})`);
return payload;
}
function rangeForBoard(range, board) {
const blocked = new Set(board);
const combos = range.split(",").map((item) => item.trim()).filter((item) => {
const match = /^([2-9TJQKA][cdhs])([2-9TJQKA][cdhs]):([0-9.]+(?:e[+-]?\d+)?)$/i.exec(item);
if (!match || !Number.isFinite(Number(match[3]))) {
throw new Error("Invalid weighted combo in the projected range.");
}
const canonical = (card) => card[0].toUpperCase() + card[1].toLowerCase();
const first = canonical(match[1]);
const second = canonical(match[2]);
if (first === second) throw new Error("Duplicate card in a projected combo.");
return !blocked.has(first) && !blocked.has(second);
});
if (!combos.length) throw new Error("No legal combinations for the next board.");
return combos.join(",");
}
async function selectBetCall(tree, strategy, targetBb) {
const bets = tree.nodes.flatMap((entry) => {
const match = /^root\/BET (\d+(?:\.\d+)?)$/.exec(entry.node);
return match && !entry.is_hero && entry.token ? [{ entry, bb: Number(match[1]) }] : [];
});
const selected = bets.sort((a, b) => Math.abs(a.bb - targetBb) - Math.abs(b.bb - targetBb))[0];
if (!selected || Math.abs(selected.bb - targetBb) > 0.5 ||
!strategy.strategy.some((row) => row.action === "bet" && !row.allin &&
Math.abs(row.amount_bb - selected.bb) < 0.02)) {
throw new Error(`No supported bet sizing close to ${targetBb} BB.`);
}
const opponent = await post("/solver/node", { node: selected.entry.token });
if (!opponent.actions?.some((row) => row.action === "call")) {
throw new Error("The call branch is unavailable.");
}
return selected;
}
async function waitForTree(solve, deadlineMs = 90_000) {
if (typeof solve !== "string" || !solve) throw new Error("Missing solve handle.");
const deadline = Date.now() + deadlineMs;
while (Date.now() < deadline) {
const tree = await post("/solver/tree", { solve }, Math.min(10_000, deadline - Date.now()));
if (tree.spot_status === "queryable") return tree;
if (!["available", "computing"].includes(tree.spot_status)) {
throw new Error(`Solve stopped: ${tree.spot_status ?? "missing status"}`);
}
const delay = Math.min(1_000, deadline - Date.now());
if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
}
throw new Error("Solve polling timed out. Keep the original handle.");
}
实测数据与复现记录
牌局和原始行动路径来自 2026 年 11 月 18 日的 Cache API 生产采集。11 月 19 日用公开 HTTPS 实测了旧端点,确认相同预解包、同一手牌和 13/14/22 BB 三次下注跟注。两个 Solver 都启动了新计算。本次消耗 2 次 presolved 和 2 次 solve 额度。
首次 Turn 提交返回 invalid_range,求解额度未扣。核对后确认,上一街的范围仍包含 A♠。按示例过滤新公牌的冲突组合后,沿原路线完成求解。图表分别标注采集轮次,范围转换前后保留相同的公开牌面和行动条件。
引用时请附上策略包、牌面、动作路径、日期和计时口径。本文面向训练、研究和赛后复盘。这里的“实时分析”指用户在工具中连续探索场景的交互体验,不用于进行中的真人牌局辅助。禁止在真实资金牌桌上提供实时辅助。
API 文档 · API 参考 · 实时 Solver 工作流 · OpenAPI · llms.txt
有完整缓存时,直接读取三街策略
如果你使用 Builder 或 Pro,并且目标场景已有完整缓存,可以沿行动和牌面直接读取同一棵预解树的策略。配套 Guide 用同一手 200NL 3-bet 演示如何查免费覆盖目录、浏览三街策略,以及按需读取 EV 和 EQ。用 PokerAI Cache API 打造低延迟实时扑克分析产品