Enviar Múltiplas Imagens numa Única Mensagem
Nesta página
Analisar Múltiplas Imagens de Uma Vez
A API Vision da Mistral não se limita a uma imagem por mensagem. Pode enviar múltiplas imagens num único pedido para solicitar ao modelo que as compare, sintetize ou analise em conjunto. A diferença entre isto e duas chamadas separadas é crítica: numa única chamada, o modelo vê ambas as imagens simultaneamente e pode raciocinar sobre as suas relações — algo que nenhuma agregação de respostas individuais conseguiria alcançar.
Esta capacidade desbloqueia casos de uso onde a questão se foca na lacuna e não no conteúdo: comparações antes/depois, análise de séries documentais ou verificações de conformidade visual.
Estrutura de uma Mensagem com Múltiplas Imagens
O princípio é simples: adicione múltiplos itens image_url ao array content:
message = {
"role": "user",
"content": [
{"type": "text", "text": "Compare estas duas imagens e descreva as diferenças."},
{"type": "image_url", "image_url": "https://example.com/image1.jpg"},
{"type": "image_url", "image_url": "https://example.com/image2.jpg"}
]
}
A homogeneidade não é obrigatória: pode misturar imagens por URL e Base64 na mesma mensagem. Isto é comum quando precisa de comparar uma imagem de referência alojada com um ficheiro local gerado recentemente.
Exemplo: Comparar Duas Imagens
Considere uma inspeção de receção num armazém. Compara uma fotografia de referência do produto em conformidade com uma fotografia da amostra recebida, utilizando um prompt de sistema que estabelece o papel de inspetor:
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{
"role": "system",
"content": "É um especialista em controlo de qualidade. Compare as imagens fornecidas com precisão."
},
{
"role": "user",
"content": [
{
"type": "text",
"text": "Aqui estão duas fotos do mesmo produto. A primeira é a referência, a segunda é a amostra recebida. Identifique todas as diferenças."
},
{"type": "image_url", "image_url": "https://example.com/reference.jpg"},
{"type": "image_url", "image_url": "https://example.com/sample.jpg"}
]
}
]
)
print(response.choices[0].message.content)
O texto indica explicitamente a ordem — «a primeira é a referência» — porque o modelo não a pode adivinhar.
Intercalar Texto e Imagens
Esta abordagem de ordenação rapidamente atinge os seus limites além de duas imagens. Um método mais robusto consiste em rotular cada imagem imediatamente antes de a fornecer, alternando elementos text e image_url:
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "Eis a planta arquitetónica original:"},
{"type": "image_url", "image_url": "https://example.com/plan-original.png"},
{"type": "text", "text": "E aqui está a foto do edifício construído:"},
{"type": "image_url", "image_url": "https://example.com/photo-batiment.jpg"},
{"type": "text", "text": "O edifício corresponde à planta? Liste as discrepâncias."}
]
}
]
)
Cada imagem possui agora a sua própria etiqueta, e a pergunta final só surge após toda a matéria ser apresentada. Este formato melhora significativamente a compreensão do modelo: sabe que a planta é o padrão e a foto é o objeto a avaliar. Invertê-las produziria um relatório de discrepâncias invertido.
Processamento em Lote com Base64
Para uma pasta de imagens locais, a construção do content torna-se programática. Monta a lista num ciclo, codificando cada ficheiro em tempo real:
import base64
import os
from pathlib import Path
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
def encode_image(path):
with open(path, "rb") as f:
b64 = base64.standard_b64encode(f.read()).decode("utf-8")
ext = Path(path).suffix.lower()
mime = {"jpg": "jpeg", "jpeg": "jpeg", "png": "png", "webp": "webp"}.get(ext.lstrip("."), "jpeg")
return f"data:image/{mime};base64,{b64}"
# Carregar todas as imagens de uma pasta
folder = Path("captures/")
images = sorted(folder.glob("*.png"))
# Construir o conteúdo da mensagem
content = [{"type": "text", "text": f"Analise estas {len(images)} capturas de ecrã e resuma os elementos comuns."}]
for img in images[:5]: # Limitar a no máximo 5 imagens
content.append({"type": "image_url", "image_url": encode_image(img)})
response = client.chat.complete(
model="mistral-small-latest",
messages=[{"role": "user", "content": content}]
)
print(response.choices[0].message.content)
O slice images[:5] é a salvaguarda do script. Sem ele, uma pasta contendo duzentas capturas de ecrã entraria inteiramente numa única chamada — com as consequências descritas logo abaixo.
Limites das Chamadas com Múltiplas Imagens
Não existe um limite estrito documentado sobre o número de imagens, mas dois efeitos combinam-se além de cinco a dez: a qualidade da análise degrada-se à medida que a atenção do modelo se dilui pelas imagens, e os custos de tokens aumentam drasticamente. Recorde a ordem de grandeza da Lição 2: cada imagem consome 800 a 1.500 tokens, pelo que cinco imagens já representam 5.000 a 7.500 tokens de prompt antes mesmo de a sua pergunta começar. O total — imagens, texto e resposta — deve também caber na janela de contexto do modelo, um teto que um lote de imagens atinge muito mais rapidamente do que um documento de texto.
Esta função calcula a fatura antes da chamada e não depois:
def estimate_multi_image_cost(num_images, tokens_per_image=1000, text_tokens=100, response_tokens=500):
"""Estimar o total de tokens para uma chamada com múltiplas imagens."""
total_input = (num_images * tokens_per_image) + text_tokens
total = total_input + response_tokens
print(f"Imagens: {num_images} x {tokens_per_image} = {num_images * tokens_per_image} tokens")
print(f"Texto do prompt: {text_tokens} tokens")
print(f"Resposta estimada: {response_tokens} tokens")
print(f"Total estimado: {total} tokens")
return total
estimate_multi_image_cost(3)
# Imagens: 3 x 1000 = 3000 tokens
# Texto do prompt: 100 tokens
# Resposta estimada: 500 tokens
# Total estimado: 3600 tokens
Estratégia para Grandes Volumes
Além de cinco imagens, altere a sua abordagem em vez de forçar a passagem. Existem três caminhos, frequentemente combinados. A análise sequencial processa as imagens uma a uma e depois agrega os resultados — o custo mantém-se linear e a precisão por imagem é máxima. O agrupamento em lotes envia pacotes de três a cinco imagens, preservando alguma comparação intra-lote. A pré-filtragem, finalmente, utiliza um modelo mais leve como o Small para descartar imagens irrelevantes antes de entregar os casos importantes ao Large.
O primeiro caminho apresenta-se assim, com uma síntese final que lida apenas com texto:
# Análise sequencial com agregação
results = []
for img_path in images:
response = client.chat.complete(
model="mistral-small-latest",
messages=[{
"role": "user",
"content": [
{"type": "text", "text": "Descreva brevemente o conteúdo desta imagem."},
{"type": "image_url", "image_url": encode_image(img_path)}
]
}]
)
results.append(response.choices[0].message.content)
# Síntese final (apenas texto)
synthesis = client.chat.complete(
model="mistral-small-latest",
messages=[{
"role": "user",
"content": f"Aqui estão descrições de {len(results)} imagens:\n\n" +
"\n---\n".join(results) +
"\n\nForneça uma síntese global."
}]
)
O truque reside na segunda chamada: não contém imagens, logo, sem tokens visuais. Sintetiza cinquenta imagens pelo preço de algumas centenas de tokens de texto.
Pontos-chave
- Pode enviar múltiplas imagens numa única mensagem adicionando vários elementos
image_url - Intercale texto entre imagens para fornecer contexto ao modelo
- Cada imagem adiciona 800-1500 tokens — estime os seus custos antes de efetuar a chamada
- Além de 5 imagens, prefira uma estratégia sequencial ou em lotes
- URLs e Base64 podem ser misturados na mesma mensagem