DEV Community: Daniel Dong

Stop regex-parsing your LLM output. Make it return JSON.

Daniel Dong — Thu, 01 Oct 2026 07:13:16 +0000

The moment an LLM hands you a wall of prose and you reach for a regex, you've moved the problem — you traded a model that knows the answer for a string you have to re-parse to get it back.

curl https://aibridge-api.com/v1/chat/completions \
  -H "Authorization: Bearer mb-xxxxxxxx" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [
      {"role": "system", "content": "You return ONLY valid JSON. No markdown fences, no prose, no commentary."},
      {"role": "user", "content": "Extract name, date, and amount from this invoice text: \"...\""}
    ]
  }'

The response lands as clean, machine-readable JSON you can feed straight into your pipeline — no .split(), no regex, no "it worked until the model added an emoji."

The prose-parsing trap

LLMs default to prose because prose is how they were trained to talk. But your code doesn't want prose — it wants fields. So developers end up doing one of three fragile things:

Regex surgery — brittle, breaks the moment the model rephrases
String splitting — "find the first colon, take everything after it" (works until it doesn't)
"Just ask nicely" — prompt the model to return JSON, but never verify it actually did

Every one of those fails in production, usually at 2 AM, usually on a customer's most important request.

The fix is a contract, not a wish

Structured output works when you treat the format as a requirement, not a request:

Say it in the system prompt — "return ONLY valid JSON, no fences, no prose"
Give it a schema — describe the exact keys and types you expect, or better, paste an example
Verify before you trust — parse the result with json.loads / JSON.parse; if it throws, retry with a harder prompt

The model is good at following a clear contract. It's bad at guessing what you meant. Spell out the shape and it will usually deliver it.

Where structured output pays for itself

Extraction — pull name/date/amount from messy text into clean fields
Classification — return {"label": "refund", "confidence": 0.97} instead of "This appears to be a refund request"
API responses — build an endpoint that returns LLM-shaped JSON, not prose you have to clean
Chained pipelines — one model's JSON output becomes the next model's typed input, no parsing in between The moment your output is typed and parseable, your LLM call becomes a normal function in your codebase — testable, composable, boring in the best way.

One more trick: it pairs with the model router

You don't need a flagship model to extract fields from an invoice. Route the cheap, fast models to the structured-output work and save the heavy reasoning for the hard stuff:

def extract(messages) -> dict:
    # glm-4-flash is fast, cheap, and plenty for JSON extraction
    resp = client.chat.completions.create(model="glm-4-flash", messages=messages)
    return json.loads(resp.choices[0].message.content)  # typed, or it raises

Fast tier — glm-4-flash, deepseek-v4-flash, moonshot-v1-8k
Balanced tier — glm-4-air, deepseek-chat, qwen-plus
Flagship tier — deepseek-v4-pro, qwen3-235b-a22b, glm-4-plus
Deep reasoning — deepseek-reasoner, kimi-k3 (1M context) 15 models, 4 vendors, one OpenAI-compatible endpoint.

Pricing that keeps extraction cheap

Free tier: 500K tokens/month (weighted)
Pro: $9.90/month for 5M tokens
Top-ups: 1M / $2.99 · 5M / $9.90 · 20M / $29.90 (never expire)

The takeaway

An LLM that returns JSON is a function. An LLM that returns prose is a chore. Put the format in the contract and let your code trust the output.
Try structured output on all 15 models, free.

→ aibridge-api.com · support@aibridge-api.com

# Four Chinese AI vendors. Fifteen models. One endpoint.

Daniel Dong — Wed, 30 Sep 2026 09:08:45 +0000

The Chinese AI scene isn't a single breakout lab — it's four heavyweights shipping different strengths. And they all live behind one API key now.

curl https://aibridge-api.com/v1/chat/completions \
  -H "Authorization: Bearer mb-xxxxxxxx" \
  -d '{"model":"deepseek-v4-pro","messages":[{"role":"user","content":"..."}]}'

Change "model" and you've switched vendors — DeepSeek to Qwen to GLM to Moonshot — without touching your SDK, your auth, or your code.

Four vendors, four superpowers

If you've been watching Chinese LLMs from the outside, they blur together. Up close, each vendor owns a niche:

Vendor	Flagship	What they're known for
DeepSeek	`deepseek-v4-pro`, `deepseek-reasoner`, `deepseek-coder`	Reasoning depth and a purpose-built coding model
Qwen (Alibaba)	`qwen3-235b-a22b`, `qwen-plus`, `qwen-max`	Multilingual strength and cost-effective long context
GLM (Zhipu)	`glm-4-plus`, `glm-4-air`, `glm-4-flash`	Balanced tiers from flagship to lightning-fast flash
Moonshot	`kimi-k3`, `moonshot-v1` family	`kimi-k3`'s 1M-token context — whole repos, full transcripts

None of them is "the one." They're a portfolio — and picking one vendor means leaving three superpowers on the table.

Why one endpoint changes the game

Normally, "use all four vendors" means:

Four accounts, four SDKs, four auth flows
Four billing cycles to reconcile
Four code paths that each break in their own way

That friction is exactly why most teams silently pick one vendor and eat the trade-offs. One endpoint removes the friction, so the trade-offs become optional:

Failover — DeepSeek has a rough hour, glm-4-plus takes the call
Task routing — code goes to deepseek-coder, multilingual goes to qwen-max, reasoning goes to deepseek-reasoner
A/B testing — bake off all four vendors on your own data in an afternoon
1M context on demand — reach for kimi-k3 when the input is a whole repo

Four vendors stop being a "migration" and become a model parameter.

The full lineup

DeepSeek — deepseek-v4-pro, deepseek-v4-flash, deepseek-reasoner, deepseek-coder, deepseek-chat
Qwen — qwen3-235b-a22b, qwen-plus (131K), qwen-max
GLM — glm-4-plus, glm-4-air, glm-4-flash
Moonshot — kimi-k3 (1M context), moonshot-v1-128k / -32k / -8k

Pricing without the vendor-hop headache

Free tier: 500K tokens/month (weighted)
Pro: $9.90/month for 5M tokens
Top-ups: 1M / $2.99 · 5M / $9.90 · 20M / $29.90 (never expire)

The takeaway

You don't have to choose a Chinese AI vendor. You can choose all four — and switch between them with a one-line change.

Four vendors, fifteen models, one key.

→ aibridge-api.com · support@aibridge-api.com

# Your users don't all speak English. Your AI shouldn't either.

Daniel Dong — Mon, 28 Sep 2026 04:05:36 +0000

If your product ships to more than one country, a monolingual model is a silent quality tax — it answers everyone in the language it's most comfortable with, not the one your user actually speaks.

curl https://aibridge-api.com/v1/chat/completions \
  -H "Authorization: Bearer mb-xxxxxxxx" \
  -d '{
    "model": "qwen-max",
    "messages": [
      {"role": "system", "content": "You are a multilingual support agent. Always reply in the user\u0027s language."},
      {"role": "user", "content": "我的订单还没发货，能帮我查一下吗？"}
    ]
  }'

qwen-max is built for exactly this — multilingual work, with a long-context window to match. It answers in the user's language because that's what it was tuned to do, not as an afterthought.

The monolingual tax you're paying

Most models are trained with an English-heavy distribution. That's fine if your users all speak English. The moment they don't, three things quietly degrade:

Awkward code-switching — the model answers a Chinese question in English, or drops half-translated phrases
Lost nuance — idioms, politeness levels, and cultural context flatten out in translation
Forced workarounds — you bolt on a translate-first pipeline, adding latency and a second failure point

If your market is multilingual — and most of the world is — a model that natively handles those languages is the difference between "works" and "feels native."

Where multilingual actually matters

Customer support — reply in the customer's language, not the agent's
Content & localization — draft in one language, adapt tone for another, without a translation middleman
E-commerce & reviews — parse and respond to reviews across markets
Multilingual search & chat — let users ask in whatever language they think in

Each of these is a place where a translate-first hack degrades quality — and where a multilingual model just… works.

A language-aware model stack

AIBridge doesn't make you bet the whole product on one model. The Qwen family carries the multilingual load, while the rest of the menu covers everything else:

Need	Model	Why
Multilingual + long context	`qwen-max`	Tuned for multilingual tasks, 32K context
Cost-effective multilingual at scale	`qwen-plus`	131K context, lower cost
Flagship general quality	`qwen3-235b-a22b`	Best overall Qwen3
Reasoning / math / logic	`deepseek-reasoner`	Chain-of-thought
Code	`deepseek-coder`	Purpose-built for code
1M-context documents	`kimi-k3`	Million-token window

Same endpoint, same key — you route each request to the model that fits, language included.

The full menu

Qwen — qwen-max, qwen-plus (131K), qwen3-235b-a22b
DeepSeek — deepseek-v4-pro, deepseek-v4-flash, deepseek-reasoner, deepseek-coder, deepseek-chat
GLM — glm-4-plus, glm-4-air, glm-4-flash
Moonshot — kimi-k3 (1M context), moonshot-v1-128k / -32k / -8k

Pricing that works in every market

Free tier: 500K tokens/month (weighted)
Pro: $9.90/month for 5M tokens
Top-ups: 1M / $2.99 · 5M / $9.90 · 20M / $29.90 (never expire)

The takeaway

Your product speaks your users' language — or it doesn't. A multilingual model makes that a feature, not an afterthought.

Try qwen-max on a non-English request and feel the difference.

→ aibridge-api.com · support@aibridge-api.com

Your chat model guesses. A reasoning model works the problem.

Daniel Dong — Sun, 27 Sep 2026 14:48:05 +0000

Ask a chat model to prove a theorem and it might confidently say something plausible. Ask a reasoning model and it actually works through it — step by step, before it answers.

curl https://aibridge-api.com/v1/chat/completions \
  -H "Authorization: Bearer mb-xxxxxxxx" \
  -d '{
    "model": "deepseek-reasoner",
    "messages": [{"role": "user", "content": "Prove that sqrt(2) is irrational."}]
  }'

deepseek-reasoner spends its thinking budget before responding — exploring the problem, checking its work, then committing to an answer. For hard questions, that changes everything.

The two kinds of questions

Most of what we ask models falls into two buckets:

Recall & reformat — "summarize this", "rewrite that", "extract the date". One-shot, no deep thought required.
Reason & derive — "prove this", "find the bug", "which option is optimal". The answer depends on a chain of logic, not just memory.

A chat model handles bucket one beautifully. It stumbles on bucket two — not because it's bad, but because it answers in a single pass, and for multi-step reasoning, a single pass means guessing at the hard steps.

A reasoning model doesn't answer in one pass. It thinks first, then answers. The difference is the difference between "sounds right" and "is right."

When to reach for reasoning

Use deepseek-reasoner (or kimi-k3, which reasons by default) when the answer has to be derived, not retrieved:

Task	Chat model	Reasoning model
Summarize a doc	✅	Overkill
Rewrite copy	✅	Overkill
Math / proofs	Guesses	Derives
Multi-step logic	Fragile	Reliable
"Find the bug in this code"	May miss it	Traces it
Optimization / planning	Shallow	Explores alternatives

The rule of thumb: if you could answer it without scratch paper, a chat model is fine. If you'd need scratch paper, use a reasoning model.

Reasoning as one tier in a full stack

The point isn't "always use reasoning" — it's that you can now choose. AIBridge puts both modes behind one endpoint, so you route per question:

def model_for(prompt: str) -> str:
    if any(k in prompt.lower() for k in ("prove", "derive", "why", "optimize", "debug")):
        return "deepseek-reasoner"      # needs a chain of thought
    return "deepseek-chat"              # recall & reformat

Cheap chat model for the easy 90% of traffic, reasoning model for the hard 10% that actually needs it. You're not paying reasoning-token prices for a "summarize this email."

The full model menu

DeepSeek — deepseek-reasoner, deepseek-v4-pro, deepseek-v4-flash, deepseek-coder, deepseek-chat
Qwen — qwen3-235b-a22b, qwen-plus (131K), qwen-max
GLM — glm-4-plus, glm-4-air, glm-4-flash
Moonshot — kimi-k3 (1M context, always-on reasoning), moonshot-v1-128k / -32k / -8k

Pricing that doesn't punish thinking

Free tier: 500K tokens/month (weighted)
Pro: $9.90/month for 5M tokens
Top-ups: 1M / $2.99 · 5M / $9.90 · 20M / $29.90 (never expire)

The takeaway

The right model depends on the question, not the product. Give recall to the chat model, give reasoning to the reasoner — and let both live on one endpoint.

Try deepseek-reasoner on a problem your chat model keeps flubbing.

→ aibridge-api.com · support@aibridge-api.com

# A purpose-built coding model, one endpoint — no IDE plugin required

Daniel Dong — Sat, 26 Sep 2026 10:17:21 +0000

General-purpose models write passable code. A purpose-built coding model writes code that's correct. Here's the difference, in one request.

curl https://aibridge-api.com/v1/chat/completions \
  -H "Authorization: Bearer mb-xxxxxxxx" \
  -d '{
    "model": "deepseek-coder",
    "messages": [
      {"role": "system", "content": "You are an expert programmer. Fix bugs with minimal, correct changes."},
      {"role": "user", "content": "This function throws IndexError on empty input. Fix it:\n\n<code>"}
    ]
  }'

deepseek-coder is tuned for exactly this — code generation, debugging, review, and refactoring. And it lives behind the same OpenAI-compatible endpoint as the general models, so you reach it with the SDK you already use.

Why "it writes code" isn't the same as "it's for code"

A general chat model can produce code. It just wasn't optimized for it. The differences show up where it matters:

Correctness over fluency — a coding model prioritizes working output over natural-sounding output
Edge cases — empty inputs, nulls, boundary conditions that a chat model might gloss over
Minimal diffs — when you ask for a fix, you want the smallest correct change, not a rewrite
Idiomatic code — it knows the conventions and APIs of the language you're in

That's the niche deepseek-coder fills. For the harder, reasoning-heavy stuff — design a system, prove an algorithm, untangle a gnarly bug — you pair it with deepseek-v4-pro or deepseek-reasoner. A coding stack, not a coding tool.

A coding workflow, one endpoint

Task	Model	Why
Autocomplete / boilerplate	`deepseek-coder`	Fast, idiomatic, low cost
Bug fix with a minimal diff	`deepseek-coder`	Correct, edge-case aware
Code review & critique	`deepseek-coder`	Reads like a senior reviewer
Refactor & explain	`deepseek-v4-pro`	Reasoning over structure
Algorithm design / proofs	`deepseek-reasoner`	Chain-of-thought for hard problems

Every step through the same key, the same SDK, the same stream: true you'd use anywhere else. No new IDE plugin to install, no separate subscription to manage.

Why an endpoint beats an IDE plugin

Coding copilots are great inside the editor. But a lot of code work happens outside it:

CI pipelines — generate tests, summarize a PR, flag risky changes
Backend services — a code-review bot that runs on every commit
CLI tools & scripts — a fix-my-tests command, a generate-changelog command
Custom tooling — anything where you control the prompt and the flow

An API gives you that. A plugin gives you a chat box.

The full model menu

DeepSeek — deepseek-coder, deepseek-v4-pro, deepseek-v4-flash, deepseek-reasoner, deepseek-chat
Qwen — qwen3-235b-a22b, qwen-plus (131K), qwen-max
GLM — glm-4-plus, glm-4-air, glm-4-flash
Moonshot — kimi-k3 (1M context), moonshot-v1-128k / -32k / -8k

Pricing that keeps coding cheap

Free tier: 500K tokens/month (weighted)
Pro: $9.90/month for 5M tokens
Top-ups: 1M / $2.99 · 5M / $9.90 · 20M / $29.90 (never expire)

The takeaway

You don't need another subscription or another plugin to get serious about AI-assisted coding. You need a coding model on the endpoint you already call.

Generate, debug, and review with deepseek-coder — free tier included.

→ aibridge-api.com · support@aibridge-api.com

# From zero to your first AI request in 2 minutes — no credit card

Daniel Dong — Mon, 21 Sep 2026 13:13:45 +0000

Most AI platforms make you prove yourself before you can even look: create an account, enter a card, prepay, then find out if the thing works for you. That's backwards.

Here's the whole onboarding at AIBridge:

# 1. Sign in with GitHub.  2. Grab your key.  3. Run this.
curl https://aibridge-api.com/v1/chat/completions \
  -H "Authorization: Bearer mb-xxxxxxxx" \
  -d '{"model":"deepseek-v4-pro","messages":[{"role":"user","content":"Explain why the sky is blue."}]}'

That's it. Sign in with your existing GitHub account, copy your key, and you're making real requests to 15 different models — with 500K free tokens and no card on file.

The paywall-before-proof problem

The standard AI-tool funnel asks for trust before it earns it:

Create an account (name, email, verify)
Add a payment method
Prepay or commit to a tier
Finally run your first real request

Steps 2 and 3 are a gate. If the model turns out wrong for your use case — a thing you could've learned in five minutes — you've already handed over a card for the privilege of finding out.

Flip it: proof before paywall

AIBridge inverts the order. The first thing you get is working, not billing:

Sign in with GitHub OAuth — no new username/password to invent or forget
500K free tokens (weighted) — enough to genuinely evaluate, not a 3-request teaser
15 models, all unlocked — the free tier isn't a walled garden; you can test the flagships too
Playground included — try prompts in the browser before you even write the curl

You can decide whether AIBridge fits before spending a cent. That's the point.

The 2-minute path, step by step

Hit sign-in — GitHub OAuth, two clicks, done
Copy your mb- key from the dashboard
Paste the curl above (or open the Playground and skip code entirely)
Toggle models — deepseek-v4-pro, qwen3-235b-a22b, glm-4-plus, kimi-k3, see what sticks
Decide with data — if it fits, upgrade when you're ready, not before

No card. No prepay. No "we'll bill you in 7 days" fine print.

What's behind the door

DeepSeek — deepseek-v4-pro, deepseek-v4-flash, deepseek-reasoner, deepseek-coder, deepseek-chat
Qwen — qwen3-235b-a22b, qwen-plus (131K), qwen-max
GLM — glm-4-plus, glm-4-air, glm-4-flash
Moonshot — kimi-k3 (1M context), moonshot-v1-128k / -32k / -8k

When you're ready to upgrade

Free: 500K tokens/month (weighted)
Pro: $9.90/month for 5M tokens
Top-ups: 1M / $2.99 · 5M / $9.90 · 20M / $29.90 (never expire)

The takeaway

You shouldn't have to trust an AI platform before you've tried it. You should try it in two minutes, free, and then decide if it earns your card.

Start with 500K free tokens — no credit card required.

→ aibridge-api.com · support@aibridge-api.com

# Test 15 AI models before you write a single line of code

Daniel Dong — Sun, 20 Sep 2026 12:37:38 +0000

The worst time to find out a model is wrong for your task is after you've wired it into production. The best time is in the first five minutes — in a browser, before any code exists.

# You *can* start here…
curl https://aibridge-api.com/v1/chat/completions \
  -H "Authorization: Bearer mb-xxxxxxxx" \
  -d '{"model":"deepseek-v4-pro","messages":[{"role":"user","content":"Summarize this policy."}]}'

…but you don't have to. AIBridge ships a Playground in the dashboard, so you can fire that same request at 15 models with zero setup and zero code.

The wrong way to pick a model

The standard evaluation flow is backwards. You:

Read a blog post about "the best model"
Install an SDK
Write a test script
Wire it up, run it, and only then discover the output doesn't fit your use case

Every step before step 4 is a tax you paid to learn something the browser could've told you in seconds.

The right way: try before you build

The Playground flips the order:

Type your real prompt — not a toy "hello world", but the actual input your product will send
Switch models with a dropdown — DeepSeek, Qwen, GLM, Moonshot, all 15, side by side
See the difference immediately — reasoning quality, output format, tone, speed, all visible at a glance
Then, and only then, write code — you already know which model won, so the code you write is code you keep

It's the difference between building to find out and finding out to build.

What the Playground actually changes

Without it	With it
"I'll try model X and see"	"I already saw model X, Y, and Z — Y wins"
Days of setup to compare	Minutes, no setup
The blog's benchmark made your choice	Your own prompt made your choice
Code first, regret later	Decide first, code once

The common thread: you move the expensive learning before the expensive building.

A loop that costs you nothing

Because the free tier gives you real quota, the Playground is a sandbox you can actually use:

Paste the prompt you care about
Toggle through deepseek-v4-pro, qwen3-235b-a22b, glm-4-plus, kimi-k3…
Note which one nails the format, tone, and speed
Grab the equivalent curl/SDK snippet and ship it

By the time you touch a code editor, the "which model" question is already answered.

The full menu waiting in the dropdown

DeepSeek — deepseek-v4-pro, deepseek-v4-flash, deepseek-reasoner, deepseek-coder, deepseek-chat
Qwen — qwen3-235b-a22b, qwen-plus (131K), qwen-max
GLM — glm-4-plus, glm-4-air, glm-4-flash
Moonshot — kimi-k3 (1M context), moonshot-v1-128k / -32k / -8k

Pricing that makes exploring free

Free tier: 500K tokens/month (weighted)
Pro: $9.90/month for 5M tokens
Top-ups: 1M / $2.99 · 5M / $9.90 · 20M / $29.90 (never expire)

The takeaway

Don't read your way to a model choice. Click your way to one.

Try all 15 models in the Playground, free — then write the code that actually fits.

→ aibridge-api.com · support@aibridge-api.com

Stop rewriting the same prompt. It's your most valuable asset.

Daniel Dong — Mon, 14 Sep 2026 14:01:29 +0000

You spent three hours getting that system prompt just right. Then you pasted it into a chat, got your answer, and watched it disappear into the scrollback — doomed to be rewritten from scratch next month.

# Your carefully-tuned system prompt, reused across models — not rewritten
curl https://aibridge-api.com/v1/chat/completions \
  -H "Authorization: Bearer mb-xxxxxxxx" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [
      {"role": "system", "content": "You are a senior code reviewer. Flag bugs, security issues, and readability problems. Be specific."},
      {"role": "user", "content": "Review this PR diff:\n\n<diff>"}
    ]
  }'

Same system block tomorrow, next month, on a different model if you want. A good prompt is reusable code for the model's brain — and it deserves better than a notes app.

The prompt-amnesia cycle

Most teams treat prompts as disposable. The result is a quiet tax:

Rewrite cost — every new session re-derives what you already solved
Quality drift — "close enough" rewrites that silently underperform the original
No versioning — you tweak a prompt, it works, and you can't remember what you changed
Knowledge silos — the best prompt lives in one person's head, not the team's toolkit

Contrast that with how you treat code. Code gets committed, reviewed, versioned, and reused. Your prompts should get the same treatment — because they are logic.

A prompt library is just source control for prompts

AIBridge ships a prompt library built into the dashboard, so your best prompts stop being ephemeral:

Save once, reuse forever — your validated prompts live in one place, not in chat scrollback
Test in the Playground — run a prompt against any of 15 models before wiring it into code
Swap models without rewriting — the same prompt against deepseek-v4-pro, glm-4-flash, or kimi-k3; the prompt doesn't care, you just change one field
Keep the good versions — when you iterate, the winning prompt survives instead of being overwritten

The workflow becomes: write → test → save → reuse. Instead of write → lose → rewrite → guess.

What this unlocks

Onboarding at speed — a new teammate inherits your prompt library instead of your tribal knowledge
Consistent output — everyone calls the same tuned prompt, so the product's "voice" stays stable
Cheap experimentation — fork a saved prompt, tweak one line, A/B the results in the Playground, keep the winner

Prompts are cheap to store and expensive to lose. The asymmetry favors saving everything.

The full model menu behind it

DeepSeek — deepseek-v4-pro, deepseek-v4-flash, deepseek-reasoner, deepseek-coder, deepseek-chat
Qwen — qwen3-235b-a22b, qwen-plus (131K), qwen-max
GLM — glm-4-plus, glm-4-air, glm-4-flash
Moonshot — kimi-k3 (1M context), moonshot-v1-128k / -32k / -8k

Pricing that makes saving free

Free tier: 500K tokens/month (weighted)
Pro: $9.90/month for 5M tokens
Top-ups: 1M / $2.99 · 5M / $9.90 · 20M / $29.90 (never expire)

The takeaway

Your prompt library is your competitive moat, one saved prompt at a time. Stop treating your best work like a throwaway.

Save it. Reuse it. Ship it.

→ aibridge-api.com · support@aibridge-api.com

Your users don't wait. Here's why streaming matters more than model size.

Daniel Dong — Fri, 11 Sep 2026 14:20:24 +0000

You can have the smartest model in the world, and if the first word takes eight seconds, your users will call it "broken." The difference between AI magic and AI feels slow is one flag.

from openai import OpenAI

client = OpenAI(
    api_key="mb-xxxxxxxx",
    base_url="https://aibridge-api.com/v1",
)

stream = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Write a short story about a robot."}],
    stream=True,
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

That stream=True is the entire feature. Tokens start arriving almost immediately, instead of the whole answer landing at once after a blank screen.

The dead-air problem

Non-streaming LLM calls have a brutal UX curve: the user hits enter, and then… nothing. For a long generation, that silence can stretch 5–15 seconds while the model drafts the entire response in memory before returning anything.

What users do during that silence:

Think it's frozen and click again (double-spend, double-billing)
Think it's broken and abandon
Feel the weight of every second — perceived latency is always worse than measured latency

Streaming collapses that wait to time-to-first-token — usually well under a second. After that, words flow as they're generated, and the user watches progress instead of staring at a spinner. The total time is the same. The perceived time is night-and-day.

The UX numbers that actually matter

Metric	Non-streaming	Streaming
Time to first visible output	5–15s	< 1s
User perception	"It's thinking…"	"It's answering"
Double-submit risk	High (feels stuck)	Low (feels alive)
Perceived latency	Full generation time	Time to first token

None of this requires a faster model. It requires stream: true — and an endpoint that implements it correctly.

Streaming works on every model

Because AIBridge speaks the OpenAI wire format, streaming is first-class across all 15 models. Want it snappier? Pair streaming with a fast tier:

# Autocomplete / suggestions — sub-second feels instant
stream = client.chat.completions.create(
    model="glm-4-flash",          # fast tier
    messages=[{"role": "user", "content": "Continue: 'The quick brown fox'"}],
    stream=True,
)

Fast tier — glm-4-flash, deepseek-v4-flash, moonshot-v1-8k for keystroke-speed interactions
Balanced tier — glm-4-air, deepseek-chat, qwen-plus for everyday generation
Flagship tier — deepseek-v4-pro, qwen3-235b-a22b, glm-4-plus for quality that earns the wait
Deep reasoning — deepseek-reasoner, kimi-k3 for genuinely hard problems

Stream the fast models for real-time surfaces; stream the flagships so even long answers feel immediate.

The full stack, one endpoint

15 models · 4 vendors · one OpenAI-compatible key:

DeepSeek — deepseek-v4-pro, deepseek-v4-flash, deepseek-reasoner, deepseek-coder, deepseek-chat
Qwen — qwen3-235b-a22b, qwen-plus (131K), qwen-max
GLM — glm-4-plus, glm-4-air, glm-4-flash
Moonshot — kimi-k3 (1M context), moonshot-v1-128k / -32k / -8k

Pricing that doesn't punish snappiness

Free tier: 500K tokens/month (weighted)
Pro: $9.90/month for 5M tokens
Top-ups: 1M / $2.99 · 5M / $9.90 · 20M / $29.90 (never expire)

The takeaway

Before you reach for a bigger model, reach for stream: true. Your users will feel the difference long before they notice the intelligence.

Stream all 15 models free.

→ aibridge-api.com · support@aibridge-api.com

Your OpenAI SDK already works here. Change three lines, unlock 15 models.

Daniel Dong — Wed, 09 Sep 2026 15:16:04 +0000

You don't need a new client library. You don't need to learn a new API surface. You need to change two values in code you already wrote.

from openai import OpenAI

client = OpenAI(
    api_key="mb-xxxxxxxx",                  # ← AIBridge key
    base_url="https://aibridge-api.com/v1", # ← the only URL change
)

resp = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Explain quicksort in one paragraph."}],
)
print(resp.choices[0].message.content)

That's it. If that snippet ran in your head without Googling, you already know everything you need to use AIBridge — because it is the OpenAI SDK.

The migration tax is a myth

The usual story when you add a new model vendor goes like this: read their docs, install their SDK, learn their auth flow, map their types to your types, then rewrite every call site.

AIBridge strips that to zero. It speaks the OpenAI wire format — same endpoints, same request/response JSON, same error codes, same stream: true semantics. So "migrating" to 15 Chinese models is a config change, not a code change.

Here's the same idea in Node, for the TypeScript crowd:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "mb-xxxxxxxx",
  baseURL: "https://aibridge-api.com/v1",
});

const resp = await client.chat.completions.create({
  model: "qwen3-235b-a22b",
  messages: [{ role: "user", content: "Summarize this changelog." }],
});
console.log(resp.choices[0].message.content);

Switching from DeepSeek to Qwen to GLM to Kimi is just changing the model string. Every call site, every streaming handler, every retry wrapper you already wrote keeps working unchanged.

What that unlocks in practice

Once the SDK barrier is gone, the interesting doors open:

A/B test 15 models on your real traffic with a loop, not a migration project
Failover across 4 vendors by catching an error and re-calling with a different model
Match the model to the job — glm-4-flash for autocomplete, deepseek-v4-pro for hard reasoning
Reach for 1M context with kimi-k3 when the input is a whole repo, not a sentence

All of it through the client you already trust.

The full model menu

DeepSeek — deepseek-v4-pro, deepseek-v4-flash, deepseek-reasoner, deepseek-coder, deepseek-chat
Qwen — qwen3-235b-a22b, qwen-plus (131K), qwen-max
GLM — glm-4-plus, glm-4-air, glm-4-flash
Moonshot — kimi-k3 (1M context), moonshot-v1-128k / -32k / -8k

15 models, 4 vendors, one OpenAI-compatible contract.

Pricing without a migration cost either

Free tier: 500K tokens/month (weighted)
Pro: $9.90/month for 5M tokens
Top-ups: 1M / $2.99 · 5M / $9.90 · 20M / $29.90 (never expire)

The takeaway

The best migration is the one where the diff is two lines and the rest of your codebase doesn't notice.

Point your OpenAI SDK at https://aibridge-api.com/v1 and keep shipping.

→ aibridge-api.com · support@aibridge-api.com

Your API key is a spending limit. Treat it like one.

Daniel Dong — Tue, 08 Sep 2026 15:23:17 +0000

The scariest thing about wiring an LLM into your product isn't the prompt — it's the moment a key leaks into a public repo and the meter starts running without you.

curl https://aibridge-api.com/v1/chat/completions \
  -H "Authorization: Bearer mb-xxxxxxxx" \
  -d '{"model":"deepseek-v4-pro","messages":[{"role":"user","content":"..."}]}'

One key, one meter, and — the important part — hard limits that actually stop requests, not polite warnings you find out about in next month's invoice.

The bill-explosion problem

Every LLM horror story follows the same script: a key gets committed to GitHub, a bot scrapes it, and someone wakes up to a four-figure bill. The key was never meant to be a blank check, but on most platforms, that's exactly what it is.

The problem isn't just the leak. It's the lack of a blast radius:

No hard quota → a leaked key can spend until you notice
No rate limit → a runaway retry loop can drain you in hours
Per-vendor keys → four keys means four leak surfaces, four places to rotate

Security that's boring on purpose

AIBridge puts guardrails in front of the models, so a key can't act like an unlimited credit card:

Per-token atomic quota — a hard ceiling that stops the request, not just flags it after the fact
Rate limiting — caps requests-per-window so a buggy loop can't spiral
One key, not four — a single mb- credential for all 15 models, so there's one thing to rotate when you need to
Usage dashboard with a live bar — you see your spend as it happens, not at reconciliation time

The goal: if something goes wrong, the damage is a bounded number you set — not a surprise you discover.

The habits that pair with it

The tools only help if you use them like you mean it:

Never hardcode the key — pull it from process.env / secrets manager, always
Rotate on any suspicion — with one key, rotation is a five-minute job instead of a five-account ordeal
Set your quota deliberately — leave headroom for growth, but not for catastrophe
Watch the dashboard weekly — a usage bar that climbs unexpectedly is your earliest alarm

That's the whole security posture. No custom middleware, no WAF config, no SOC-2 audit — just sane defaults baked into the endpoint.

What's behind the key

15 models across 4 vendors, all callable with that single credential:

DeepSeek — deepseek-v4-pro, deepseek-v4-flash, deepseek-reasoner, deepseek-coder, deepseek-chat
Qwen — qwen3-235b-a22b, qwen-plus, qwen-max
GLM — glm-4-plus, glm-4-air, glm-4-flash
Moonshot — kimi-k3 (1M context), moonshot-v1-128k / -32k / -8k

Pricing with a ceiling built in

Free tier: 500K tokens/month (weighted)
Pro: $9.90/month for 5M tokens
Top-ups: 1M / $2.99 · 5M / $9.90 · 20M / $29.90 (never expire)

The takeaway

A leaked key should cost you a rotation, not a mortgage payment. Put your spend behind a real limit and get back to building.

One key. Hard limits. Fifteen models.

→ aibridge-api.com · support@aibridge-api.com

Your users feel latency, not benchmarks

Daniel Dong — Sun, 06 Sep 2026 14:18:09 +0000

A model that takes 8 seconds to answer feels broken in a chat — no matter how "smart" the leaderboard says it is. Speed is a feature, and it's one you can buy per-request.

# Real-time autocomplete: you need the answer NOW, not the smartest answer
curl https://aibridge-api.com/v1/chat/completions \
  -H "Authorization: Bearer mb-xxxxxxxx" \
  -d '{"model":"glm-4-flash","stream":true,"messages":[{"role":"user","content":"Suggest the next word:"}]}'

Same endpoint as the heavy models. Same key. But glm-4-flash returns fast enough to keep a keystroke-level interaction feeling instant — while deepseek-v4-pro chews on the questions that actually deserve deep thought.

The latency tax on everything

Route every request to your biggest model and you're not just paying more in tokens. You're paying in seconds, and seconds are where products die:

Chat: users expect the first token in ~1s. A reasoning model that spends 6s "thinking" before streaming feels broken.
Autocomplete / suggestions: sub-second or it's useless. By the time a slow model answers, the user has already typed the rest.
Classification / moderation: this is a millisecond-scale gate in your pipeline. A slow model becomes a bottleneck.

The fix isn't a faster server. It's a smaller model on the hot path and a bigger model on the hard path.

Flash vs flagship: pick the tier, not just the vendor

AIBridge gives you the full speed/quality gradient in one place:

Tier	Models	Vibe
Fast	`glm-4-flash`, `deepseek-v4-flash`, `moonshot-v1-8k`	Sub-second first token, perfect for interactive surfaces
Balanced	`glm-4-air`, `deepseek-chat`, `qwen-plus`	Good quality at a comfortable clip
Flagship	`deepseek-v4-pro`, `qwen3-235b-a22b`, `glm-4-plus`	Max quality for the questions that earn it
Deep reasoning	`deepseek-reasoner`, `kimi-k3`	Chain-of-thought for genuinely hard problems

The pattern that emerges in every real product:

Hot path (autocomplete, classify, moderate, extract) → flash models, streamed
Main path (draft, summarize, translate) → balanced models
Hard path (reason, prove, plan, debug) → flagship / reasoning models
Impossible path (whole repo, full transcript) → kimi-k3 at 1M context

One endpoint carries all four. The model is just a parameter you set per call.

A routing rule that costs one line

def route(user_input: str) -> str:
    if len(user_input) < 12:        return "glm-4-flash"       # autocomplete, quickies
    if "explain" in user_input:     return "deepseek-v4-pro"   # wants depth
    if "prove" in user_input:       return "deepseek-reasoner" # needs reasoning
    return "deepseek-chat"                                    # sensible default

That's the whole trick. You don't need a model router service — you need a model menu.

Pricing that keeps the fast path cheap

Free tier: 500K tokens/month (weighted)
Pro: $9.90/month for 5M tokens
Top-ups: 1M / $2.99 · 5M / $9.90 · 20M / $29.90 (never expire)

Flash models draw from the same meter — so your speed tier is also your cost tier.

The takeaway

Latency is a product decision, not an infrastructure problem. Give the easy stuff to the fast models, and save the heavy lifting for the ones that earned it.

15 models, one endpoint, four speed tiers.

→ aibridge-api.com · support@aibridge-api.com