Enviar varias imágenes en un único mensaje
En esta página
Analizar varias imágenes a la vez
La API de Visión de Mistral no se limita a una imagen por mensaje. Puedes enviar varias imágenes en una única llamada para pedir al modelo que las compare, sintetice o analice conjuntamente. La diferencia entre esto y dos llamadas separadas es crítica: en una única llamada, el modelo ve ambas imágenes simultáneamente y puede razonar sobre sus relaciones, algo que ninguna agregación de respuestas individuales podría lograr.
Esta capacidad habilita casos de uso donde la pregunta se centra en la brecha más que en el contenido: comparaciones de antes y después, análisis de series documentales o verificaciones visuales de conformidad.
Estructura de un mensaje con varias imágenes
El principio es sencillo: añade varios elementos image_url al array content:
message = {
"role": "user",
"content": [
{"type": "text", "text": "Compara estas dos imágenes y describe las diferencias."},
{"type": "image_url", "image_url": "https://example.com/image1.jpg"},
{"type": "image_url", "image_url": "https://example.com/image2.jpg"}
]
}
No es necesaria la homogeneidad: puedes mezclar imágenes por URL y en Base64 en el mismo mensaje. Esto es habitual cuando necesitas comparar una imagen de referencia alojada con un archivo local generado recientemente.
Ejemplo: Comparar dos imágenes
Imagina una inspección de recepción en un almacén. Comparas una foto de referencia del producto conforme con una foto de la muestra recibida, utilizando un prompt de sistema que establece el rol del inspector:
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": "Eres un experto en control de calidad. Compara las imágenes proporcionadas con precisión."
},
{
"role": "user",
"content": [
{
"type": "text",
"text": "Aquí tienes dos fotos del mismo producto. La primera es la referencia, la segunda es la muestra recibida. Identifica todas las diferencias."
},
{"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)
El texto indica explícitamente el orden («la primera es la referencia») porque el modelo no puede adivinarlo.
Intercalar texto e imágenes
Este enfoque de ordenación alcanza rápidamente sus límites más allá de dos imágenes. Un método más robusto consiste en etiquetar cada imagen justo antes de proporcionarla, alternando elementos text e image_url:
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "Este es el plano arquitectónico original:"},
{"type": "image_url", "image_url": "https://example.com/plan-original.png"},
{"type": "text", "text": "Y esta es la foto del edificio construido:"},
{"type": "image_url", "image_url": "https://example.com/photo-batiment.jpg"},
{"type": "text", "text": "¿Coincide el edificio con el plano? Enumera las discrepancias."}
]
}
]
)
Cada imagen lleva ahora su propia etiqueta, y la pregunta final llega solo después de presentar todo el material. Este formato mejora significativamente la comprensión del modelo: sabe que el plano es el estándar y la foto es el objeto a evaluar. Invertirlos produciría un informe de discrepancias invertido.
Procesamiento por lotes con Base64
Para una carpeta de imágenes locales, la construcción del content se vuelve programática. Ensamblas la lista en un bucle, codificando cada archivo sobre la marcha:
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}"
# Cargar todas las imágenes de una carpeta
folder = Path("captures/")
images = sorted(folder.glob("*.png"))
# Construir el contenido del mensaje
content = [{"type": "text", "text": f"Analiza estas {len(images)} capturas de pantalla y resume los elementos comunes."}]
for img in images[:5]: # Limitar a un máximo de 5 imágenes
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)
El fragmento images[:5] es la salvaguarda del script. Sin él, una carpeta con doscientas capturas de pantalla entraría entera en una única llamada, con las consecuencias descritas justo a continuación.
Límites de las llamadas con varias imágenes
No existe un límite estricto documentado sobre el número de imágenes, pero dos efectos se combinan más allá de cinco a diez: la calidad del análisis se degrada a medida que la atención del modelo se diluye entre las imágenes, y los costes de tokens aumentan drásticamente. Recuerda el orden de magnitud de la Lección 2: cada imagen consume entre 800 y 1.500 tokens, por lo que cinco imágenes ya representan entre 5.000 y 7.500 tokens de prompt antes incluso de que empiece tu pregunta. El total —imágenes, texto y respuesta— debe caber también en la ventana de contexto del modelo, un techo que un lote de imágenes alcanza mucho más rápido que un documento de texto.
Esta función calcula la factura antes de la llamada en lugar de después:
def estimate_multi_image_cost(num_images, tokens_per_image=1000, text_tokens=100, response_tokens=500):
"""Estima el total de tokens para una llamada con varias imágenes."""
total_input = (num_images * tokens_per_image) + text_tokens
total = total_input + response_tokens
print(f"Imágenes: {num_images} x {tokens_per_image} = {num_images * tokens_per_image} tokens")
print(f"Texto del prompt: {text_tokens} tokens")
print(f"Respuesta estimada: {response_tokens} tokens")
print(f"Total estimado: {total} tokens")
return total
estimate_multi_image_cost(3)
# Imágenes: 3 x 1000 = 3000 tokens
# Texto del prompt: 100 tokens
# Respuesta estimada: 500 tokens
# Total estimado: 3600 tokens
Estrategia para grandes volúmenes
Más allá de cinco imágenes, cambia tu enfoque en lugar de forzar la situación. Existen tres vías, a menudo combinadas. El análisis secuencial procesa las imágenes una a una y luego agrega los resultados: el coste se mantiene lineal y la precisión por imagen es máxima. La agrupación por lotes envía paquetes de tres a cinco imágenes, preservando cierta comparación intra-lote. El prefiltrado, finalmente, utiliza un modelo más ligero como Small para descartar imágenes irrelevantes antes de pasar los casos importantes a Large.
La primera vía tiene este aspecto, con una síntesis final que maneja solo texto:
# Análisis secuencial con agregación
results = []
for img_path in images:
response = client.chat.complete(
model="mistral-small-latest",
messages=[{
"role": "user",
"content": [
{"type": "text", "text": "Describe brevemente el contenido de esta imagen."},
{"type": "image_url", "image_url": encode_image(img_path)}
]
}]
)
results.append(response.choices[0].message.content)
# Síntesis final (solo texto)
synthesis = client.chat.complete(
model="mistral-small-latest",
messages=[{
"role": "user",
"content": f"Aquí tienes descripciones de {len(results)} imágenes:\n\n" +
"\n---\n".join(results) +
"\n\nProporciona una síntesis global."
}]
)
El truco reside en la segunda llamada: no contiene imágenes, por lo que no hay tokens visuales. Sintetizas cincuenta imágenes por el precio de unos pocos cientos de tokens de texto.
Puntos clave
- Puedes enviar varias imágenes en un único mensaje añadiendo múltiples elementos
image_url - Intercala texto entre las imágenes para proporcionar contexto al modelo
- Cada imagen añade entre 800 y 1.500 tokens: estima tus costes antes de llamar
- Más allá de 5 imágenes, prefiere una estrategia secuencial o por lotes
- Las URL y Base64 pueden mezclarse en el mismo mensaje