PokerKit Poker Bot-Tutorial: Eine echte Handbewertung ergänzen

PokerKit ist das schnellste Upgrade, nachdem dein erster Open Poker-Bot eine Verbindung hergestellt hat. Der 47-Zeilen-Starter-Bot beweist, dass deine WebSocket-Schleife funktioniert, aber PokerKit gibt dieser Schleife einen echten Hand-Evaluator, einen Board-Parser und einen Simulationspfad. Nutze es für Entscheidungen. Behalte das WebSocket-Protokoll von Open Poker für den Wettbewerb bei.

Teil von: Der vollständige Leitfaden zum Aufbau eines KI-Poker-Bots im Jahr 2026 - die zentrale Kursreferenz, die Frameworks, Entscheidungslogik, Equity, Tests und Wettbewerbsmöglichkeiten abdeckt.

Wichtige Erkenntnisse

• PokerKit ist eine reine Python-Pokerbibliothek mit Handbewertung, Simulationen und Texas Hold'em-Unterstützung.
• Verwende PokerKit innerhalb deiner Entscheidungsfunktion, nicht als Ersatz für den Open Poker WebSocket-Client.
• Konvertiere zunächst Open Poker-Kartenzeichenfolgen in das kompakte Format von PokerKit und vergleiche dann die StandardHighHand-Objekte.

Was soll PokerKit in deinem Bot tun?

PokerKit sollte eine Frage beantworten: „Wie stark ist meine Hand im Moment?“ Der Open Poker-Server sendet den Spielstatus über WebSocket, während PokerKit die Karten lokal auswertet. Die Dokumente von PokerKit berichten von einer standardmäßigen High-Hand-Auswertung bei 1.016.740,7 Händen pro Sekunde auf einem einzelnen Intel i7-1255U-Kern in Python 3.11.5 (PokerKit-Dokumente).

Diese Geschwindigkeit reicht für normale Open Poker-Entscheidungen aus, da die Plattform deinem Bot 45 Sekunden Zeit gibt, bevor eine Aktion abläuft (Open Poker-Aktionsdokumente). Für das erste Upgrade brauchst du kein neuronales Netzwerk. Du musst aufhören, Ace-High und einen Flush als denselben „Call if cheap“-Zweig zu behandeln.

Die Aufgaben lassen sich klar aufteilen:

Wenn du noch dabei bist, deine erste Event-Schleife zu schreiben, beginne mit Poker-Bot in Python erstellen. Komm hierher zurück, sobald dieser Bot ohne Zeitüberschreitung an einem Tisch sitzen kann.

Wie installiert man PokerKit für einen Bot?

Installiere PokerKit mit pip install pokerkit. In der aktuellen PokerKit-README-Datei heißt es, dass die Bibliothek Python 3.11 oder höher erfordert und reines Python ist, sodass sie zum gleichen Bereitstellungsmodell passt wie ein normaler Open Poker-Bot (PokerKit GitHub).

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

Behalte websockets für die Open Poker-Verbindung bei. PokerKit meldet sich nicht an, tritt der Lobby nicht bei und sendet keine Aktionen. Es hilft dir nur dabei, über Karten nachzudenken, nachdem der Server eine your_turn-Nachricht gesendet hat.

Das Open Poker-Protokoll verwendet Karten wie Ah, Kd und 7c. PokerKit akzeptiert die gleichen kompakten Kartenstrings. Das bedeutet, dass du eine Open Poker-Liste mit einem einzigen Join in einen PokerKit-String umwandeln kannst:

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

In den Dokumenten von PokerKit wird darauf hingewiesen, dass das String-Parsing rechenintensiv ist, wenn es wiederholt in Hot-Loops durchgeführt wird. Für einen ersten Bot sind Strings in Ordnung. Wenn du Tausende von Monte-Carlo-Versuchen pro Entscheidung ausführst, parse die Karten möglichst nur einmal und speichere die Ergebnisse zwischen.

Wie bewertet man eine Texas Hold'em-Hand?

Verwende StandardHighHand.from_game(hole, board) für normales No-Limit Texas Hold'em. Open Poker ist 6-max NLHE mit 10/20 Blinds und 1.000 bis 5.000 Chip-Buy-Ins (Saisondokumente), daher ist die Standard-High-Hand-Bewertung die richtige Standardeinstellung.

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

Dieser Vergleich ist der wichtige Teil. PokerKit-Handobjekte unterstützen normale Vergleichsoperatoren, wodurch dein Bot Ergebnisse ohne handgeschriebene Logik „Paar schlägt hohe Karte“ bewerten kann.

Übertreibe das nicht zu früh. Auf dem Flop geht es bei den meisten Entscheidungen nicht um die endgültige Hand, da noch zwei Karten kommen. Nutze die Stärke deiner eigenen Hand für offensichtliche Entscheidungen und füge dann die Equity-Schätzung für Draws und knappe Call-Entscheidungen hinzu. Hier kommt PokerKit zum Einsatz.

Wie verbindet man PokerKit mit your_turn?

Führe PokerKit im your_turn-Zweig aus, nachdem du deinen neuensten Hole Cards zwischengespeichert hast. Die WebSocket-your_turn-Nachricht enthält valid_actions, pot, community_cards, min_raise, max_raise und einen neuen turn_token (WebSocket-Dokumente).

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

Das ist bewusst konservativ. Der Bot foldet zu häufig, verschenkt dafür aber nicht mit dem niedrigsten Paar den gesamten Stack. Sobald dies ausgeführt wird, kombiniere es mit der Poker-Bot-Setzstrategie, damit der Bot mit starken Händen sinnvoll erhöht, statt immer nur den Mindesterhöhungsbetrag zu wählen.

Wann solltest du Equity statt Handkategorien verwenden?

Füge Equity hinzu, wenn eine Handkategorie wichtige Unterschiede verdeckt. Ein nackter Flush Draw und ein gemachtes Paar können beide an verschiedenen Stellen profitabel sein, aber ein Nur-Label-Bot interpretiert eine davon falsch. PokerKit ist nützlich, weil du unbekannte Turn- und River-Karten simulieren kannst, anstatt zu raten.

Der einfachste Weg ist:

1. Baue ein Deck mit 52 Karten.
2. Hole Cards des eigenen Bots und sichtbare Boardkarten entfernen.
3. Probiere die Hole Cards des Gegners und die fehlenden Boardkarten aus.
4. Vergleiche die endgültigen PokerKit-Hände.
5. 1.000 bis 10.000 Mal wiederholen.

Das gibt dir eine geschätzte Gewinnwahrscheinlichkeit. Vergleiche diese Schätzung dann mit den 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 sendet den Pot- und Call-Betrag bereits in valid_actions, sodass du die Setzrunde nicht selbst rekonstruieren musst. Für die vollständige Equity-Implementierung lies Monte-Carlo-Equity-Rechner in Python.

Wofür solltest du PokerKit nicht verwenden?

Verwende PokerKit nicht als Ersatz für Live-Tests. PokerKit kann dir sagen, ob eine Hand eine andere Hand schlägt, aber es kann dir nicht sagen, ob deine Gegner am River zu häufig auf Einsätze folden, im Big Blind zu weit mitgehen oder nach einem misslungenen Bluff aufgeben. Open Poker existiert, weil allein das Selbstspiel diese Muster verfehlt.

Simuliere auch nicht den gesamten Open Poker-Tisch lokal, es sei denn, du hast einen bestimmten Grund. Der Server ist maßgeblich. Dein Bot sollte auf your_turn reagieren, zulässige Aktionen mit dem aktuellen turn_token senden und client_action_id für die Deduplizierung verwenden. Wer den Tischzustand vollständig neu konstruiert, baut meist Fehler ein, bevor daraus ein strategischer Vorteil entsteht.

Für eine erste Implementierung eignet sich diese Struktur:

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

Das ist genug Struktur, um an den meisten Anfänger-Bots vorbeizukommen. Anschließend kannst du Positions-Ranges, Gegnermodellierung und Stack-Management Stück für Stück hinzufügen.

Was solltest du nach dem Hinzufügen von PokerKit protokollieren?

Protokolliere die Handkategorie, die Setzrunde, die Aktion und das Endergebnis. Open Poker legt den öffentlichen Handfluss über WebSocket und Saisonstatistiken über das Dashboard/die API offen, aber dein eigenes Entscheidungsprotokoll ist der einzige Ort, der erklärt, warum der Bot gehandelt hat. Ohne dieses Protokoll kann sich ein besserer Evaluator immer noch wie eine Black Box fühlen.

Beginne mit einer JSON-Zeile pro Entscheidung:

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

Gruppiere die Protokolle nach 200 bis 500 Händen nach hand und action. Wenn dein Bot mit einem Paar zu häufig gegen winzige Einsätze foldet, wirst du es sehen. Auch wenn er mit einem Flush erhöht, mit einem Full House aber nur callt, fällt das in den Daten auf.

So vermeidest du auch, fünf Dinge auf einmal zu ändern. Füge PokerKit hinzu, führe ein Beispiel aus, vergleiche die Ergebnisse mit dem alten Bot und ändere dann einen Entscheidungszweig. Der Evaluator sollte das Debuggen deines Bots einfacher und nicht schwieriger machen.

FAQ

Ist PokerKit besser, als meinen eigenen Hand-Evaluator zu schreiben?

Ja, für fast jeden Open Poker-Bot. PokerKit liefert getestete Hold'em-Handauswertungen aus, unterstützt Vergleichsoperatoren und meldet in seiner README-Datei eine Codeabdeckung von 99 %. Deine Zeit solltest du besser für Strategie, Protokollierung und Postflop-Strategien verwenden.

Kann PokerKit direkt eine Verbindung zu Open Poker herstellen?

Nein. Open Poker verwendet WebSocket plus JSON für Live-Spiele. PokerKit ist eine lokale Python-Bibliothek zur Kartenbewertung und -simulation. Nutze beides: WebSocket für die Arena, PokerKit für Entscheidungen.

Soll ich PokerKit oder OpenSpiel verwenden?

Verwende PokerKit, wenn du einen Live-Bot erstellst. Verwende OpenSpiel, wenn du Algorithmen für viele Spiele erforschst. OpenSpiel ist eine ausgezeichnete Forschungsinfrastruktur, aber PokerKit ist einfacher, wenn es darum geht, „diese Hold'em-Karten jetzt zu bewerten“.

Macht PokerKit einen Bot allein profitabel?

Nein. Ein Hand-Evaluator verhindert offensichtliche Fehler, aber der Gewinn ergibt sich aus der Range-Auswahl, dem Bet-Sizing, der Gegnermodellierung und den Entscheidungen über die Bankroll. Füge zuerst PokerKit hinzu und lies dann Positions-Ranges für Poker-Bots.