Tutorial de bots de póker con PokerKit: añade evaluación real de manos

PokerKit es una de las mejoras más rápidas que puedes incorporar después de conectar tu primer bot de Open Poker. El ejemplo inicial de 47 líneas demuestra que el bucle WebSocket funciona; PokerKit añade un evaluador de manos, análisis del board y una base para simulaciones. Úsalo para decidir y conserva el protocolo WebSocket de Open Poker para competir.

Parte de: La guía completa para crear un bot de póker con IA en 2026, la guía principal sobre frameworks, lógica de decisión, equity, pruebas y dónde competir.

Conclusiones clave

• PokerKit es una biblioteca de póker escrita íntegramente en Python, con evaluación de manos, simulaciones y soporte para Texas Hold'em.
• Usa PokerKit dentro de la función de decisión, no como sustituto del cliente WebSocket de Open Poker.
• Empieza convirtiendo las cartas de Open Poker al formato compacto de PokerKit y compara después los objetos StandardHighHand.

¿Qué debería hacer PokerKit dentro de tu bot de póker?

PokerKit debe responder a una pregunta: «¿Qué fuerza tiene mi mano ahora mismo?». El servidor de Open Poker envía el estado mediante WebSocket y PokerKit evalúa las cartas en local. Su documentación registra 1.016.740,7 evaluaciones estándar de manos altas por segundo en un solo núcleo Intel i7-1255U con Python 3.11.5 (documentación de PokerKit).

Esa velocidad basta para las decisiones habituales de Open Poker, donde el bot dispone de 45 segundos antes del timeout de una acción (documentación de acciones de Open Poker). No necesitas una red neuronal para esta primera mejora. Lo importante es dejar de tratar as alto y color como si pertenecieran a la misma regla de «call si sale barato».

La división limpia es simple:

Si todavía estás escribiendo el primer bucle de eventos, empieza por Crear un bot de póker en Python. Vuelve cuando el bot pueda sentarse a una mesa sin agotar el tiempo.

¿Cómo se instala PokerKit para un bot?

Instala PokerKit con pip install pokerkit. El README actual indica que la biblioteca requiere Python 3.11 o posterior y está escrita íntegramente en Python, por lo que encaja en el mismo modelo de despliegue que un bot normal de Open Poker (PokerKit GitHub).

python -m venv .venv
. .venv/bin/activate
pip install websockets pokerkit

Mantén websockets para la conexión con Open Poker. PokerKit no inicia sesión, no entra al lobby ni envía acciones. Solo ayuda a razonar sobre las cartas después de que el servidor manda un mensaje your_turn.

El protocolo de Open Poker representa las cartas como Ah, Kd y 7c. PokerKit acepta el mismo formato compacto de rango y palo. Por tanto, puedes convertir una lista de Open Poker en una cadena de PokerKit con una sola unión:

def compact(cards):
    return "".join(cards)
 
assert compact(["Ah", "Kd"]) == "AhKd"

La documentación de PokerKit advierte que procesar cadenas repetidamente dentro de bucles intensivos tiene un coste. Para un primer bot, las cadenas son suficientes. Cuando ejecutes miles de simulaciones Monte Carlo por decisión, procesa las cartas una sola vez o utiliza una caché.

¿Cómo se evalúa una mano de Texas Hold'em?

Usa StandardHighHand.from_game(hole, board) para una partida estándar de No-Limit Texas Hold'em. Open Poker es NLHE 6-max, con ciegas 10/20 y buy-ins de 1000 a 5000 fichas (documentación de temporadas), así que la evaluación estándar de mano alta es la opción correcta.

from pokerkit import StandardHighHand
 
 
def made_hand(hole_cards, board_cards):
    """Return the best standard high hand from hole cards plus board."""
    hole = "".join(hole_cards)
    board = "".join(board_cards)
    return StandardHighHand.from_game(hole, board)
 
 
hero = made_hand(["As", "Ah"], ["Ad", "7c", "2d", "9h", "Ks"])
villain = made_hand(["Kc", "Kh"], ["Ad", "7c", "2d", "9h", "Ks"])
 
if hero > villain:
    print("hero wins")

La comparación es la parte esencial. Los objetos de mano de PokerKit admiten operadores normales, por lo que el bot puede ordenar resultados sin codificar reglas como «una pareja supera a carta alta».

No lleves esta lógica demasiado lejos al principio. En el flop todavía faltan dos cartas y la mayoría de las decisiones no dependen solo de la mano formada. Usa su fuerza para los casos evidentes y añade después una estimación de equity para proyectos y calls marginales. Ahí es donde PokerKit aporta más valor.

¿Cómo se conecta PokerKit a your_turn?

Ejecuta PokerKit dentro de la rama your_turn, después de guardar las últimas cartas privadas recibidas. El mensaje WebSocket your_turn incluye valid_actions, pot, community_cards, min_raise, max_raise y un turn_token nuevo (documentación de WebSocket).

from pokerkit import StandardHighHand
 
 
def current_hand_label(hole_cards, board_cards):
    if len(board_cards) < 3:
        return "preflop"
    hand = StandardHighHand.from_game("".join(hole_cards), "".join(board_cards))
    return str(hand)
 
 
def choose_action(msg, hole_cards):
    actions = {a["action"]: a for a in msg["valid_actions"]}
    board = msg.get("community_cards", [])
 
    # Preflop still needs ranges, not a made-hand evaluator.
    if len(board) == 0:
        if "raise" in actions and is_premium_preflop(hole_cards):
            return "raise", actions["raise"]["min"]
        if "check" in actions:
            return "check", None
        return "fold", None
 
    hand = StandardHighHand.from_game("".join(hole_cards), "".join(board))
    label = hand.entry.label.name
 
    if label in {"STRAIGHT_FLUSH", "FOUR_OF_A_KIND", "FULL_HOUSE", "FLUSH"}:
        if "raise" in actions:
            return "raise", actions["raise"]["min"]
        if "call" in actions:
            return "call", None
 
    if "check" in actions:
        return "check", None
    return "fold", None

La política es conservadora a propósito. Foldea demasiado, pero evita dejarse el stack con una pareja baja. Cuando funcione, combínala con una estrategia de apuestas para bots de póker para que las manos fuertes suban a un tamaño útil en vez de elegir siempre el mínimo.

¿Cuándo deberías añadir equity en lugar de etiquetas?

Añade equity cuando una etiqueta oculte diferencias importantes. Un proyecto de color y una pareja formada pueden ser rentables en situaciones distintas, pero un bot que solo usa etiquetas interpretará mal alguno de esos casos. PokerKit permite simular las cartas desconocidas del turn y el river en vez de adivinar.

El camino más sencillo es:

1. Construye una baraja de 52 cartas.
2. Retira las cartas del jugador y las cartas comunitarias visibles.
3. Muestrea las cartas privadas del rival y las comunitarias que faltan.
4. Compara las manos finales de PokerKit.
5. Repite entre 1000 y 10.000 veces.

Así obtienes una probabilidad estimada de ganar. Compárala después con las pot odds:

def pot_odds(pot, call_amount):
    return call_amount / (pot + call_amount)
 
 
def should_call(pot, call_amount, equity):
    return equity > pot_odds(pot, call_amount)

Open Poker ya envía el bote y el importe del call en valid_actions, por lo que no necesitas reconstruir la ronda de apuestas. Para ver una implementación completa, consulta la calculadora de equity Monte Carlo en Python.

¿Para qué no deberías usar PokerKit?

No uses PokerKit como sustituto de las pruebas en vivo. Puede decirte si una mano vence a otra, pero no si los rivales apuestan de más en el river, pagan demasiado desde la ciega grande o se descontrolan tras un farol fallido. Open Poker existe porque el self-play por sí solo no reproduce esos patrones.

Tampoco simules toda la mesa de Open Poker en local salvo que tengas un motivo concreto. El servidor es la fuente de verdad. El bot debe reaccionar a your_turn, enviar acciones legales con el turn_token actual y usar client_action_id para deduplicarlas. Reconstruir el estado desde cero añade errores antes que ventaja.

Una buena forma de primera producción es:

WebSocket message
  -> parse visible state
  -> PokerKit evaluates cards
  -> policy chooses action
  -> send action with turn_token
  -> log result for later review

Esta estructura basta para superar a muchos bots principiantes. Después puedes añadir rangos por posición, modelado de rivales y gestión de stacks, una pieza cada vez.

¿Qué deberías registrar después de agregar PokerKit?

Registra la etiqueta de la mano, la calle, la acción y el resultado final. Open Poker expone el flujo de manos público a través de WebSocket y las estadísticas de la temporada a través del panel/API, pero su propio registro de decisiones es el único lugar que explica por qué actuó el bot. Sin ese registro, un mejor evaluador todavía puede sentirse como una caja negra.

Empieza con una línea JSON por decisión:

def log_decision(msg, hole_cards, action, amount, hand_label):
    row = {
        "hand_id": msg.get("hand_id"),
        "street": "river" if len(msg.get("community_cards", [])) == 5 else "postflop",
        "hole": hole_cards,
        "board": msg.get("community_cards", []),
        "pot": msg["pot"],
        "hand": hand_label,
        "action": action,
        "amount": amount,
    }
    print(json.dumps(row))

Después de 200 a 500 manos, agrupa los registros por hand y action. Si el bot foldea demasiadas parejas ante apuestas pequeñas, lo verás. Si sube con color pero solo paga con full, también.

Así evitas cambiar cinco cosas a la vez. Añade PokerKit, ejecuta una muestra, compara los resultados con el bot anterior y después modifica una rama de la política. El evaluador debe facilitar la depuración, no complicarla.

Preguntas frecuentes

¿PokerKit es mejor que escribir mi propio evaluador de manos?

Sí, para casi todos los bots de Open Poker. PokerKit incluye evaluación probada de manos de Hold'em, admite operadores de comparación y declara un 99 % de cobertura de código en su README. Conviene invertir el tiempo en estrategia, logs y política postflop.

¿Puede PokerKit conectarse directamente a Open Poker?

No. Open Poker utiliza WebSocket más JSON para jugar en vivo. PokerKit es una biblioteca local de Python para evaluación y simulación de cartas. Usa ambos: WebSocket para la arena, PokerKit para las decisiones.

¿Debo usar PokerKit u OpenSpiel?

Usa PokerKit si estás creando un bot en vivo. Usa OpenSpiel si investigas algoritmos para distintos juegos. OpenSpiel ofrece una gran infraestructura de investigación, pero PokerKit resulta más directo cuando la tarea es «evaluar estas cartas de Hold'em ahora mismo».

¿PokerKit hace rentable un bot por sí solo?

No. Un evaluador evita errores obvios, pero los resultados dependen de los rangos, los tamaños de apuesta, el modelado de rivales y la gestión del bankroll. Añade primero PokerKit y después consulta rangos por posición para bots de póker.