Tutorial de Mistral Large 3: Crear un centro de evaluación de inteligencia multimodal

Mistral Large 3 es un modelo MoE multimodal creado para leer, razonar y estructurar la información de documentos visuales complejos. En lugar de tratar los gráficos y los archivos PDF como imágenes estáticas, está diseñado para extraer tablas e información y generar narrativas pulidas a partir de ellos.

En este tutorial, utilizaremos el modelo Mistral Large 3 (mistral-large-2512) para crear un centro de evaluación de inteligencia multimodal en Streamlit. El flujo es el siguiente:

• Subes datos como gráficos, estados financieros o archivos PDF de varias páginas.
• Mistral lee el texto y los números directamente de la imagen.
• Reconstruye cualquier tabla visible en cadenas CSV.
• A continuación, Mistral genera información, riesgos y anomalías basándose en los datos introducidos.
• Por último, devuelve resúmenes breves en varios idiomas.

Todo esto se hace con un único modelo (mistral-large-2512), un único punto final (/v1/chat/completions) y un esquema JSON estricto para mantener los resultados estructurados y fiables. 

Te recomiendo leer nuestro artículo sobre Mistral 3, que presenta las características principales de los nuevos modelos. 

¿Qué es Mistral Large 3?

Mistral Large 3 es una arquitectura de mezcla de expertos (MOE) con 41 000 millones de parámetros activos de un total de 675 000 millones y un codificador de visión de 2500 millones de parámetros para la comprensión de imágenes.

A continuación se indican algunas propiedades clave relevantes para este modelo:

• Multimodal: Mistral Large 3 procesa tanto texto como imágenes (gráficos, capturas de pantalla, documentos).
• Contexto largo (256 000 tokens): Está diseñado para documentos largos, procesos RAG y flujos de trabajo empresariales.
• Salida agencial y estructurada: Admite llamadas a funciones y salida JSON/JSON Schema a través de la API de chat.
• Multilingual: El modelo grande 3 de Mistral ofrece un gran rendimiento en más de 40 idiomas, no solo en inglés.

La tarjeta modelo y los documentos sobre el ecosistema también mencionan algunas advertencias importantes:

• No es un modelo de razonamiento específico, es decir, también incluye ciertas variantes de razonamiento especializadas que pueden superarlo en lógica compleja.
• Queda por detrás de los modelos específicos para la visión en tareas puramente visuales, por lo que el preprocesamiento y las buenas indicaciones son importantes.
• Para la visión, Mistral recomienda mantener relaciones de aspecto cercanas a 1:1, evitando imágenes extremadamente delgadas o anchas. Por lo tanto, recortar imágenes ayuda a mejorar el rendimiento del modelo. 

Ejemplo de proyecto grande con Mistral 3: Centro de evaluación de inteligencia multimodal

En esta sección, crearemos un centro de evaluación de inteligencia multimodal utilizando Mistral Large 3 integrado en una aplicación Streamlit. A grandes rasgos, esto es lo que hace la aplicación final:

• Acepta entradas similares a informes, como capturas de pantalla de gráficos, páginas de informes individuales o archivos PDF de varias páginas con tablas y gráficos.
• Convierte los archivos PDF en una única imagen apilada, luego recorta el centro a una relación de aspecto aproximada de 1:1 (siguiendo la recomendación de Mistral Large 3 vision), cambia el tamaño a aproximadamente 1024×1024 y codifica el resultado como una URL de datos base64.
• A continuación, enviamos las instrucciones del usuario y la imagen a mistral-large-2512, que utiliza response_format en modo JSON Schema para obtener una carga JSON estructurada.
• Por último, representamos el JSON como un panel interactivo que consta de tablas reconstruidas como DataFrame con archivos CSV descargables, información destacada/riesgos/anomalías, una publicación lista para redes sociales y resúmenes multilingües en expansores.

Esto convierte un informe visual estático en un asistente de inteligencia interactivo impulsado íntegramente por Mistral Large 3.

Construyámoslo paso a paso.

Paso 1: Requisitos previos y configuración

Antes de poder crear nuestra demostración de Streamlit sobre Mistral Large 3, necesitamos un entorno local básico para comunicarnos con el modelo a través de la API de Mistral. Comienza instalando algunas bibliotecas auxiliares para gestionar la interfaz de usuario, los documentos y la configuración. 

pip install streamlit mistralai pillow pdf2image pandas python-dotenv

Usaremos las bibliotecas principales mencionadas anteriormente, como streamlit para la interfaz de usuario de la aplicación web interactiva, mistralai para comunicarnos con la API de Mistral y pillow y pdf2image para abrir y convertir archivos PDF en imágenes, pandas para manejar cualquier dato tabular o registro, y python-dotenv para cargar de forma segura variables de entorno como MISTRAL_API_KEY desde un archivo .env.

A continuación, inicia sesión en la plataforma Mistral AI y ve a la sección Claves API ..

Establece tu espacio de trabajo predeterminado (si se te solicita) y haz clic en Crear nueva clave.

Asigna un nombre significativo a tu clave y, si lo deseas, establece una fecha de caducidad.

Por último, copia la clave generada y expórtala como un variable de entorno de la siguiente manera:

export MISTRAL_API_KEY="your_mistral_api_key_here"

En este punto, nuestro entorno ya está listo para autenticarse con la API de Mistral.

Paso 2: Inicialización del cliente Mistral

Una vez configurado el entorno e instaladas las dependencias, el siguiente paso es inicializar el cliente Mistral que gestionará todas nuestras llamadas al modelo Mistral Large 3. Esto nos proporciona un punto de entrada para enviar indicaciones desde nuestra aplicación Streamlit a Mistral Large 3.

MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
MODEL_ID = "mistral-large-2512"  
if MISTRAL_API_KEY is None:
    raise RuntimeError("Please set the MISTRAL_API_KEY environment variable.")
client = MistralClient(api_key=MISTRAL_API_KEY)

El bloque de código anterior hace tres cosas:

• Lee el archivo MISTRAL_API_KEY de nuestro entorno y almacena el nombre del modelo en MODEL_ID, lo que nos permite reutilizarlo en toda la aplicación.
• A continuación, comprueba que la clave API esté configurada y muestra un error claro si falta.
• También crea una instancia de MistralClient utilizando el SDK oficial mistralai, que utilizaremos para todas las solicitudes posteriores al modelo.

Una vez inicializado el cliente, crearemos algunas funciones auxiliares que envían mensajes y gestionan las respuestas dentro de la interfaz de usuario de Streamlit.

Paso 3: Preprocesamiento de la visión

Antes de enviar cualquier imagen o PDF a Mistral Large 3, debemos hacerlos «compatibles con el modelo». La API Vision funciona mejor cuando las entradas son cuadradas, tienen un tamaño razonable y están codificadas en un formato coherente. 

Paso 3.1: Recorte central

Empezamos cargando la imagen subida y convirtiéndola en un recorte cuadrado. 

def load_image_from_upload(uploaded_file) -> Image.Image:
    return Image.open(io.BytesIO(uploaded_file.read())).convert("RGB")
def center_crop_to_square(img: Image.Image) -> Image.Image:
    width, height = img.size
    if width == height:
        return img
    if width > height:
        offset = (width - height) // 2
        box = (offset, 0, offset + height, height)
    else:
        offset = (height - width) // 2
        box = (0, offset, width, offset + width)
    return img.crop(box)

El bloque de código anterior garantiza que los gráficos o tablas que subís se conviertan en un recorte cuadrado antes de pasar al modelo, en consonancia con las directrices de visión de Mistral.

Paso 3.2: Cambiar el tamaño 

A continuación, cambiamos el tamaño de la imagen al tamaño máximo (1024×1024) para equilibrar la calidad, la latencia y el coste de los tokens.

def resize_for_vlm(img: Image.Image, max_size: int = 1024) -> Image.Image:
    width, height = img.size
    scale = min(max_size / width, max_size / height, 1.0)
    if scale == 1.0:
        return img
    new_w = int(width * scale)
    new_h = int(height * scale)
    return img.resize((new_w, new_h), Image.LANCZOS)

Aquí, calculamos un factor scale que mantiene ambas dimensiones por debajo de max_size , al tiempo que conserva la relación de aspecto. Si la imagen ya es lo suficientemente pequeña, la devolvemos tal cual. De lo contrario, calculamos las nuevas dimensiones y utilizamos LANCZOS para obtener una reducción de alta calidad.

Este paso garantiza que las imágenes no saturen tu ventana de contexto ni ralenticen las respuestas innecesariamente.

Paso 3.3: PDF a imagen apilada

En el caso de los archivos PDF, a menudo queremos mostrar el modelo en más de una página. Un truco sencillo consiste en renderizar todas las páginas y apilarlas verticalmente en una sola imagen alta. 

def stack_images_vertically(images: List[Image.Image]) -> Image.Image:
    if not images:
        raise ValueError("No images to stack")
    target_width = images[0].size[0]
    resized_images = []
    for img in images:
        if img.size[0] != target_width:
            aspect_ratio = img.size[1] / img.size[0]
            new_height = int(target_width * aspect_ratio)
            img = img.resize((target_width, new_height), Image.LANCZOS)
        resized_images.append(img)
    total_height = sum(img.size[1] for img in resized_images)
    stacked = Image.new('RGB', (target_width, total_height))
    y_offset = 0
    for img in resized_images:
        stacked.paste(img, (0, y_offset))
        y_offset += img.size[1] 
    return stacked
def uploaded_file_to_square_base64(uploaded_file) -> Tuple[str, str]:
    mime_type = uploaded_file.type
    raw_bytes = uploaded_file.getvalue()
    if mime_type == "application/pdf":
        pages = convert_from_bytes(raw_bytes)
        pages_rgb = [page.convert("RGB") for page in pages]
        img = stack_images_vertically(pages_rgb)
        img = resize_for_vlm(img, max_size=1024)
        mime_type = "image/png"  
    else:
        img = Image.open(io.BytesIO(raw_bytes)).convert("RGB")
        img = center_crop_to_square(img)
        img = resize_for_vlm(img, max_size=1024)
    return mime_type, image_to_base64_data_url(img, mime_type=mime_type)

La función stack_images_vertically() toma una lista de imágenes PIL, las normaliza a un ancho común conservando la relación de aspecto, calcula la altura total y las pega una debajo de otra en un único lienzo RGB. Mientras que lafunción uploaded_file_to_square_base64() decide qué hacer en función del tipo MIME:

• En el caso de los archivos PDF, convierte cada página en una imagen, las apila verticalmente y cambia el tamaño del resultado.
• Para las subidas de imágenes habituales, carga la imagen, la recorta por el centro para convertirla en un cuadrado y cambia su tamaño.

En ambos casos, devuelve una imagen normalizada junto con un tipo MIME para el paso final de codificación.

Paso 3.4: Codificación a base64 

La API Vision de Mistral acepta imágenes como objetos image_url, que pueden ser URL reales o URL data:.

def image_to_base64_data_url(img: Image.Image, mime_type: str = "image/png") -> str:
    buffer = io.BytesIO()
    if mime_type == "image/jpeg":
        img.save(buffer, format="JPEG", quality=90)
    else:
        img.save(buffer, format="PNG")
        mime_type = "image/png"
    b64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
    return f"data:{mime_type};base64,{b64}"

Empezamos escribiendo la imagen en un búfer en memoria y eligiendo un formato adecuado (como JPEG o PNG), antes de codificar finalmente los bytes en base64. 

Por último, envolvemos la cadena codificada en una URL data:{mime_type};base64 que se puede pasar directamente a la API de Mistral Vision como image_url.

Al final de este paso, todos los archivos cargados, ya sean un único PNG, un panel de control amplio o un PDF de varias páginas, pasan por el mismo proceso de recorte central, cambio de tamaño, apilamiento de PDF y conversión de URL de datos base64.

Paso 4: Llamada de inferencia multimodal 

En este paso, lo envolvemos todo en una única función auxiliar que envía una solicitud de visión más texto y obliga al modelo a responder en formato JSON. Lo hacemos combinando:

• Un mensaje del sistema que define la función del modelo como Evaluador de Inteligencia Multimodal,
• Un mensaje de usuario que mezcla instrucciones con el contenido de la imagen, y
• Se pasa un esquema JSON a través de response_format para que el resultado esté estructurado y sea fácil de analizar.

def call_mistral_large_multimodal(
    mime_type: str,
    image_data_url: str,
    user_instruction: str,
    languages: List[str],
) -> Dict[str, Any]:
    json_schema = {
        "type": "object",
        "properties": {
            "csv_tables": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Each item is a CSV string representing one table found in the image."
            },
            "insights": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Up to 5 key insights about the content."
            },
            "risks": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Up to 5 key risks or red flags."
            },
            "anomalies": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Any anomalies, outliers, or surprising patterns you detect."
            },
            "translations": {
                "type": "object",
                "properties": {
                    lang: {"type": "string"} for lang in languages
                },
                "description": "Short high-level summaries in the selected languages."
            },
        },
        "required": ["csv_tables", "insights", "risks"],
        "additionalProperties": False,
    }
    system_prompt = (
        "You are a Multimodal Intelligence Evaluator using Mistral Large 3.\n"
        "You are given a single document-like image (e.g. chart + table, financial report page).\n\n"
        "Your tasks:\n"
        "1. Read all visible text and numbers directly from the image.\n"
        "2. Reconstruct any clearly visible tables into valid CSV strings.\n"
        "   - Use the first row as headers when possible.\n"
        "   - Use commas as separators and newline per row.\n"
        "3. Derive up to 5 concise INSIGHTS about trends, patterns, or takeaways.\n"
        "4. Derive up to 5 concise RISKS or red flags (business, financial, operational, etc.).\n"
        "5. Detect any anomalies or surprising patterns if present (else return an empty list).\n"
        "6. Provide short summaries in the requested languages.\n\n"
        "You MUST respond ONLY with a JSON object that matches the provided JSON schema.\n"
        "Do not include any extra commentary outside of the JSON."
    )
    messages = [
        {
            "role": "system",
            "content": [
                {"type": "text", "text": system_prompt},
            ],
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": user_instruction or "Analyze this financial report page.",
                },
                {
                    "type": "image_url",
                    "image_url": image_data_url,
                },
            ],
        },
    ]
    response = client.chat(
        model=MODEL_ID,
        messages=messages,
        temperature=0.2,
        max_tokens=2048,
        response_format={
            "type": "json_schema",
            "json_schema": {
                "name": "multimodal_intel_eval",
                "schema": json_schema,
                "strict": True,
            },
        },
    )
    content = response.choices[0].message.content
    try:
        parsed = json.loads(content)
    except json.JSONDecodeError:
        try:
            start = content.index("{")
            end = content.rindex("}") + 1
            parsed = json.loads(content[start:end])
        except Exception:
            raise ValueError(f"Model did not return valid JSON. Raw content:\n{content}")
    return parsed

La función « call_mistral_large_multimodal() » constituye el motor central de la demostración de inteligencia multimodal.

• La función primero crea un esquema JSON que define arreglos para csv_tables, insights, risks, anomalies y un objeto translations con claves derivadas de la lista languages. 
• También definimos una indicación detallada del sistema que enmarca el modelo como un Evaluador de Inteligencia Multimodal y te guía a través de las tareas de lectura de números, reconstrucción de tablas como CSV, extracción de información, riesgos, anomalías y resúmenes multilingües.
• La función « call_mistral_large_multimodal() » construye entonces el arreglo de mensajes en formato de chat combinando las instrucciones del sistema con un mensaje de usuario que incluye tanto instrucciones de texto como la carga útil « image_url ». Llama a client.chat() con MODEL_ID mientras mantiene la temperatura baja para obtener un resultado determinista, y response_format={"type": "json_schema",}, de modo que la respuesta se ajusta al esquema. Por último, intentamos analizarlo con json.loads.

Con esto, ahora tienes un punto de partida sólido para convertir un gráfico sin procesar o la imagen de un informe en una narrativa estructurada.

Paso 5: Creación de la interfaz de usuario de Streamlit

Con el proceso de preprocesamiento y el cliente Mistral listos, el último paso es integrar todo en una interfaz Streamlit. 

st.set_page_config(
    page_title="Multimodal Intelligence Evaluation Hub - Mistral Large 3",
    layout="wide",
)
st.title("Multimodal Intelligence Evaluation Hub")
st.caption("Powered by **Mistral Large 3**")
col_left, col_right = st.columns([2, 1])
with col_left:
    uploaded_file = st.file_uploader(
        "Upload an image or report (PNG, JPG, WEBP, or PDF)",
        type=["png", "jpg", "jpeg", "webp", "pdf"],
    )
    default_prompt = (
        "Give me 3–5 key insights and risks from this input and export any tables you see as CSV "
        "Also write down the findings for a professional audience."
    )
    user_instruction = st.text_area(
        "Instruction to Mistral Large 3",
        value=default_prompt,
        height=120,
    )
with col_right:
    st.subheader("Multilingual Options")
    languages = st.multiselect(
        "Additional summary languages",
        options=["fr", "de", "es", "hi", "zh", "ja"],
        default=["hi"],
        help="Mistral Large 3 supports dozens of languages; these will receive short summaries.",
        label_visibility="collapsed",
    )
    run_button = st.button("Run Analysis", type="primary")
if run_button:
    if uploaded_file is None:
        st.error("Please upload an image or PDF first.")
        st.stop()
    prep_msg = "Preparing PDF (combining all pages)..." if uploaded_file.type == "application/pdf" else "Preparing image..."
    with st.spinner(prep_msg):
        mime_type, data_url = uploaded_file_to_square_base64(uploaded_file)
    mime, b64_part = data_url.split(",", 1)
    img_bytes = base64.b64decode(b64_part)
    st.image(img_bytes, caption="Center-cropped & resized image for the model", width=400)
    with st.spinner("Processing..."):
        try:
            result = call_mistral_large_multimodal(
                mime_type=mime_type,
                image_data_url=data_url,
                user_instruction=user_instruction,
                languages=languages,
            )
        except Exception as e:
            st.error(f"Error calling Mistral Large 3: {e}")
            st.stop()
    st.header("Results")
    csv_tables = result.get("csv_tables", [])
    if csv_tables:
        st.subheader("Reconstructed Tables (CSV)")
        for i, csv_str in enumerate(csv_tables):
            st.markdown(f"**Table {i+1}**")
            try:
                df = pd.read_csv(io.StringIO(csv_str))
                st.dataframe(df, use_container_width=True)
            except Exception:
                st.text_area(f"Raw CSV for Table {i+1}", value=csv_str, height=150)
            st.download_button(
                label=f"Download Table {i+1} as CSV",
                data=csv_str,
                file_name=f"table_{i+1}.csv",
                mime="text/csv",
                key=f"csv_download_{i}",
            )
    else:
        st.info("No tables were detected or reconstructed.")
    insights = result.get("insights", [])
    risks = result.get("risks", [])
    anomalies = result.get("anomalies", [])
    col_ins, col_risk = st.columns(2)
    with col_ins:
        st.subheader("Key Insights")
        if insights:
            for bullet in insights:
                st.markdown(f"- {bullet}")
        else:
            st.write("_No explicit insights returned._")
    with col_risk:
        st.subheader("Risks")
        if risks:
            for bullet in risks:
                st.markdown(f"- {bullet}")
        else:
            st.write("_No explicit risks returned._")
    st.subheader("Anomalies")
    if anomalies:
        for bullet in anomalies:
            st.markdown(f"- {bullet}")
    else:
        st.write("_No anomalies reported._")
    translations = result.get("translations", {}) or {}
    if translations:
        st.subheader(" Multilingual Summaries")
        for lang_code, summary in translations.items():
            with st.expander(f"Summary in {lang_code}"):
                st.write(summary)
    else:
        st.info("No multilingual summaries were requested or returned.")
    # Raw JSON (debug)
    # with st.expander(" Raw JSON (debug)"):
    #     st.json(result)

El código StreamLit UI anterior realiza varias tareas clave:

El método ` st.set_page_config ` divide el diseño en dos columnas. El lado izquierdo gestiona las entradas principales (cargador de archivos y un área de texto editable con instrucciones predeterminadas). Por el contrario, el lado derecho ofrece opciones multilingües a través de st.multiselect y un botón principal Run Analysis. Al hacer clic en el botón, la aplicación comprueba que haya un archivo, convierte las imágenes o los PDF en una URL de datos base64 y muestra la imagen de vista previa. 

Una vez obtenido el resultado, las tablas CSV reconstruidas se representan como DataFrame, junto con información detallada, riesgos, anomalías y resúmenes multilingües. Opcionalmente, también podemos depurar vistas (comentadas), lo que nos permite inspeccionar el JSON sin procesar durante el desarrollo.

Una vez completado este paso, puedes guardar todo como app.py y ejecutar la experiencia completa con:

streamlit run app.py

En el siguiente vídeo, puedes ver una versión resumida del flujo de trabajo en acción con entradas tanto de imágenes como de PDF: