Mengboy Tech Notes

Go Dual-Provider LLM Routing (OpenAI + Claude): Timeout Tiers, Cost Caps, and Fallback Control

Wed, 08 Apr 2026 01:22:53 +0000

If your Go service relies on one LLM provider, two failures hurt the most, timeout spikes and billing spikes. A real production setup is not just “add another provider”, it is a single control plane for routing, timeout tiers, cost caps, and fallback.

This guide gives you a practical OpenAI + Claude dual-provider pattern with one priority, keep uptime first, then optimize quality.

Claude Code + GitHub Actions CI Self-Healing Pipeline: Error Attribution, Minimal Patches, and Human Approval Gates

Mon, 06 Apr 2026 01:17:34 +0000

If your CI keeps failing and engineers keep babysitting logs, you’re paying an invisible velocity tax. A production-grade AI self-healing pipeline is not “let the agent edit anything”. It’s a controlled loop: attribution, patching, approval, rollback.

This post gives you a deployable baseline: Claude Code proposes a minimal fix patch, GitHub Actions enforces risk gates and regression checks, and humans only approve at high-impact checkpoints.

Claude API Rate-Limit Storm Playbook: Adaptive Concurrency, Jittered Backoff, and Quota Isolation

Fri, 03 Apr 2026 01:15:05 +0000

When Claude API starts returning 429 under high load, most systems don’t just slow down—they collapse: queue buildup, retry storms, upstream timeout chains, and pager noise.

Claude 3.7 + OpenAI Responses Dual-Stack Degradation Playbook: Timeout Probing, Circuit Cutover, and Error-Budget Dashboard

Wed, 01 Apr 2026 01:19:20 +0000

Running both Claude and OpenAI in production sounds resilient—until a slow failure hits: latency climbs, 429s spike, quality drifts, and everything still looks “up.”

This guide gives you a practical dual-stack degradation runbook: timeout probing first, circuit-based cutover second, and an error-budget dashboard to keep business impact bounded.

Claude + OpenAI Dual-Provider Gateway Failover: Health Probes, Circuit Breaking, and SLA Fallback

Mon, 30 Mar 2026 01:14:00 +0000

If your production stack calls both Claude and OpenAI, the hard part is not API integration. The hard part is keeping user experience stable when one provider starts throwing 429/5xx spikes, regional latency, or timeout storms.

This guide gives you a practical dual-provider gateway playbook: health probes, circuit breaking, SLA-aware fallback, and observability loops. The goal is not “never fail.” The goal is controlled failure with controlled cost and controlled latency.

OpenAI Responses Streaming in Production: Backpressure, Chunk Reassembly, and Timeout Budget

Fri, 27 Mar 2026 01:08:00 +0000

Most streaming failures are not about “can it stream”, but “does it stay stable under load”: broken chunks, stuck clients, timeout cascades, and retry storms.

Claude + OpenAI Model Routing Gateway: Latency Tiers, Cost Caps, and Quality Guardrails

Wed, 25 Mar 2026 01:16:31 +0000

Connecting both Claude and OpenAI in production is the easy part. The hard part is keeping the system stable across the quality-latency-cost triangle.
Without a routing gateway, you usually get latency spikes, runaway bills, and ugly cascading failures.

OpenAI Responses + Go Stream Recovery: Delta Persistence, Resume Tokens, and Duplicate Chunk Dedup

Mon, 23 Mar 2026 01:13:09 +0000

In production, the painful part is not “streaming is slow.” It’s “streaming breaks and then duplicates output after reconnect.”
This guide gives you a practical recovery loop: delta persistence + resume token + idempotent dedup, so reconnection does not replay garbage.

OpenAI Responses in Go Multi-Tenant Quota Governance: Token Buckets, Budget Circuit Breakers, and Cost Attribution

Fri, 20 Mar 2026 01:08:00 +0000

Most multi-tenant AI platforms fail for two boring reasons: one tenant saturates shared capacity, and finance discovers the burn too late.

This guide gives you a practical Go blueprint: token-bucket throttling, budget circuit breakers, and request-level cost attribution.

Go + OpenAI Responses Agent Memory Layering: Short-Term Context, Long-Term Index, and Cost Caps

Wed, 18 Mar 2026 16:33:52 +0000

In production Go agents, the first thing that breaks is usually not model quality. It is memory management: context grows, bills spike, and answers drift.

Use a 3-layer memory design:

L1: short-term conversational window (seconds)
L2: rolling summary (minutes)
L3: long-term retrieval memory (days)

Handling OpenAI 429/5xx Storms in Go: Token Bucket, Exponential Backoff, and Circuit Breakers

Wed, 18 Mar 2026 01:14:00 +0000

Most Go teams are not killed by a single API error. They are killed by a retry storm they created themselves.

OpenAI Responses + GitHub Actions PR Risk Gate: Automated Evals, Tiered Blocking, and One-Click Rollback

Mon, 16 Mar 2026 01:08:00 +0000

You don’t need an AI reviewer that “sounds smart.” You need a gate that stops risky PRs before they hit main.

This post shows a production-ready minimum setup: OpenAI Responses generates structured risk output, GitHub Actions enforces tiered policies, and critical failures can trigger a one-click rollback.

OpenAI Batch API with Go: Offline Batching, Failure Replay, and Cost Boundaries

Fri, 13 Mar 2026 01:08:00 +0000

Short answer: if your workload is delay-tolerant, batchable, and replay-safe, move it from online calls to Batch API. The savings are real, but only if you design splitting, failure routing, and replay first.

Many teams treat Batch API as a cheaper sync endpoint. That usually creates a replay mess instead of stable savings. A conservative rollout starts with cost boundaries and SLOs, then implements offline batching and controlled replay.

OpenAI Responses Structured Outputs with Go: Schema Evolution, Bad-Case Fallbacks, and Gradual Rollback

Wed, 11 Mar 2026 01:08:00 +0000

The hardest part of Structured Outputs is not getting JSON once. It is surviving schema changes without turning production into a small fire with excellent logs and terrible business results.

Once a Go service starts evolving prompts and response contracts, the usual failure modes show up fast: a new required field breaks older consumers, an enum expands and strict validation kills valid requests, or one bad sample drags the whole chain into retries and rollback panic.

OpenAI Realtime + Go in Production: WebRTC Token Rotation, Interruption Recovery, and End-to-End Latency Budgets

Mon, 09 Mar 2026 01:13:00 +0000

If you plan to put OpenAI Realtime into production, do not let a passing demo fool you.

What usually breaks the system is not the model itself. It is non-rotating short-lived auth, missing interruption state, and zero end-to-end latency budgeting. Miss those three and your voice UX starts sounding like an angry walkie-talkie.

Go + OpenAI Responses: Connection Pooling and Timeout Budgets from HTTP/2 Reuse to Error-Budget Control

Fri, 06 Mar 2026 01:13:12 +0000

When Go services call the OpenAI Responses API in production, the real failures are rarely about model quality. Most incidents come from transport instability: weak connection pooling, conflicting timeout layers, and retry storms.

This guide gives you a practical baseline: HTTP/2 reuse, layered timeout budgets, bounded retries, and error-budget driven operations.

OpenAI Responses + Go: Taming Retry Storms with Idempotency Keys, Jittered Backoff, and Circuit Breakers

Wed, 04 Mar 2026 01:10:40 +0000

The most expensive outage is not a single failure — it is a failure amplified by retries.

In an OpenAI Responses + Go tool-calling stack, missing idempotency, jittered backoff, and breaker thresholds can turn 10 failing requests into 1000 downstream calls in minutes.

Taming Context Explosion in OpenAI Assistants/Responses with Go: Truncation, Summary Backfill, and Cost Caps

Mon, 02 Mar 2026 12:44:00 +0000

Long-running agent sessions usually fail the same way: context keeps growing, latency spikes, costs blow up, and answer quality gets worse.

That is rarely a model-quality issue. It is almost always missing context governance.

Go + OpenAI API Timeout Troubleshooting: DNS, TLS, Proxy, and Connection Pool

Mon, 02 Mar 2026 01:12:10 +0000

When OpenAI API calls start timing out in production, the real problem is usually not “OpenAI is down.”

The real problem is you don’t know which hop is failing: DNS, TLS handshake, proxy path, or your own connection pool.

GitHub Actions + AI Agent Auto-Fix Pipeline: Failure Tiers, Regression Gates, and Security Guardrails

Fri, 27 Feb 2026 01:18:38 +0000

When CI keeps failing, the real risk is not “slow fixes” — it is “fast bad fixes.” This guide gives you a practical GitHub Actions + AI Agent auto-fix pipeline with failure tiering, strict edit boundaries, and merge-time gates.

OpenAI Agents SDK with Go: Tool Calling, Session Memory, and Error Recovery

Wed, 25 Feb 2026 01:18:00 +0000

Most teams can connect an LLM in a demo. The real pain starts in production: multi-step tasks, flaky tool calls, unclear retries, and rising cost.

This guide gives you a pragmatic Go-first blueprint for shipping an Agent workflow that can survive real incidents.

OpenAI Responses API Streaming in Go: Timeouts, Retries, and Observability

Mon, 23 Feb 2026 01:15:00 +0000

Production streaming fails in two predictable ways: users wait while the stream silently drops, and your logs say “timeout” without telling you where it actually broke.

This guide gives you a practical Go pattern for OpenAI Responses API streaming with strict timeout boundaries, safe retries, and useful telemetry.

A Stable FreshRSS + RSSHub Deployment on Linux (Docker Compose)

Fri, 20 Feb 2026 01:11:51 +0000

Getting FreshRSS + RSSHub running is easy. Keeping it stable is the hard part: lost state after restarts, repeated 403 errors, broken proxy headers, and risky upgrades.

This guide gives a production-ready Linux baseline focused on long-term stability, observability, and safe upgrades.

Redis Distributed Lock Best Practices (with Common Misuse Cases)

Thu, 19 Feb 2026 09:55:00 +0800

In high-concurrency scenarios, distributed locks are essential for ensuring data consistency. However, many developers’ understanding of Redis distributed locks stops at “SETNX”, leading to frequent production incidents.

This article comprehensively covers the correct usage of Redis distributed locks from principles, implementation, common misuse cases to production-grade solutions.

Nginx Reverse Proxy WebSocket Disconnects: 7 Common Traps and Reliable Fixes

Wed, 18 Feb 2026 08:20:00 +0800

If your WebSocket keeps reconnecting every few seconds, it’s usually not your app code. In most production incidents, the root cause is an incomplete reverse-proxy chain in Nginx (or one proxy layer before it).

This guide gives you a copy-paste checklist to stabilize WebSocket connections fast.

RAG Accuracy Playbook: Retrieval Recall, Re-Ranking, and Evaluation Loop

Tue, 17 Feb 2026 10:56:00 +0800

If your RAG system feels unreliable, switching to a more expensive LLM is usually the wrong first move. In most cases, the bottleneck is retrieval quality: weak recall, poor ranking, and no measurement loop.

This guide gives a practical path: make recall broader, make ranking sharper, then close the loop with offline + online evaluation.

Hugo Auto Deploy with GitHub Actions: Safe Config and Troubleshooting

Mon, 16 Feb 2026 11:59:00 +0800

Your local hugo build works, but GitHub Actions fails randomly. Classic. The root cause is usually not the workflow syntax. It is environment drift, missing permissions, and unstable dependencies.

Claude Code + Codex for Multi-Model Development: Cost, Speed, and Quality (Practical Workflow)

Sun, 15 Feb 2026 10:30:00 +0800

If you still use one model for everything, you usually pay in one of three ways: higher cost, slower delivery, or more rework.

A better setup is role-based collaboration: Claude Code for planning and quality gates, Codex for fast implementation and batch edits.

Go Memory Leak Triage in Production: pprof + FlameGraph Step by Step

Sat, 14 Feb 2026 21:20:00 +0800

If your Go service RSS keeps climbing, drops after restart, then climbs again, you likely have a memory retention problem (or an actual leak pattern).

Do not start with random code edits. Run a clean evidence chain: metrics trend check → pprof snapshots → FlameGraph comparison → object growth path → regression validation.

OpenAI Responses API + MCP in Practice: From Function Calling to Agent Workflows

Wed, 11 Feb 2026 23:15:00 +0800

If you’ve already used function calling but keep writing glue code for every non-trivial task, you’re likely at the point where Responses API + MCP makes more sense.

This guide is practical: how to move from single tool calls to a scalable agent workflow where retrieval, execution, validation, and write-back follow a consistent structure.

WSL2 + Docker Network Troubleshooting: Fix DNS Timeouts and Image Pull Failures

Wed, 11 Feb 2026 22:50:00 +0800

If your WSL2 + Docker setup suddenly fails with docker pull timeouts, Temporary failure in name resolution, or containers that start but cannot access the internet, don’t nuke your environment yet. Most cases are recoverable in 15 minutes.

This guide gives you a practical sequence: identify whether the fault is DNS, proxy/VPN, virtual NIC, or Docker daemon config—then apply the smallest fix first.

MCP in Practice: Automated Browser Debugging with DevTools MCP

Tue, 10 Feb 2026 22:10:00 +0800

MCP sounds great in theory, but real-world setup often fails at browser debugging: AI cannot reach Chrome, cannot inspect network requests, and cannot collect performance traces. This guide gives you a copy-paste setup that works on Windows + WSL.

Claude vs Codex vs OpenAI CLI: Which Workflow Actually Improves Dev Productivity

Mon, 09 Feb 2026 23:28:00 +0800

If you use AI as a chatbot only, these tools feel similar. In real engineering workflows, they behave very differently.

My conclusion first: use Codex for repo-native coding changes, Claude for deep reasoning and long-form planning, and OpenAI CLI for standardized automation pipelines.

Software Engineering History: From Software Crisis to AI Co-Creation

Wed, 31 Dec 2025 12:30:15 +0800

Large language models are changing how we clarify requirements, generate code, and design tests, and many teams feel that traditional workflows are being rewritten. To understand what is truly changing, it helps to place today inside the longer history of software engineering.

This article walks through the major stages of software engineering and ends with the AI-era variables and a simple checklist so you can map your current problems to the right time scale.

Configure Chrome DevTools MCP in WSL

Sun, 28 Dec 2025 22:26:08 +0800

Chrome DevTools MCP lets MCP clients connect to Chrome’s remote debugging endpoint. Because WSL2 and Windows are isolated at the network layer, you need port forwarding and a firewall rule. The commands below are split into clear steps.

Installing Cursor MCP Servers in WSL for a Seamless Dev Experience

Tue, 13 May 2025 23:17:00 +0800

For developers who love the power of Linux tools but work on Windows, the Windows Subsystem for Linux (WSL) is a game-changer. Cursor, the AI-first code editor, can further enhance this setup by integrating with Model Control Program (MCP) servers. Running these MCP servers directly within your WSL environment keeps your development workflow clean and consolidated. This guide will walk you through configuring Cursor to use MCP servers running in WSL.

Complete Guide to Migrating from Hexo to Hugo

Sun, 04 May 2025 13:30:00 +0800

Detailed step-by-step instructions on how to smoothly migrate your Hexo blog to Hugo, including article conversion, multilingual setup, and metadata preservation

About Me

Sat, 03 May 2025 12:00:00 +0800

About Me

I’m Mengboy. I work a lot on backend systems, cloud-native tooling, and automation, and I turn hard-earned debugging experience into reusable notes.

This blog is not about generic theory. It’s about real problems + executable solutions: commands you can run, configs you can apply, and workflows you can reuse.

What I Write Here

Engineering Practice: troubleshooting and performance tuning for Go, Redis, Nginx, Docker, Linux/WSL
AI in Production Workflows: MCP, automation pipelines, and integrating AI into day-to-day development
Deployment & Ops: stable release strategies, rollback safety, and production-minded setup
Reusable Methods: decision frameworks, checklists, and templates that save time

Tech Preferences

Backend: Go, Python
Infrastructure: Docker, Kubernetes, Linux
Data Layer: MySQL, Redis, MongoDB
Engineering Habits: incremental delivery, scripting-first, docs-first

Writing Principles

Conclusion first, then explanation.
Focus on why failures happen and how to locate them fast.
Include copy-paste-ready commands and configuration whenever possible.

If a post helps you solve a real issue faster, it has done its job.