Systemdesign med flera modeller: När en modell inte räcker

Välj det enklaste mönster som fungerar.

Sidinnehåll

Enkelmodellsystem är enkla. Multimodellsystem är kraftfulla. Utmaningen ligger inte i att välja modeller, utan i att designa arkitekturen som dirigerar dem.

Ett multimodellsystem handlar inte om att ha fler modeller. Det handlar om att ha rätt modell för rätt uppgift vid rätt tillfälle.

Multi-model LLM system design patterns

Arkitekturmönster

Fem mönster täcker de flesta användningsfall:

Mönster Komplexitet När det ska användas Kompromiss
Enkel modell Lägst Prototyper, enkla uppgifter Begränsad kapacitet
Sekventiell Låg Flöden med flera steg Högre latens
Parallell Medel Oberoende uppgifter Högre kostnad
Hierarkisk Hög Komplext resonemang Komplex dirigering
Ensemble Högst Kritiska beslut Högst kostnad

Välj det enklaste som fungerar. Komplexitet är verklig, och den ackumuleras.

Sekventiell arkitektur

Bearbeta uppgifter genom en kedja av modeller, där varje modell specialiserar sig på ett steg.

Mönster 1: Pipeline

Pipelinemönster — varje modells utdata matas in i nästa:

class ModelPipeline:
    def __init__(self):
        self.models = [
            {"model": "qwen3-1.7b", "task": "classify"},
            {"model": "qwen3-8b", "task": "extract"},
            {"model": "qwen3-32b", "task": "reason"},
        ]

    def process(self, input: str) -> str:
        current = input
        for model_config in self.models:
            current = self.call_model(
                model_config["model"],
                self.create_prompt(model_config["task"], current)
            )
        return current

Latensen adderas. Tre modeller i sekvens innebär tre gånger latensen. Använd detta endast när varje steg faktiskt behöver en annan modell.

Mönster 2: Router

Rutermönster — klassificera uppgiften, rutt till specialisten:

class ModelRouter:
    def __init__(self):
        self.classifier = "qwen3-1.7b"
        self.specialists = {
            "code": "qwen2.5-coder-7b",
            "math": "qwen3-32b",
            "creative": "claude-sonnet-4",
            "general": "qwen3-8b",
        }

    def route(self, prompt: str) -> str:
        task_type = self.classify(prompt)
        model = self.specialists.get(task_type, self.specialists["general"])
        return self.call_model(model, prompt)

Klassificeraren är den svaga länken. Om den klassificerar fel, ruttas du till fel modell och förlorar kvalitet. Använd en klassificerare som är tillräckligt bra — även en liten fungerar om kategorierna är tydliga.

Parallell arkitektur

Bearbeta oberoende uppgifter samtidigt.

Mönster 1: Fan-Out

Fan-out (utbredning) — kör samma prompt genom flera modeller:

import asyncio

class ModelFanOut:
    def __init__(self):
        self.models = [
            "qwen3-8b",
            "qwen3-32b",
            "claude-sonnet-4",
        ]

    async def process(self, prompt: str) -> list[str]:
        tasks = [self.call_model(model, prompt) for model in self.models]
        return await asyncio.gather(*tasks)

Användbart för jämförelse, A/B-testning eller när du vill välja den bästa utdata. Dyrt, men kvalitetsvinsten är värd det vid kritiska beslut.

Mönster 2: Voting

Röstning — kombinera utdata genom konsensus:

class ModelVoting:
    def __init__(self):
        self.models = [
            "qwen3-8b",
            "qwen3-32b",
            "claude-sonnet-4",
        ]

    def vote(self, prompt: str) -> str:
        responses = [self.call_model(model, prompt) for model in self.models]
        from collections import Counter
        votes = Counter(responses)
        return votes.most_common(1)[0][0]

Majoritetsröstning fungerar för klassificering. För genereringsuppgifter är det svårare — du behöver semantisk likhet, inte exakta matchningar.

Hierarkisk arkitektur

Använd modeller på olika abstraktionsnivåer.

Mönster 1: Planner-Executor

Planerare-exekutor — en stark modell planerar, mindre modeller exekverar:

class PlannerExecutor:
    def __init__(self):
        self.planner = "qwen3-32b"
        self.executors = {
            "code": "qwen2.5-coder-7b",
            "search": "qwen3-8b",
            "math": "qwen3-8b",
        }

    def process(self, task: str) -> str:
        plan = self.call_model(self.planner, f"Plan: {task}")
        results = []
        for step in self.parse_plan(plan):
            executor = self.executors.get(step["type"], "qwen3-8b")
            result = self.call_model(executor, step["prompt"])
            results.append(result)
        return self.call_model(self.planner, f"Synthesize: {results}")

Planeraren gör den tunga jobbet. Exekutorerna hanterar specifika uppgifter. Detta mönster fungerar bra när planeringssteget är dyrt men exekveringsstegen är billiga.

Mönster 2: Supervisor-Worker

Supervisor-worker (övervakare-arbetare) — en övervakare delegerar och granskar:

class SupervisorWorker:
    def __init__(self):
        self.supervisor = "qwen3-32b"
        self.workers = ["qwen3-8b", "qwen2.5-coder-7b"]

    def process(self, task: str) -> str:
        assignments = self.call_model(self.supervisor, f"Assign: {task}")
        results = []
        for assignment in self.parse_assignments(assignments):
            result = self.call_model(
                assignment["worker"], assignment["task"]
            )
            results.append(result)
        return self.call_model(self.supervisor, f"Review: {results}")

Övervakaren är flaskhalsen. Den planerar, delegerar och granskar. Se till att den är tillräckligt snabb, annars hela systemet bromsar in.

Ensemblearkitektur

Kombinera flera modeller för kritiska beslut.

Mönster 1: Weighted Ensemble

Vägt ensemble — poängsätt varje modells utdata, välj den högsta:

class WeightedEnsemble:
    def __init__(self):
        self.models = {
            "qwen3-32b": 0.5,
            "claude-sonnet-4": 0.3,
            "qwen3-8b": 0.2,
        }

    def decide(self, prompt: str) -> str:
        responses = {
            model: self.call_model(model, prompt)
            for model in self.models
        }
        scores = {}
        for model, response in responses.items():
            score = self.evaluate(response) * self.models[model]
            scores[response] = scores.get(response, 0) + score
        return max(scores, key=scores.get)

Vikten speglar ditt förtroende för varje modell. Justera dem baserat på faktisk prestanda, inte benchmarkresultat.

Mönster 2: Consensus Ensemble

Konsensusensemble — kräv överensstämmelse, eskalera om det inte finns någon:

class ConsensusEnsemble:
    def __init__(self, threshold: float = 0.7):
        self.threshold = threshold
        self.models = [
            "qwen3-32b",
            "claude-sonnet-4",
            "qwen3-8b",
        ]

    def decide(self, prompt: str) -> str:
        responses = [
            self.call_model(model, prompt)
            for model in self.models
        ]
        from collections import Counter
        votes = Counter(responses)
        max_votes = max(votes.values())

        if max_votes / len(self.models) >= self.threshold:
            return votes.most_common(1)[0][0]

        return self.call_model("qwen3-32b", prompt)

Tröskeln styr hur strikt konsensus är. 0.7 innebär två tredjedelar överensstämmelse. Sänk den för snabbare beslut, höj den för högre säkerhet.

När multimodellsystem är lämpliga

Multimodellsystem är lämpliga när du har blandade arbetsbelastningar, behöver hög kvalitet vid kritiska beslut, eller optimerar för kostnad eller latens.

De är inte lämpliga när alla uppgifter har liknande komplexitet, du prototyper, eller enkelhet värderas högre än optimering.

Fingerregel: börja med en modell. Lägg till fler när du stöter på en verklig begränsning — kostnad, latens eller kvalitet. Bygg inte komplexitet innan du behöver den.

Kompromisser

Mönster Kostnad Latens Kvalitet Komplexitet
Enkel modell Lägst Lägst Variabel Lägst
Sekventiell Medel Hög Hög Medel
Parallell Hög Låg Hög Medel
Hierarkisk Hög Hög Högst Hög
Ensemble Högst Medel Högst Högst

Varje mönster byter något mot något. Välj det som matchar dina begränsningar.

Relaterat

Prenumerera

Få nya inlägg om system, infrastruktur och AI-ingenjörskonst.