← 全部指南
本页内容
指南 GTO 策略 · 02/08 求解器应用 15 分钟 中级

用 PokerAI 预解数据与实时 Solver 打造低延迟扑克分析产品

用 PokerAI 读取预解的 Flop 策略,在查询完成后立即显示动作频率。本文用一手真实的 200NL 3-bet 演示完整接入过程,包括筛选场景、切换动作和牌面,以及把双方范围带入 Turn 和 River 的实时求解。

更新于 维护者 Pokerai API

打开一手牌时,先用 /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 跟注
摊牌
图 1:每街下注后跟注,最后走到摊牌。

沿图中的路径查询,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♥ 的策略。

预解与实时 Solver 接入顺序
  1. 1. 查找可用场景/availability免费核对预解场景
  2. 2. 读取并展示策略/flop/tree 和 /flop/node读取一次树扣 1 次 presolved,节点续查免费
  3. 3. 转换范围并求解/flop/projected-range、/turn/projected-range 和 /solver为 Turn 和 River 分别提交求解
图 2:先展示 Flop 策略,再沿用户选定的行动和牌面求解后两街。

下方请求读取 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 BB91 BB
TurnA♠45 BB78 BB
River7♦73 BB64 BB
图 3:每次下注并跟注,底池增加两份下注,有效筹码减去一份。表中金额按原线路计算,实时 Solver 示例按实际返回的下注额计算。

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 数据是同一手牌的单次策略读取实测。

三街策略请求耗时 同一手 200NL 3-bet · 统一刻度(秒)
路径耗时轮次
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
Cache 实测 · 11 月 18 日香港时间 A Flop 根节点,13:37–13:38 B Turn 发牌,17:44–17:45 C River 发牌,20:52 旧端点实测 · 11 月 19 日香港时间 D Flop 预解读取,09:51 E Turn、River 实时求解,09:53
图 4:蓝色条取自同一手牌的 Cache 实测,记录单次策略请求。橙色条为旧端点,各街的计时起点见上文。两种路径在不同轮次采集。
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 打造低延迟实时扑克分析产品