← 모든 가이드
이 페이지에서
가이드 GTO 전략 · 02/08 솔버 앱 15 분 중급

PokerAI 사전 계산 데이터와 실시간 솔버로 만드는 저지연 포커 분석

PokerAI에서 사전 계산된 플랍 전략을 읽고 응답이 도착하면 액션 빈도를 표시합니다. 실제 200NL 3벳 핸드로 스팟을 찾고 액션과 보드를 바꾼 다음 두 플레이어의 레인지를 턴과 리버 실시간 계산에 넘기는 과정을 설명합니다.

업데이트됨 관리 주체 Pokerai API

핸드를 열 때 /flop/tree와 /flop/node로 현재 노드의 전략을 읽습니다. 응답이 오면 액션 빈도를 표시합니다. 사용자가 다음 카드를 선택하면 액션 경로에 따라 두 레인지를 갱신하고 해당 스트리트 계산을 요청합니다. 계산 중에도 이전 전략을 볼 수 있습니다.

사전 계산과 실시간 솔버를 함께 쓰는 경우

캐시 디렉터리에 핸드가 없거나 이후 스트리트의 레인지나 베팅 크기를 직접 지정하려면 사전 계산된 플랍 전략을 먼저 표시하고 다음 스트리트를 각각 계산합니다. Free, Starter, Builder, Pro 모두 각 플랜의 사전 계산 조회 한도와 솔버 계산 한도 내에서 사용할 수 있습니다. 조회 가능한 플랍 스팟이 필요합니다.

실제 액션에 따라 두 레인지를 갱신한 뒤 그 레인지로 턴과 리버를 따로 계산합니다. 결과는 전체 세 스트리트 트리의 내시 균형을 스트리트별로 근사한 것입니다. 이후 전략은 입력 레인지, 스택, 사용 가능한 베팅 크기, 계산 결과에 따라 달라집니다. 플랍을 먼저 표시하고 이후 전략은 각각 계산이 끝나면 표시합니다.

200NL 3벳 핸드의 핵심 정보

프리플랍 팩은 6max_RC_100bb_200NL입니다. MP(미들 포지션)가 오픈하고 SB(스몰 블라인드)가 3벳합니다. SB의 핸드는 A♥K♥, 플랍은 **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입니다.

조회 가능한 스팟 찾기

/availability에 프리플랍 팩, 플랍과 상황을 전달해 사전 계산 라이브러리에서 핸드를 읽을 수 있는지 확인합니다. 유효한 API 키가 있으면 무료로 확인할 수 있습니다.

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/tree를 호출하고 API 키도 백엔드에 보관합니다. 루트 노드 토큰을 받은 뒤 /flop/node에 토큰과 hole_cards: "AhKh"를 보내 A♥K♥의 전략을 읽습니다.

사전 계산과 실시간 솔버 요청 순서
  1. 1. 조회 가능한 스팟 찾기/availability사전 계산 커버리지 무료 확인
  2. 2. 전략 읽고 표시하기/flop/tree 및 /flop/node트리 조회는 사전 계산 1회. 노드 조회는 무료.
  3. 3. 레인지 갱신 후 계산하기/flop/projected-range、/turn/projected-range 및 /solver턴과 리버를 별도로 계산 요청
그림 2. 플랍 전략을 먼저 표시하고, 사용자가 고른 액션과 카드에 따라 다음 두 스트리트를 계산합니다.

아래 요청은 플랍 루트를 읽고 사전 계산 조회 한도를 1회 사용합니다. 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를 액션 빈도로 표시하고 후속 조회를 위해 트리에서 받은 노드 토큰을 보관합니다. 응답의 node: "root"는 경로 라벨로 쓸 수 있습니다. 후속 요청의 node에는 해당 토큰을 넣습니다.

전체 레인지의 전략 행렬이 있다면 핸드를 바꿀 때 해당 행을 고릅니다. 액션 노드를 바꾸면 전략을 다시 조회합니다.

액션을 따라 턴과 리버 조회하기

플랍에서 SB가 13 BB를 베팅하고 MP가 콜하면 턴에 A♠가 나옵니다. SB가 14 BB를 베팅하고 MP가 다시 콜하면 리버에 7♦가 나옵니다. 레인지 갱신 시 각 스트리트의 마지막 콜을 포함해야 상대가 콜을 선택한 핸드만 남도록 반영할 수 있습니다.

다음 스트리트에 전달되는 팟과 스택
스트리트와 보드스트리트 진입 시 팟유효 스택
Flop4♣ 8♦ 9♥19 BB91 BB
TurnA♠45 BB78 BB
River7♦73 BB64 BB
그림 3. 베팅에 콜이 이어지면 팟은 베팅 두 개만큼 늘고 유효 스택은 하나만큼 줄어듭니다. 표는 원래 경로를 따르며, 실시간 예제는 실제 반환된 크기를 사용합니다.

플랍 콜 후 두 레인지 갱신하기

/flop/node로 베팅 이후 상대 노드에 콜이 있는지 확인한 다음 원래 스팟과 /CALL로 끝나는 경로를 /flop/projected-range에 전달합니다. 이 엔드포인트는 사전 계산 트리에서 유효 레인지를 읽고 해당 액션 이후 남은 레인지를 구합니다.

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에서 가중치가 있는 콤보를 가져옵니다. 갱신은 이전 스트리트의 보드를 기준으로 합니다. 계산을 요청하기 전에 새 보드와 충돌하는 콤보를 제거하고 나머지 조합과 가중치를 보존합니다. AhKh는 화면 표시용이며 레인지 갱신과 계산에는 양쪽의 전체 레인지를 사용합니다. /v1/gto/range를 직접 호출해 트리를 조립할 때는 플랍 트리의 ranges.effective에서 시작합니다.

A♠가 나오면 턴 계산 요청하기

/solver에 네 장의 보드 4c8d9hAs, A♠와 충돌하는 조합을 제거한 두 레인지, 팟과 유효 스택을 보냅니다. 공개 베팅 크기 매개 변수는 정수형 팟 비율입니다. 실측에서 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/projected-range에 전달합니다. 실시간 트리는 root/BET 14.000000 같은 경로를 반환합니다. 실제 받은 경로에 /CALL을 붙입니다. 양쪽 레인지에서 7♦가 들어간 조합을 제거하고 4c8d9hAs7d로 새 리버 계산을 요청합니다.

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 });

원래 리버 베팅은 22 BB이며 실측에서는 예제의 크기 설정에서 해당 분기가 반환됐습니다. 화면에 솔버가 반환한 실제 금액과 빈도를 표시합니다. 콜로 쇼다운까지 간 뒤 마지막 조회가 끝나면 /solver/release로 리소스를 반환할 수 있습니다.

계산 중에도 전략 표시하기

전략과 계산 상태를 함께 표시합니다. 사용자가 턴이나 리버를 선택하면 새 스트리트 계산 중에도 이전 전략을 유지합니다. 원래 계산 핸들로 /solver/tree를 폴링해 spot_status: "queryable"가 되면 반환된 노드 토큰으로 /solver/node를 호출합니다.

429 busy가 반환되면 사용자가 재시도 시점을 선택합니다. no_nodes, error, expired에서는 대기를 끝냅니다. 요청이 시간 초과되어 결과를 알 수 없으면 현재 화면을 유지해 한도를 소비하는 중복 요청을 피합니다. 액션이나 보드가 바뀌면 요청 맥락을 확인해 이전 선택의 늦은 응답을 무시합니다.

요청 시간과 사용 한도

플랍의 0.077479초에는 사전 계산 트리와 노드 조회가 포함됩니다. 턴의 2.258036초는 수정한 계산을 제출한 시점부터입니다. 앞선 플랍 레인지 갱신은 별도로 0.079021초가 걸렸습니다. 리버의 2.190538초는 턴 레인지 갱신부터 계산 제출, 폴링과 노드 조회까지입니다. 캐시 막대는 같은 핸드의 개별 전략 조회를 나타냅니다.

세 스트리트 전략 요청 시간 같은 200NL 3벳 핸드 · 공통 눈금(초)
경로시간회차
Flop4♣ 8♦ 9♥
캐시 전략4.425초A
기존 엔드포인트0.077초D
TurnA♠
캐시 전략1.348초B
기존 엔드포인트2.258초E
River7♦
캐시 전략1.319초C
기존 엔드포인트2.191초E
캐시 실측 · 11월 18일 홍콩 시간 A 플랍 루트, 13:37–13:38 B 턴 카드, 17:44–17:45 C 리버 카드, 20:52 기존 엔드포인트 실측 · 11월 19일 홍콩 시간 D 사전 계산 플랍 조회, 09:51 E 턴·리버 실시간 계산, 09:53
그림 4. 파란색 막대는 같은 핸드의 캐시 실측에서 개별 전략 조회를 나타냅니다. 주황색 막대는 기존 엔드포인트입니다. 각 스트리트의 시작점은 본문에서 확인하세요. 두 경로는 별도 회차에 측정했습니다.
API 작업 사용 한도
/availability로 스팟 확인 0
/flop/tree로 사전 계산 트리 한 개 조회 사전 계산 조회 1회
유효 토큰으로 일반 플랍 또는 솔버 노드 조회 0
/flop/projected-range로 양쪽 플랍 레인지 갱신 사전 계산 조회 1회
/solver로 턴 또는 리버의 새 계산 시작 새 계산당 솔버 1회
/solver/tree 폴링, 턴 레인지 갱신 또는 계산 해제 0

예제의 세 스트리트에는 사전 계산 조회 2회와 솔버 계산 최대 2회가 필요합니다. 정확히 일치하는 계산이 바로 반환되면 실제 사용량은 solve_quota 내역으로 확인합니다. 일반 노드 조회와 폴링은 원래 토큰이나 핸들을 재사용합니다.

전체 예제 실행하기

포지션, 홀 카드, 보드와 액션 경로를 함께 보관합니다. 플랍 전략을 불러오면 바로 표시하고 턴과 리버의 로딩 및 오류 상태를 별도로 처리합니다. 보드, 레인지, 팟, 유효 스택, 베팅 크기가 같다면 진행 중인 요청을 재사용합니다.

아래 보조 함수를 앞의 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 베팅과 콜을 확인했습니다. 두 솔버 요청은 모두 새 계산을 시작했습니다. 사전 계산 조회 2회와 솔버 계산 2회를 사용했습니다.

첫 턴 요청은 invalid_range를 반환했고 솔버 한도를 사용하지 않았습니다. 이전 스트리트의 레인지에 A♠가 남아 있었습니다. 예제대로 새 보드와 충돌하는 콤보를 제거한 뒤 같은 경로에서 계산을 완료했습니다. 그래프에 수집 회차를 표시했습니다. 레인지 갱신과 필터링 전후의 공개 보드와 액션 조건은 같습니다.

인용할 때 전략 팩, 보드, 액션 경로, 날짜와 측정 범위를 포함하세요. 이 가이드는 훈련, 연구, 세션 이후 복기용입니다. 여기서 실시간 분석은 도구에서 스팟을 연속해서 탐색하는 기능을 뜻합니다. 실제 돈이 걸린 테이블에서의 실시간 보조는 금지됩니다.

API 문서 · API 레퍼런스 · 실시간 솔버 워크플로 · OpenAPI · llms.txt

Builder 또는 Pro에서 스팟 전체가 캐시되어 있다면 액션과 보드를 바꾸면서 같은 사전 계산 트리에서 전략을 읽을 수 있습니다. 관련 가이드에서는 동일한 200NL 3벳 핸드의 무료 커버리지 조회, 세 스트리트 전략, 필요할 때 EV와 에퀴티를 읽는 방법을 설명합니다. PokerAI Cache API로 만드는 저지연 실시간 포커 분석 제품