7 दिनों में Zero से Open Poker Leaderboard तक: एक Daily Plan

तुम एक poker bot को "exist नहीं करता" से "Open Poker leaderboard पर ranked" तक 7 दिनों में ले जा सकते हो। 7 weeks में नहीं। Platform इस तरह build हुई है कि एक developer day 1 पर register करे, connect करे, और खेले, फिर हर दिन एक strategy upgrade add करे जब तक competitive न हो जाए। यहाँ वो plan है जो हम recommend करते हैं, exact upgrades के साथ जो needle move करते हैं और जो नहीं करते।

7-day plan काम क्यों करता है?

क्योंकि हर दिन एक working bot के ऊपर एक single, isolated improvement add करता है। तुम पहले hand से पहले end-to-end system build नहीं कर रहे। तुम day 1 पर calling station ship कर रहे हो और इसे incrementally improve कर रहे हो। Day 7 तक, हर upgrade real opponents के against validate हो चुकी होगी, किसी self-play simulator के against नहीं जो तुमसे झूठ बोलता है।

यह उसका opposite है जैसे ज़्यादातर bot projects fail होते हैं। ज़्यादातर developers दो हफ्ते एक "complete" architecture design करने में बिताते हैं, फिर day 14 पर realize करते हैं कि उनका hand evaluator protocol के card format से match नहीं करता, या उनका action sender turn token भूल जाता है, या उनका pot odds calculator wrong field use करता है। 7-day plan इन सबको तब तक defer करता है जब तक bot already running नहीं हो।

दूसरा reason जो इसे काम दिलाता है: Open Poker का leaderboard peak skill से ज़्यादा volume reward करता है। 7 days run करने वाला mediocre bot उस brilliant bot को outscore करता है जो 1 day run करता है। Day 7 तक तुम्हारे पास 4-5 दिनों का accumulated hand history है, जो field के bottom से ऊपर climb करने के लिए enough variance reduction है even अगर तुम्हारी strategy अभी rough है।

Day 1: Calling station चलाओ

Day 1 पर तुम्हारा only goal एक connected bot है जो legal hands खेले। Strategy की चिंता मत करो। Profits की चिंता मत करो। Anything की चिंता मत करो सिवाय: bot connects, bot table join करता है, bot your_turn पर valid action से respond करता है, bot 30 minutes तक crash नहीं होता।

Python में poker bot build करने वाले guide को starting point की तरह use करो। पूरा bot 50 lines से कम है। Copy करो, अपना API key paste करो, run करो। 30 seconds के अंदर "Connected as YourBotName" दिखेगा और lobby join करने के एक-दो minutes में पहला hand।

Calling station strategy (check कर सको तो check, वरना call, वरना fold) chips lose करती है लेकिन complete event loops produce करती है। हर message type handle होता है। हर action valid turn token के साथ sent होता है। Day 1 के end तक तुम्हारे bot ने 50-100 hands खेले होंगे और तुम्हारे पास improve करने के लिए baseline win rate होगी।

End-of-day target: bot ने कम से कम 20 hands खेले, कोई crashes नहीं, कोई timeouts नहीं।

Day 2: Pre-flop hand selection add करो

Calling station के ऊपर सबसे बड़ा improvement। Hold'em में ज़्यादातर starting hands losers होते हैं; pre-flop bottom 60% fold करने से flop और उससे आगे chips bleed dramatically reduce होती है।

def should_play_preflop(cards):
    """Top ~40% of starting hands."""
    ranks = "23456789TJQKA"
    r1 = ranks.index(cards[0][0])
    r2 = ranks.index(cards[1][0])
    high, low = max(r1, r2), min(r1, r2)
    pair = r1 == r2
    suited = cards[0][1] == cards[1][1]
 
    if pair: return True
    if high >= 10: return True
    if high >= 8 and suited: return True
    if high == 12 and low >= 7: return True
    return False

hole_cards आने पर hole cards store करो। your_turn पर, अगर यह preflop है और should_play_preflop() False return करे, fold करो। वरना calling station logic पर fall back करो।

यह single change typically calling station को -2.5 bb/100 से लगभग -0.8 bb/100 पर ले जाती है। तुम अभी भी chips lose कर रहे हो, लेकिन एक rate पर जो frequent rebuys trigger नहीं करती। End-of-day target: 200+ hands खेले, win rate 12% से ऊपर।

Day 3: Pre-flop raising add करो

Day 2 का bot bad hands fold करता है लेकिन good ones कभी raise नहीं करता। Opponents तुम्हारे premium holdings के against free flops देखते हैं, जिसका मतलब है उन्हें ऐसे hands बनाने को मिलते हैं जो तुम्हें beat करें। Fix: सिर्फ call करने की बजाय top 15% hands raise करो।

def should_raise_preflop(cards):
    ranks = "23456789TJQKA"
    r1, r2 = ranks.index(cards[0][0]), ranks.index(cards[1][0])
    pair = r1 == r2
    high, low = max(r1, r2), min(r1, r2)
    suited = cards[0][1] == cards[1][1]
    # Premium pairs
    if pair and r1 >= 8: return True  # 99+
    # Big aces
    if high == 12 and low >= 9: return True  # AT+
    # Suited broadway
    if suited and high >= 10 and low >= 9: return True
    return False

जब यह True return करे और raise valid_actions में हो, call की बजाय min-raise भेजो। Amount field raise-to total है, increment नहीं। Raise action entry में min value अपना amount use करो।

End-of-day target: 400+ hands खेले, win rate 16% से ऊपर, bb/100 break-even approach।

Day 4: Postflop calls के लिए pot odds add करो

Postflop वहाँ है जहाँ bots सबसे ज़्यादा chips leak करते हैं। Math किए बिना random bets call करना ही calling station को calling station बनाता है। Pot odds से fix करो।

Math: call amount को pot में call के बाद divide करो। अगर तुम्हारी estimated win probability उस ratio से ज़्यादा हो, call करो। वरना fold। Bots के लिए poker math tutorial formula को detail में cover करती है।

def call_is_profitable(your_turn_msg, win_pct=0.30):
    actions = {a["action"]: a for a in your_turn_msg["valid_actions"]}
    if "call" not in actions:
        return False
    pot = your_turn_msg["pot"]
    call_amt = actions["call"]["amount"]
    if call_amt == 0:
        return True
    pot_odds = call_amt / (pot + call_amt)
    return win_pct > pot_odds

Day 4 के लिए flat 30% win rate estimate use करो। यह ज़्यादातर specific spots पर wrong है, लेकिन average पर "always call" से बहुत better default है। तुम rivers fold करोगे जहाँ तुम्हारे पास nothing है और उन hands continue करोगे जिनकी realistic equity है।

End-of-day target: 600+ hands खेले, bb/100 break-even या slightly positive।

Day 5: Opponent VPIP track करो

Day 5 वो है जब तुम हर hand एक जैसा खेलना बंद करते हो और table के adapt होने लगते हो। एक simple opponent tracker build करो जो log करे कि हर player pre-flop में chips कितनी बार put करता है। Opponent modeling guide में full implementation है, लेकिन minimum viable version:

from collections import defaultdict
 
vpip_data = defaultdict(lambda: {"hands": 0, "voluntary": 0})
acted_this_hand = set()
 
def on_hand_start():
    acted_this_hand.clear()
 
def on_player_action(msg):
    name = msg.get("name", f"seat{msg['seat']}")
    if msg["action"] in ("call", "raise", "all_in"):
        if name not in acted_this_hand:
            vpip_data[name]["hands"] += 1
            vpip_data[name]["voluntary"] += 1
            acted_this_hand.add(name)
 
def get_vpip(name, default=0.25):
    data = vpip_data[name]
    if data["hands"] < 20:
        return default
    return data["voluntary"] / data["hands"]

VPIP use करके अपनी raising range adjust करो। Late position में VPIP under 15% वाले opponent के against अपनी stealing range expand करो। VPIP over 50% वाले opponent के against only value-bet करो (bluff मत करो: वो बहुत ज़्यादा call करते हैं)।

End-of-day target: 800+ hands, bot कम से कम 5 distinct opponents identify कर रहा है।

Day 6: Bet sizing variation add करो

Static bet sizing next leak है। ज़्यादातर beginner bots या तो हमेशा min-raise करते हैं या हमेशा pot-bet करते हैं। दोनों wrong हैं। Situation के based पर तीन sizes mix करो:

Spot के based पर raise amount compute करो, valid_actions से min/max तक clamp करो, और send करो। Sizes mix करना तुम्हें noticeably less exploitable बनाता है। Patterns track करने वाले opponents अब तुम्हारे bet size से तुम्हारे hand strength का guess नहीं लगा सकते। Betting strategy tutorial में full breakdown है।

End-of-day target: 1,000+ hands, bb/100 measurably positive, leaderboard का top 50%।

Day 7: Uptime run करो, monitor करो, iterate करो

Day 7 नए features के बारे में नहीं है। यह तुम्हारे bot को 12+ hours straight run करने, leaderboard देखने, और जो कुछ भी break होता है उसे patch करने के बारे में है। Debug guide सबसे common failure modes (auth issues, timeouts, race conditions) cover करती है।

तीन चीज़ें check करो:

1. Crash log। अपने main loop को एक try/except में wrap करो जो हर exception को timestamp के साथ log करे। 4 hours run करो, फिर log पढ़ो। सबसे frequent error पहले fix करो।

2. Slow decisions। Timeout guide से latency logging add करो। 1 second से ज़्यादा कुछ भी investigation का हकदार है।

3. Win rate by hour। अपनी hand history को day के hour के हिसाब से group करो और check करो कि क्या तुम्हारी win rate vary करती है। कुछ bots peak hours में जीतते हैं (ज़्यादा opponents = exploit करने के लिए ज़्यादा weak players) लेकिन off-peak times पर खोते हैं। यह decide करने के लिए use करो कि अपना bot कब running रखना है।

End-of-day target: Bot ने 7 days में 1,500+ hands खेले हों, current season leaderboard के top 25% में rank करे, और बिना intervention के 12+ hours unattended run करे।

7-day progression actually कैसी दिखती है?

यहाँ वो rough win-rate trajectory है जो हमने उन multiple developers में देखी जिन्होंने यह plan follow किया:

सबसे बड़े jumps days 2 और 5 पर हैं: pre-flop hand selection और opponent modeling। Code के per line सबसे सस्ते improvements। Days 4 और 6 smaller gains हैं लेकिन nicely compound करते हैं। Day 7 कोई edge नहीं add करता, लेकिन यह तुम्हारे already existing edge को hands accumulate करके leaderboard position में convert करता है।

यह कोई rigorous study नहीं है। 6-max में Variance high है और individual results season के player pool के basis पर vary करते हैं, लेकिन directionally pattern consistent है: simple upgrades एक हफ्ते से कम part-time work में एक competitive bot में stack होते हैं।

पहले हफ्ते में क्या नहीं करना चाहिए?

तीन traps avoid करो।

Scratch से hand evaluator मत लिखो। यह tempting है क्योंकि यह "real" poker work जैसा लगता है। यह एक multi-day project है जो simple win-probability heuristic पर कोई measurable edge नहीं add करता। अगर तुम्हें absolutely hand strength चाहिए, PokerKit या Treys (battle-tested evaluators वाली Python libraries) use करो अपना खुद लिखने की बजाय। हम server side पर PokerKit use करते हैं उसी reason से।

CFR या GTO solving implement मत करो। Counterfactual Regret Minimization Pluribus और Libratus के पीछे की technique है। यह एक multi-month research project भी है जिसे tens of millions training hands चाहिए। First bot के लिए, तुम उसी time में basic heuristics पर better results पाओगे। Top 20% से आगे push करना हो तभी CFR later में add करो।

Day 1 पर no error handling के साथ deploy मत करो। अपने event loop को try/except में wrap करो, हर exception log करो, और चलते रहो। एक single bad message पर crash होने वाले bots सारा table time खो देते हैं जो उन्हें overnight accumulate होता। Fix एक try/except block है।

Day 7 के बाद क्या?

एक working competitive bot हो जाने के बाद, upgrades का अगला round incremental और high-impact है:

• Position-aware ranges: under the gun पर tighter, cutoff और button पर looser
• Multi-street planning: flop bet करने से पहले turn पर क्या करोगे सोचो
• Bluff selection: ऐसे boards pick करो जहाँ bluffs credible हों (high cards, fewer draws)
• Bankroll management: session results के based पर buy-in vary करो

इनमें से हर एक अच्छी तरह implement होने पर 0.5-1.5 bb/100 और add करती है। Top-10 leaderboard finishes का रास्ता कोई single breakthrough नहीं है; यह 10 small improvements stack करना है जब तक तुम्हारे bot का हर common spot में measurable edge न हो। पूरी platform docs अगले round के लिए ज़रूरी हर protocol detail cover करती हैं।

FAQ

एक competitive poker bot build करने में actually कितना समय लगता है? First competitive bot (leaderboard का top 25%) के लिए, 7 days part-time work realistic है। Top 10% के लिए 2-4 weeks iteration और tuning expect करो। Top 1% के लिए CFR-style algorithms, opponent profiling at scale, और months of refinement चाहिए।

क्या मैं Python के अलावा किसी और language के साथ यह plan follow कर सकता हूँ? हाँ। Protocol pure WebSocket plus JSON है, तो WebSocket support वाली कोई भी language काम करती है। JavaScript, Go, Rust, Java, C++, यहाँ तक कि websocat के साथ Bash — सभी से Open Poker पर bots build किए गए हैं। Python examples directly translate होते हैं।

Leaderboard climb करने के लिए कितने hands खेलने पड़ते हैं? Leaderboard पर appear होने के लिए कम से कम 10 hands चाहिए। Significantly climb करने के लिए season में 1,000-2,000 hands plan करो। ज़्यादा hands variance कम करती है और तुम्हारे edge को show through होने देती है।

क्या इस plan के लिए Pro account चाहिए? नहीं। इस plan में सब कुछ free account पर काम करता है। Pro tier ($5/season, bundle discounts के साथ) analytics, custom strategies, और shorter rebuy cooldowns add करता है, लेकिन strategy upgrades themselves free हैं। Full list के लिए Pro feature comparison देखो।

क्या होगा अगर मेरा bot plan finish करने से पहले bust हो जाए? Auto-rebuy handle करता है। Connect होने के बाद एक बार {"type": "set_auto_rebuy", "enabled": true} भेजो और server automatically तुम्हें rebuy करेगा (free tier पर 5-minute cooldown के अनुसार) जब तुम्हारा bot bust हो। तुम्हारा event loop running रहता है और cooldown expire होते ही अगला hand शुरू होता है।

सात दिनों का focused work Open Poker पर एक poker bot को zero से leaderboard contender तक ले जाने के लिए काफी है। Platform इसी iteration speed के लिए designed है। Bot register करो, day-by-day plan follow करो, और अगले हफ्ते तक तुम्हारी ranked entry होगी।