Building Multi-Model AI Applications

Why Use Multiple AI Models?

No single AI model is best at everything. By routing different tasks to specialized models, you can:

• Improve quality - Use the best model for each specific task
• Reduce costs - Route simple tasks to cheaper models
• Increase reliability - Fallback to alternative models on failure
• Handle diverse content - Different languages, formats, and domains

Model Selection Guide

Task Type	Best Model	Why
Code generation & debugging	DeepSeek V4	Superior reasoning, concise output
Chinese content & analysis	GLM-5.1	Native Chinese understanding
Multilingual translation	Qwen-Plus	Strong across 30+ languages
Long document analysis	Kimi K2.6	2M token context window
Fast responses & chat	Doubao Pro	Lowest latency, efficient
Creative writing	DeepSeek V4	Rich, nuanced output
Data extraction (JSON)	GLM-5.1	Reliable structured output

Smart Model Routing

The simplest approach: route by task type:

from openai import OpenAI

client = OpenAI(
    base_url="https://tokenease.io/v1",
    api_key="your_tokenease_api_key"
)

MODEL_ROUTER = {
    "code": "deepseek",
    "chinese": "zhipu",
    "translation": "qwen",
    "long_doc": "kimi",
    "fast_chat": "doubao",
    "creative": "deepseek",
    "extraction": "zhipu"
}

def chat(task_type, messages, **kwargs):
    model = MODEL_ROUTER.get(task_type, "deepseek")
    return client.chat.completions.create(
        model=model,
        messages=messages,
        **kwargs
    )

# Usage
response = chat("code", [
    {"role": "user", "content": "Write a Python function to validate email addresses"}
])

Content-Based Routing

For smarter routing, analyze the input first:

import re

def detect_language(text):
    if re.search(r'[\u4e00-\u9fff]', text):
        return "chinese"
    return "english"

def detect_code_request(text):
    code_keywords = ["function", "class", "def ", "import ", "code", "program", "script"]
    return any(kw in text.lower() for kw in code_keywords)

def auto_route(text):
    if detect_code_request(text):
        return "deepseek"
    if detect_language(text) == "chinese":
        return "zhipu"
    if len(text) > 10000:
        return "kimi"  # Long document
    return "deepseek"  # Default

response = client.chat.completions.create(
    model=auto_route(user_input),
    messages=[{"role": "user", "content": user_input}]
)

Model Ensembling

For critical tasks, run multiple models and pick the best response:

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://tokenease.io/v1",
    api_key="your_tokenease_api_key"
)

async def multi_model_generate(messages, models=["deepseek", "zhipu", "qwen"]):
    """Generate with multiple models, return all responses"""
    tasks = [
        client.chat.completions.create(
            model=m, messages=messages, max_tokens=500
        )
        for m in models
    ]
    responses = await asyncio.gather(*tasks, return_exceptions=True)
    
    results = []
    for model, resp in zip(models, responses):
        if isinstance(resp, Exception):
            results.append({"model": model, "error": str(resp)})
        else:
            results.append({
                "model": model,
                "content": resp.choices[0].message.content,
                "tokens": resp.usage.total_tokens
            })
    return results

# Usage
results = asyncio.run(multi_model_generate([
    {"role": "user", "content": "Write a haiku about programming"}
]))

for r in results:
    print(f"\n{r['model']} ({r.get('tokens', 'N/A')} tokens):")
    print(r.get('content', r.get('error')))

Fallback Strategies

Handle model failures gracefully:

async def generate_with_fallback(messages, primary="deepseek", fallbacks=["zhipu", "qwen", "kimi"]):
    """Try primary model, fall back on failure"""
    for model in [primary] + fallbacks:
        try:
            resp = await client.chat.completions.create(
                model=model, messages=messages, timeout=30
            )
            return {
                "success": True,
                "model_used": model,
                "content": resp.choices[0].message.content
            }
        except Exception as e:
            print(f"{model} failed: {e}")
            continue
    
    return {"success": False, "error": "All models failed"}

Tiered Fallback by Cost

Start with the best model, downgrade on budget constraints:

COST_TIERS = {
    "premium": ["deepseek", "zhipu"],      # Best quality
    "standard": ["qwen", "kimi"],          # Good balance
    "budget": ["doubao"]                   # Cheapest
}

async def tiered_generate(messages, tier="premium"):
    models = COST_TIERS.get(tier, COST_TIERS["premium"])
    return await generate_with_fallback(messages, models[0], models[1:])

Full Example: Smart Writer App

Here's a complete multi-model writing assistant:

class SmartWriter:
    def __init__(self, api_key):
        self.client = OpenAI(
            base_url="https://tokenease.io/v1",
            api_key=api_key
        )
    
    def write(self, prompt, content_type="blog"):
        """Route to best model based on content type"""
        model_map = {
            "code": "deepseek",
            "blog": "deepseek",
            "chinese_blog": "zhipu",
            "translation": "qwen",
            "long_article": "kimi",
            "quick_reply": "doubao"
        }
        
        model = model_map.get(content_type, "deepseek")
        
        system_prompts = {
            "code": "You are an expert programmer. Write clean, well-documented code.",
            "blog": "You are a professional writer. Create engaging, SEO-friendly content.",
            "chinese_blog": "你是专业作家。创作引人入胜、适合SEO的中文内容。",
            "translation": "You are a professional translator. Preserve tone and meaning.",
            "long_article": "You are a researcher. Write comprehensive, well-structured articles.",
            "quick_reply": "You are a helpful assistant. Give concise, accurate responses."
        }
        
        response = self.client.chat.completions.create(
            model=model,
            messages=[
                {"role": "system", "content": system_prompts.get(content_type, "")},
                {"role": "user", "content": prompt}
            ],
            temperature=0.7,
            max_tokens=2000
        )
        
        return {
            "content": response.choices[0].message.content,
            "model": model,
            "tokens": response.usage.total_tokens
        }

# Usage
writer = SmartWriter("your_tokenease_api_key")

# Write a blog post
blog = writer.write("Write about AI API gateways", "blog")
print(f"Blog ({blog['model']}, {blog['tokens']} tokens):\n{blog['content'][:200]}...")

# Write Chinese content
chinese = writer.write("介绍人工智能API网关的优势", "chinese_blog")
print(f"\nChinese ({chinese['model']}):\n{chinese['content'][:100]}...")

# Generate code
code = writer.write("Create a React button component", "code")
print(f"\nCode ({code['model']}):\n{code['content'][:150]}...")

Cost Analysis

Running this multi-model app for 100K tokens/month:

Approach	Cost	Quality
Single model (DeepSeek only)	$15	Good for most tasks
Smart routing (this guide)	$12-18	Best for each task
Ensembling (3 models)	$45	Highest quality
OpenAI GPT-4o only	$125	Single model baseline