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.
/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.
| Street et board | Action | É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 |
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♥.
- 1. Trouver une situation disponible
/availabilityVérification gratuite de la couverture - 2. Lire et afficher la stratégie
/flop/treeet/flop/nodeUn arbre consomme une consultation précalculée. La lecture des nœuds est gratuite. - 3. Projeter les ranges et calculer
/flop/projected-range、/turn/projected-rangeet/solverSoumettre séparément la turn et la river
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.
| Street et board | Pot au début de la street | Tapis effectif |
|---|---|---|
| Flop4♣ 8♦ 9♥ | 19 BB | 91 BB |
| TurnA♠ | 45 BB | 78 BB |
| River7♦ | 73 BB | 64 BB |
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.
| Parcours | Durée | Série | |
|---|---|---|---|
| Flop4♣ 8♦ 9♥ | |||
| Stratégie en cache | 4,425 s | A | |
| Endpoints existants | 0,077 s | D | |
| TurnA♠ | |||
| Stratégie en cache | 1,348 s | B | |
| Endpoints existants | 2,258 s | E | |
| River7♦ | |||
| Stratégie en cache | 1,319 s | C | |
| Endpoints existants | 2,191 s | E | |
| 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
Lire directement les trois streets si la situation est entièrement en cache
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