← Tous les guides
Sur cette page
Guide Stratégie GTO · 02/08 Applications de solveur 15 min Intermédiaire

Créer une analyse de poker à faible latence avec les données précalculées et le solveur en temps réel de PokerAI

Récupérez la stratégie précalculée du flop auprès de PokerAI et affichez les fréquences d’action dès réception. Une vraie main de 200NL en pot 3-bet montre comment trouver une situation, changer d’action ou de board et transmettre les deux ranges au solveur en temps réel pour la turn et la river.

Mis à jour Maintenu par Pokerai API

À l’ouverture de la main, récupérez la stratégie du nœud courant avec /flop/tree et /flop/node. Affichez les fréquences dès réception. Quand l’utilisateur choisit une nouvelle carte, projetez les deux ranges en suivant les actions et soumettez un calcul pour cette street. La stratégie précédente reste consultable pendant le calcul.

Quand combiner données précalculées et solveur en temps réel

Si le catalogue du cache ne contient pas la main ou si vous souhaitez choisir les ranges ou tailles de mise ultérieurs, affichez d’abord le flop précalculé et résolvez séparément les streets suivantes. Ce flux est accessible avec Free, Starter, Builder et Pro, selon les quotas de consultation précalculée et de calcul de chaque offre. La situation du flop doit être disponible dans la bibliothèque.

Projetez les deux ranges selon les actions réelles, puis résolvez séparément la turn et la river à partir de ces ranges. Vous obtenez une approximation street par street de l’équilibre de Nash de l’arbre complet. Les stratégies suivantes dépendent des ranges, des tapis, des tailles disponibles et des résultats. Affichez le flop en premier, puis chaque stratégie dès que son calcul revient.

Faits clés sur la main de 200NL en pot 3-bet

La main utilise le pack préflop 6max_RC_100bb_200NL. MP (position intermédiaire) ouvre et SB (petite blinde) 3-bet. SB détient A♥K♥ sur 4♣8♦9♥. Le flop commence avec un pot de 19 BB et un tapis effectif de 91 BB.

Ligne de mises et de calls sur trois streets
Street et boardActionÉtape suivante
Flop4♣ 8♦ 9♥SB mise 13 BB
MP paie
A♠ sort
TurnA♠SB mise 14 BB
MP paie
7♦ sort
River7♦SB mise 22 BB
MP paie
Abattage
Figure 1. Chaque mise est payée et la main atteint l’abattage.

SB mise 13, 14 et 22 BB sur les trois streets et MP paie à chaque fois. C’est la même main que dans le guide de la Cache API. L’exemple du solveur en temps réel traite SB comme OOP et MP comme IP.

Trouver une situation disponible

Envoyez le pack préflop, le flop et la situation à /availability pour vérifier si la main figure dans la bibliothèque précalculée. La vérification est gratuite pour toute clé API valide.

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"}}}'

Vérifiez status: "available", match: "exact" et resolved_preflop_pack avant de poursuivre. Les endpoints existants du flop peuvent basculer sur le pack par défaut si le pack demandé ne contient pas la situation. Pour reproduire la main, vérifiez le pack retenu avant de changer de source.

Lire la stratégie du flop

Appelez /flop/tree depuis votre serveur et conservez-y la clé API. Utilisez le jeton du nœud racine dans /flop/node avec hole_cards: "AhKh" pour lire la stratégie de A♥K♥.

Flux de requêtes, données précalculées et solveur en temps réel
  1. 1. Trouver une situation disponible/availabilityVérification gratuite de la couverture
  2. 2. Lire et afficher la stratégie/flop/tree et /flop/nodeUn arbre consomme une consultation précalculée. La lecture des nœuds est gratuite.
  3. 3. Projeter les ranges et calculer/flop/projected-range、/turn/projected-range et /solverSoumettre séparément la turn et la river
Figure 2. Affichez d’abord le flop, puis résolvez les deux streets suivantes selon les actions et cartes choisies.

La requête ci-dessous lit le nœud racine du flop et consomme une consultation précalculée. Les fonctions post et waitForTree figurent dans l’exemple complet.

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

Affichez strategy sous forme de fréquences et conservez les jetons de nœuds renvoyés pour les prochaines lectures. Le champ de réponse node: "root" peut servir de libellé du chemin. Dans les requêtes suivantes, envoyez le jeton correspondant dans node.

Si vous disposez de la matrice de stratégie du range entier, sélectionnez la ligne correspondante quand la main change. Relisez la stratégie quand le nœud d’action change.

Suivre les actions jusqu’à la turn et la river

Au flop, SB mise 13 BB et MP paie. La turn est A♠. SB mise 14 BB, MP paie à nouveau et la river est 7♦. Incluez le dernier call de chaque street dans la projection pour que les ranges reflètent les mains avec lesquelles l’adversaire paie.

Pot et tapis transmis à la street suivante
Street et boardPot au début de la streetTapis effectif
Flop4♣ 8♦ 9♥19 BB91 BB
TurnA♠45 BB78 BB
River7♦73 BB64 BB
Figure 3. Après une mise payée, le pot augmente de deux mises et le tapis effectif baisse d’une. Le tableau reprend la ligne d’origine. L’exemple utilise les tailles renvoyées.

Projeter les deux ranges après le call au flop

Avec /flop/node, vérifiez que le nœud adverse offre l’option de payer après la mise. Envoyez la situation d’origine et le chemin terminé par /CALL à /flop/projected-range. Cet endpoint lit les ranges effectifs de l’arbre précalculé et calcule ceux qui restent après l’action.

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

Récupérez les combinaisons pondérées dans range_oop_new_raw et range_ip_new_raw. La projection utilise le board de la street précédente. Avant de soumettre le calcul, retirez les combinaisons bloquées par la nouvelle carte et préservez les autres avec leurs poids. AhKh ne sert qu’à l’affichage. La projection et le calcul utilisent les deux ranges complets. Si vous appelez /v1/gto/range et montez votre arbre, partez de ranges.effective dans l’arbre du flop.

Soumettre la turn après l’arrivée de A♠

Envoyez à /solver le board de quatre cartes 4c8d9hAs, les deux ranges sans les combinaisons bloquées par A♠, le pot et le tapis effectif. Le paramètre public de taille exprime des pourcentages entiers du pot. Lors de la mesure, 31 a produit une mise de 14 BB dans un pot de 45 BB. Poursuivez avec la taille renvoyée.

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.");

Soumettre la river après le call à la turn

Appelez /turn/projected-range avec l’identifiant du calcul de la turn et le chemin d’action correspondant. Les arbres du solveur renvoient des chemins comme root/BET 14.000000. Ajoutez /CALL au chemin reçu. Retirez de chaque range les combinaisons contenant 7♦ et soumettez un nouveau calcul sur 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 });

La mise d’origine à la river était de 22 BB. Les tailles de l’exemple ont produit cette branche lors de la mesure. Affichez le montant et les fréquences renvoyés par le solveur. Après le call qui mène à l’abattage, vous pouvez libérer les ressources avec /solver/release dès la dernière lecture terminée.

Garder la stratégie visible pendant un calcul

Affichez ensemble la stratégie et l’état du calcul. Quand l’utilisateur sélectionne la turn ou la river, gardez la stratégie précédente visible pendant le calcul courant. Interrogez /solver/tree avec l’identifiant d’origine jusqu’à spot_status: "queryable", puis envoyez le jeton de nœud reçu à /solver/node.

Après 429 busy, laissez l’utilisateur choisir quand réessayer. Arrêtez l’attente à no_nodes, error ou expired. Si la soumission expire et que le résultat est inconnu, conservez l’affichage pour éviter un second envoi facturé. Quand l’action ou le board change, ignorez les réponses tardives de la sélection précédente grâce au contexte de la requête.

Durée des requêtes et quotas

Les 0,077479 s du flop comprennent la lecture de l’arbre précalculé et du nœud. Les 2,258036 s de la turn partent de la soumission corrigée. La projection précédente des ranges du flop a pris 0,079021 s, mesurées à part. Les 2,190538 s de la river partent de la projection des ranges de la turn et incluent la soumission, les interrogations et la lecture du nœud. Les barres du cache représentent des lectures de stratégie individuelles pour la même main.

Durée des lectures de stratégie sur trois streets Même main de 200NL en pot 3-bet · échelle commune (secondes)
ParcoursDuréeSérie
Flop4♣ 8♦ 9♥
Stratégie en cache4,425 sA
Endpoints existants0,077 sD
TurnA♠
Stratégie en cache1,348 sB
Endpoints existants2,258 sE
River7♦
Stratégie en cache1,319 sC
Endpoints existants2,191 sE
Mesures du cache · 18 novembre, heure de Hong Kong A Racine du flop, 13:37–13:38 B Carte de turn, 17:44–17:45 C Carte de river, 20:52 Mesures avec les endpoints existants · 19 novembre, heure de Hong Kong D Lecture du flop précalculé, 09:51 E Calculs en temps réel de la turn et de la river, 09:53
Figure 4. Les barres bleues montrent des lectures individuelles de stratégie issues de la mesure du cache sur la même main. Les barres orange correspondent aux endpoints existants. Le texte indique le départ de chaque mesure. Les deux parcours ont été mesurés séparément.
Opération API Quota consommé
Vérifier la situation avec /availability 0
Lire un arbre précalculé avec /flop/tree 1 consultation précalculée
Lire un nœud ordinaire du flop ou du solveur avec un jeton valide 0
Projeter les ranges du flop avec /flop/projected-range 1 consultation précalculée
Démarrer un nouveau calcul de turn ou river avec /solver 1 calcul par nouveau lancement
Interroger /solver/tree, projeter les ranges de turn ou libérer le calcul 0

L’exemple utilise deux consultations précalculées et jusqu’à deux calculs sur les trois streets. Si un calcul identique est renvoyé directement, vérifiez la consommation dans solve_quota. Les lectures de nœuds ordinaires et les interrogations réutilisent le jeton ou l’identifiant d’origine.

Exécuter l’exemple complet

Conservez ensemble les positions, les cartes privatives, le board et le chemin d’action. Affichez la stratégie du flop dès réception et gérez séparément les chargements et les erreurs de la turn et de la river. Réutilisez une soumission en cours quand le board, les ranges, le pot, le tapis effectif et les tailles coïncident.

Placez les fonctions ci-dessous avant les quatre blocs JavaScript précédents et exécutez le tout comme module ES de Node.js. Une exécution contre l’API de production consomme le quota du compte.

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

Mesures et reproduction

La main et le chemin d’action proviennent d’une capture de la Cache API en production du 18 novembre 2026. Les requêtes HTTPS publiques aux endpoints existants du 19 novembre ont confirmé le même pack, la même main et les trois mises suivies d’un call à 13, 14 et 22 BB. Les deux soumissions ont lancé de nouveaux calculs. L’essai a consommé deux consultations précalculées et deux calculs.

Le premier envoi de la turn a renvoyé invalid_range sans consommer de calcul. Les ranges de la street précédente contenaient encore A♠. Après exclusion des combinaisons bloquées, le chemin d’origine a pu être calculé. Le graphique distingue les séries de collecte. Les cartes publiques et les actions restent identiques pendant la projection et le filtrage.

Pour citer les mesures, indiquez le pack, le board, le chemin d’action, la date et la méthode de chronométrage. Le guide s’adresse à l’entraînement, à la recherche et à la revue après la session. L’analyse en temps réel désigne ici l’exploration interactive de situations dans un outil. L’assistance en temps réel est interdite aux tables en argent réel.

Documentation API · Référence API · Flux du solveur en temps réel · OpenAPI · llms.txt

Avec Builder ou Pro et une situation entièrement mise en cache, vous pouvez lire la stratégie du même arbre précalculé à mesure que les actions et le board changent. Le guide complémentaire reprend la même main de 200NL en pot 3-bet, de la recherche gratuite de couverture à la stratégie sur trois streets et à l’EV et l’équité à la demande. Créer un produit d’analyse de poker en temps réel et à faible latence avec la Cache API de PokerAI