Design de Sistemas Multi-Modelo: Quando Um Único Modelo Não É Suficiente

Escolha o padrão mais simples que funcione.

Conteúdo da página

Sistemas de modelo único são simples. Sistemas de múltiplos modelos são poderosos. O desafio não é escolher os modelos, mas sim projetar a arquitetura que os orquestra.

Um sistema de múltiplos modelos não se trata apenas de ter mais modelos. Trata-se de ter o modelo certo, para a tarefa certa, no momento certo.

Padrões de design de sistemas LLM multi-modelo

Padrões de arquitetura

Cinco padrões cobrem a maioria dos casos de uso:

Padrão Complexidade Quando usar Compromisso (Trade-off)
Modelo Único Mais baixa Prototipagem, tarefas simples Capacidade limitada
Sequencial Baixa Fluxos de trabalho em múltiplos passos Maior latência
Paralelo Média Tarefas independentes Maior custo
Hierárquico Alta Raciocínio complexo Orquestração complexa
Ensemble (Conjunto) Maior Decisões críticas Maior custo

Escolha o mais simples que funcione. A complexidade é real e ela se acumula.

Arquitetura sequencial

Processe tarefas através de uma cadeia de modelos, cada um especializado em uma etapa.

Padrão 1: Pipeline (Balcão)

Padrão Pipeline — a saída de cada modelo alimenta o próximo:

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

A latência acumula-se. Três modelos em sequência significam três vezes a latência. Use isso apenas quando cada etapa realmente precisar de um modelo diferente.

Padrão 2: Roteador (Router)

Padrão Roteador — classifique a tarefa e encaminhe para o especialista:

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)

O classificador é o elo fraco. Se ele classificar erroneamente, você encaminha para o modelo errado e perde qualidade. Use um classificador que seja bom o suficiente — até um pequeno funciona se as categorias forem claras.

Arquitetura paralela

Processe tarefas independentes simultaneamente.

Padrão 1: Fan-Out (Distribuição)

Fan-out — execute o mesmo prompt através de múltiplos modelos:

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)

Útil para comparação, testes A/B ou quando você deseja escolher a melhor saída. É caro, mas o ganho de qualidade compensa para decisões críticas.

Padrão 2: Votação

Votação — combine as saídas através de consenso:

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]

A votação por maioria funciona para classificação. Para tarefas de geração, é mais difícil — você precisa de similaridade semântica, não de correspondências exatas.

Arquitetura hierárquica

Use modelos em diferentes níveis de abstração.

Padrão 1: Planejador-Executor

Planejador-executor — um modelo forte planeja, modelos menores executam:

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}")

O planejador faz o trabalho pesado. Os executores lidam com tarefas específicas. Este padrão funciona bem quando a etapa de planejamento é cara, mas as etapas de execução são baratas.

Padrão 2: Supervisor-Trabalhador

Supervisor-trabalhador — um supervisor delega e revisa:

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}")

O supervisor é o gargalo. Ele planeja, delega e revisa. Certifique-se de que ele seja rápido o suficiente, senão todo o sistema desacelerará.

Arquitetura Ensemble (Conjunto)

Combine múltiplos modelos para decisões críticas.

Padrão 1: Ensemble Ponderado (Weighted)

Ensemble ponderado — avalie a saída de cada modelo, escolha a maior pontuação:

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)

Os pesos refletem sua confiança em cada modelo. Ajuste-os com base no desempenho real, não em benchmarks.

Padrão 2: Ensemble de Consenso

Ensemble de consenso — exija acordo, escale se não houver:

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)

O limite (threshold) controla quão estrito o consenso é. 0.7 significa dois terços de acordo. Abaixe-o para decisões mais rápidas, aumente-o para maior confiança.

Quando os sistemas de múltiplos modelos fazem sentido

Os sistemas de múltiplos modelos fazem sentido quando você tem cargas de trabalho mistas, precisa de alta qualidade para decisões críticas ou está otimizando para custo ou latência.

Eles não fazem sentido quando todas as tarefas têm complexidade similar, você está prototipando ou quando a simplicidade é mais importante do que a otimização.

A regra prática: comece com um modelo. Adicione mais quando encontrar uma restrição real — custo, latência ou qualidade. Não projete complexidade antes de precisar dela.

Compromissos (Trade-offs)

Padrão Custo Latência Qualidade Complexidade
Modelo Único Mais baixo Mais baixa Variável Mais baixa
Sequencial Médio Alta Alta Média
Paralelo Alto Baixa Alta Média
Hierárquico Alto Alta Mais alta Alta
Ensemble Mais alto Média Mais alta Mais alta

Cada padrão troca algo. Escolha aquele que corresponda às suas restrições.

Relacionados

Assinar

Receba novos artigos sobre sistemas, infraestrutura e engenharia de IA.