Completões N
Nesta página
Gerar múltiplas respostas numa única chamada
O parâmetro n instrui o modelo a produzir múltiplas respostas alternativas para o mesmo prompt num único pedido à API. Embora possa parecer uma funcionalidade menor, permite três casos de uso sérios: comparar duas formulações de prompt num conjunto de amostras, selecionar automaticamente a melhor resposta de um lote e explorar o espaço de soluções em vez de aceitar a primeira saída.
Por predefinição, n=1, e a API devolve uma única resposta em choices. Se definir n=5, o vetor contém cinco entradas, cada uma com o seu próprio index. Note a temperatura definida como 1.0 no exemplo abaixo: sem randomização suficiente, as cinco respostas seriam idênticas, tornando a chamada inútil.
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
response = client.chat.complete(
model="ministral-3b-latest",
messages=[
{"role": "user", "content": "What is the best programming language for beginners? One word only."}
],
temperature=1.0, # High temperature to maximize diversity
n=5
)
for choice in response.choices:
print(f"Response {choice.index}: {choice.message.content}")
Dois fatores determinam o valor prático deste parâmetro. O primeiro é a faturação: os tokens de entrada são cobrados apenas uma vez, uma vez que o prompt é enviado uma única vez, mas os tokens de saída são cobrados por cada completão. Com n=5 e max_tokens=100, o seu limite de saída salta para 500 tokens. É exatamente isto que torna o n atraente para prompts longos: amortizar um contexto grande através de cinco respostas custa significativamente menos do que fazer cinco chamadas separadas.
print(f"Prompt tokens : {response.usage.prompt_tokens}") # Charged 1x
print(f"Response tokens: {response.usage.completion_tokens}") # Charged nx
print(f"Total : {response.usage.total_tokens}")
O segundo fator é a compatibilidade: nem todos os modelos Mistral suportam n. Em abril de 2026, as versões recentes do mistral-large não suportam n > 1. Utilize o ministral-3b-latest ou outros modelos compatíveis para esta funcionalidade — é por isso que todos os exemplos desta lição recorrem a esse modelo.
Selecionar a melhor resposta
O primeiro caso de uso envolve gerar múltiplos candidatos e reter o melhor com base num critério que você define. O mecanismo é intencionalmente genérico: best_of_n aceita qualquer função de pontuação, permitindo-lhe medir o que importa no seu contexto — presença de uma palavra-chave obrigatória, validade JSON ou adesão a um comprimento alvo. A função length_scorer ilustra este último critério, onde a pontuação diminui proporcionalmente ao desvio em relação ao comprimento alvo.
def best_of_n(client, messages, n=5, scorer=None, **kwargs):
"""Generates N responses and selects the best one."""
response = client.chat.complete(
model="ministral-3b-latest",
messages=messages,
n=n,
temperature=0.9,
**kwargs
)
candidates = [
{
"index": c.index,
"content": c.message.content,
"score": scorer(c.message.content) if scorer else 0
}
for c in response.choices
]
if scorer:
candidates.sort(key=lambda x: x["score"], reverse=True)
return candidates
# Scorer: appropriate length (not too short, not too long)
def length_scorer(text: str, target=200) -> float:
"""Score based on proximity to a target length."""
diff = abs(len(text) - target)
return max(0, 1 - diff / target)
candidates = best_of_n(
client,
[{"role": "user", "content": "Write a summary of generative AI in 2026."}],
n=5,
scorer=length_scorer,
max_tokens=300
)
print("Best response:")
print(candidates[0]["content"])
print(f"Score: {candidates[0]['score']:.2f}")
Comparar dois prompts numa amostra
O segundo caso de uso é metodológico e não focado no produto. Ao decidir entre duas formulações de prompt, comparar uma única resposta com outra não prova nada: a variância do modelo por si só poderia explicar a diferença. Ao gerar N respostas para cada versão e medir o comprimento médio e a taxa de respostas distintas, obtém evidências preliminares. Uma pontuação de diversidade de 1.0 num prompt destinado a produzir um formato estável é um sinal de alerta, não uma boa notícia.
def ab_test_prompts(client, prompt_a: str, prompt_b: str, n: int = 5):
"""Compares two prompts by generating N responses for each."""
results = {}
for label, prompt in [("A", prompt_a), ("B", prompt_b)]:
response = client.chat.complete(
model="ministral-3b-latest",
messages=[{"role": "user", "content": prompt}],
n=n,
temperature=0.8,
max_tokens=200
)
texts = [c.message.content for c in response.choices]
avg_length = sum(len(t) for t in texts) / len(texts)
unique_ratio = len(set(texts)) / len(texts)
results[label] = {
"avg_length": round(avg_length),
"diversity": round(unique_ratio, 2),
"sample": texts[0][:150]
}
return results
# Test
results = ab_test_prompts(
client,
"Summarize the benefits of Python.",
"List the 3 main benefits of Python in one sentence each."
)
for label, data in results.items():
print(f"\nPrompt {label}:")
print(f" Average length : {data['avg_length']} chars")
print(f" Diversity : {data['diversity']}")
print(f" Sample : {data['sample']}...")
Melhorar a fiabilidade da classificação via votação
O terceiro caso de uso oferece o maior retorno sobre o investimento (ROI) em produção. Para uma tarefa de classificação, uma única resposta não lhe diz nada sobre a confiança do modelo: a resposta pode ser óbvia, ou pode ser um palpite limítrofe entre duas categorias. Gere sete respostas, conte os votos e obterá tanto um rótulo como uma taxa de confiança acionável — uma classificação 4/7 pode ser encaminhada para validação humana, enquanto uma 7/7 passa diretamente. Utilizar um número ímpar evita empates.
from collections import Counter
def majority_vote(client, messages, n=7, **kwargs):
"""Majority vote classification over N completions."""
response = client.chat.complete(
model="ministral-3b-latest",
messages=messages,
n=n,
temperature=0.7,
max_tokens=20,
**kwargs
)
votes = [c.message.content.strip().upper() for c in response.choices]
counts = Counter(votes)
winner, count = counts.most_common(1)[0]
confidence = count / n
return {
"result": winner,
"confidence": round(confidence, 2),
"votes": dict(counts),
"n": n
}
# Sentiment classification
result = majority_vote(
client,
messages=[
{"role": "system", "content": "Classify the sentiment: POSITIVE, NEGATIVE, or NEUTRAL. Reply with one word only."},
{"role": "user", "content": "The product is okay but the delivery was very slow."}
],
n=7
)
print(f"Result : {result['result']}")
print(f"Confidence: {result['confidence']:.0%}")
print(f"Votes : {result['votes']}")
Quando utilizar n > 1
Este parâmetro não se justifica em todo o lado: no tráfego padrão, cada completão adicional é um custo de saída sem retorno. A tabela abaixo resume valores defensáveis com base no cenário.
| Cenário | n Recomendado | Porquê |
|---|---|---|
| Produção padrão | 1 | Custo mínimo |
| Seleção de qualidade | 3-5 | Melhor-de-N para texto crítico |
| Classificação robusta | 5-9 (ímpar) | Votação maioritária para fiabilidade |
| Teste A/B de prompt | 5-10 | Tamanho de amostra suficiente para comparação |
| Brainstorming | 5-10 | Máxima diversidade de ideias |
Pontos-chave
- O parâmetro
ngera múltiplas respostas numa única chamada à API - Os tokens de entrada são cobrados uma vez; os tokens de saída são multiplicados por N
- Nem todos os modelos suportam
n > 1— verifique a compatibilidade - A votação maioritária melhora a fiabilidade da classificação
- O Melhor-de-N seleciona a melhor resposta com base num critério mensurável
- Utilize temperatura elevada com
n > 1para maximizar a diversidade das respostas