Hướng dẫn Mistral Large 3: Xây dựng Trung tâm Đánh giá Trí tuệ Đa phương thức

Mistral Large 3 là một mô hình MoE đa phương thức được xây dựng để đọc, suy luận và cấu trúc thông tin từ các tài liệu trực quan phức tạp. Thay vì coi biểu đồ và PDF như ảnh tĩnh, nó được thiết kế để trích xuất bảng, insight và tạo các bản tường thuật mạch lạc từ đó.

Trong hướng dẫn này, chúng ta sẽ sử dụng mô hình Mistral Large 3 (mistral-large-2512) để xây dựng một Trung tâm Đánh giá Trí tuệ Đa phương thức trong Streamlit. Quy trình như sau:

• Bạn tải lên đầu vào như biểu đồ, báo cáo tài chính hoặc PDF nhiều trang.
• Mistral đọc trực tiếp văn bản và số từ ảnh.
• Mô hình tái tạo mọi bảng hiển thị thành chuỗi CSV.
• Sau đó Mistral tạo insight, rủi ro và bất thường dựa trên đầu vào.
• Cuối cùng, trả về các bản tóm tắt ngắn bằng nhiều ngôn ngữ.

Tất cả được thực hiện chỉ với một mô hình (mistral-large-2512), một endpoint (/v1/chat/completions) và một JSON Schema chặt chẽ để giữ cho đầu ra có cấu trúc và đáng tin cậy. 

Tôi khuyến nghị đọc bài viết về Mistral 3 của chúng tôi, giới thiệu các tính năng chính của những mô hình mới. Bạn cũng có thể tìm hiểu về fine-tuning Ministral 3 trong một hướng dẫn riêng.

Mistral Large 3 là gì?

Mistral Large 3 là kiến trúc mixture-of-experts (MOE) thưa, với 41B tham số hoạt động trên tổng 675B và bộ mã hóa thị giác 2.5B tham số để hiểu hình ảnh.

Dưới đây là một số thuộc tính chính liên quan đến mô hình này:

• Đa phương thức: Mistral Large 3 xử lý cả văn bản và hình ảnh (biểu đồ, ảnh chụp màn hình, tài liệu).
• Ngữ cảnh dài (256k token): Được xây dựng cho tài liệu dài, pipeline RAG và quy trình doanh nghiệp.
• Tác tử và đầu ra có cấu trúc: Hỗ trợ function calling và đầu ra JSON/JSON Schema thông qua chat API.
• Đa ngôn ngữ: Mô hình Large 3 của Mistral cho hiệu năng mạnh trên hơn 40 ngôn ngữ, không chỉ tiếng Anh.

Thẻ mô hình và tài liệu hệ sinh thái cũng nêu một số lưu ý quan trọng:

• Đây không phải là mô hình chuyên về suy luận; tức là nó cũng có các biến thể suy luận chuyên biệt có thể vượt trội trong các bài toán logic khó.
• Xếp sau các mô hình chuyên thị giác ở bài toán thuần thị giác, vì vậy tiền xử lý và prompt tốt rất quan trọng.
• Với thị giác, Mistral khuyến nghị giữ tỷ lệ khung hình gần 1:1, tránh ảnh quá dọc hoặc quá ngang. Do đó, cắt ảnh giúp cải thiện hiệu năng mô hình. 

Ví dụ dự án Mistral 3 Large: Trung tâm Đánh giá Trí tuệ Đa phương thức

Trong phần này, chúng ta sẽ xây dựng một Trung tâm Đánh giá Trí tuệ Đa phương thức sử dụng Mistral Large 3 gói trong ứng dụng Streamlit. Về tổng thể, ứng dụng cuối cùng sẽ làm những việc sau:

• Nhận các đầu vào dạng báo cáo như ảnh chụp biểu đồ, một trang báo cáo hoặc PDF nhiều trang có bảng và biểu đồ.
• Chuyển PDF thành một ảnh xếp chồng duy nhất, sau đó cắt giữa để có tỷ lệ gần 1:1 (theo khuyến nghị thị giác của Mistral Large 3), đổi kích thước khoảng 1024×1024 và mã hóa kết quả thành data URL base64.
• Sau đó, chúng ta gửi hướng dẫn của người dùng và ảnh tới mistral-large-2512, mô hình dùng response_format ở chế độ JSON Schema để nhận lại payload JSON có cấu trúc.
• Cuối cùng, chúng ta hiển thị JSON dưới dạng dashboard tương tác gồm các bảng được tái tạo thành DataFrame kèm CSV tải xuống, insight/rủi ro/bất thường dạng gạch đầu dòng, bài đăng sẵn sàng cho mạng xã hội, và tóm tắt đa ngôn ngữ trong các expander.

Điều này biến một báo cáo trực quan tĩnh thành một trợ lý trí tuệ tương tác được vận hành hoàn toàn bởi Mistral Large 3.

Hãy xây dựng từng bước.

Bước 1: Điều kiện tiên quyết và thiết lập

Trước khi xây dựng bản demo Streamlit trên nền Mistral Large 3, chúng ta cần môi trường cục bộ cơ bản để giao tiếp với mô hình qua Mistral API. Bắt đầu bằng cách cài một số thư viện hỗ trợ để xử lý UI, tài liệu và cấu hình. 

pip install streamlit mistralai pillow pdf2image pandas python-dotenvĐược hỗ trợ bởi

Chúng ta sẽ dùng các thư viện cốt lõi trên như streamlit cho UI web tương tác, mistralai để giao tiếp với Mistral API, pillow và pdf2image để mở và chuyển PDF thành ảnh, pandas để xử lý dữ liệu dạng bảng hoặc log, và python-dotenv để nạp biến môi trường như MISTRAL_API_KEY từ tệp .env một cách an toàn.

Tiếp theo, đăng nhập vào Mistral AI Platform và vào thẻ API Keys .

Đặt workspace mặc định của bạn (nếu được nhắc) và nhấp Create new key.

Đặt tên có ý nghĩa cho key và tùy chọn ngày hết hạn.

Cuối cùng, sao chép key được tạo và export nó dưới dạng biến môi trường như sau:

export MISTRAL_API_KEY="your_mistral_api_key_here"Được hỗ trợ bởi

Đến đây, môi trường của chúng ta đã sẵn sàng để xác thực với Mistral API.

Bước 2: Khởi tạo client Mistral

Với môi trường đã cấu hình và phụ thuộc đã cài đặt, bước tiếp theo là khởi tạo client Mistral để xử lý mọi cuộc gọi tới mô hình Mistral Large 3. Điều này cung cấp điểm vào để gửi prompt từ ứng dụng Streamlit của chúng ta tới 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)Được hỗ trợ bởi

Đoạn mã trên làm ba việc:

• Đọc MISTRAL_API_KEY từ môi trường và lưu tên mô hình trong MODEL_ID, giúp tái sử dụng trong toàn bộ ứng dụng.
• Xác thực rằng API key đã được thiết lập và đưa ra lỗi rõ ràng nếu thiếu.
• Tạo một instance MistralClient bằng SDK chính thức mistralai, mà chúng ta sẽ dùng cho mọi yêu cầu tiếp theo tới mô hình.

Sau khi khởi tạo client, tiếp theo chúng ta sẽ xây dựng một số hàm trợ giúp để gửi prompt và xử lý phản hồi trong UI Streamlit.

Bước 3: Tiền xử lý thị giác

Trước khi gửi bất kỳ ảnh hoặc PDF nào tới Mistral Large 3, chúng ta cần làm cho chúng “thân thiện với mô hình”. Vision API hoạt động tốt nhất khi đầu vào là hình vuông, kích thước hợp lý và được mã hóa theo định dạng nhất quán. 

Bước 3.1: Cắt giữa thành hình vuông

Bắt đầu bằng cách tải ảnh đã tải lên và chuyển thành khung cắt hình vuông. 

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)Được hỗ trợ bởi

Đoạn mã trên đảm bảo biểu đồ hoặc bảng được tải lên sẽ được chuyển thành khung cắt hình vuông trước khi đưa vào mô hình, phù hợp với hướng dẫn thị giác của Mistral.

Bước 3.2: Thay đổi kích thước 

Tiếp theo, chúng ta đổi kích thước ảnh về tối đa (1024×1024) để cân bằng chất lượng, độ trễ và chi phí token.

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)Được hỗ trợ bởi

Tại đây, chúng ta tính hệ số scale để giữ cả hai chiều nhỏ hơn max_size trong khi vẫn bảo toàn tỷ lệ khung hình. Nếu ảnh đã đủ nhỏ, trả về nguyên trạng. Nếu không, tính kích thước mới và dùng nội suy LANCZOS để giảm kích thước chất lượng cao.

Bước này giúp ảnh không làm phình cửa sổ ngữ cảnh hoặc làm chậm phản hồi không cần thiết.

Bước 3.3: PDF thành ảnh xếp chồng

Với PDF, ta thường muốn cho mô hình xem hơn một trang. Một mẹo đơn giản là render tất cả các trang và xếp chồng dọc thành một ảnh cao duy nhất. 

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)Được hỗ trợ bởi

Hàm stack_images_vertically() nhận danh sách ảnh PIL, chuẩn hóa về cùng chiều rộng trong khi giữ tỷ lệ, tính tổng chiều cao và dán chúng lần lượt lên một canvas RGB duy nhất. Trong khi đó hàm uploaded_file_to_square_base64() quyết định xử lý dựa trên MIME type:

• Với PDF, chuyển mỗi trang thành ảnh, xếp chồng dọc và đổi kích thước kết quả.
• Với ảnh thường, tải ảnh, cắt giữa thành hình vuông và đổi kích thước.

Cả hai trường hợp đều trả về ảnh đã chuẩn hóa kèm MIME type cho bước mã hóa cuối.

Bước 3.4: Mã hóa sang base64 

Vision API của Mistral chấp nhận ảnh dưới dạng đối tượng image_url, có thể là URL thực hoặc 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}"Được hỗ trợ bởi

Chúng ta bắt đầu bằng cách ghi ảnh vào bộ đệm trong bộ nhớ và chọn định dạng phù hợp (như JPEG hoặc PNG), rồi mã hóa base64 các byte. 

Cuối cùng, bọc chuỗi đã mã hóa vào URL data:{mime_type};base64 có thể truyền trực tiếp cho Mistral Vision API dưới dạng image_url.

Kết thúc bước này, mọi tệp tải lên, dù là PNG đơn, dashboard rộng hay PDF nhiều trang, đều đi qua cùng pipeline cắt giữa, đổi kích thước, xếp chồng PDF và chuyển thành data URL base64.

Bước 4: Gọi suy luận đa phương thức 

Ở bước này, chúng ta gói mọi thứ vào một hàm trợ giúp duy nhất để gửi yêu cầu bao gồm thị giác và văn bản, đồng thời bắt buộc mô hình phản hồi ở định dạng JSON. Ta làm vậy bằng cách kết hợp:

• Một system prompt xác định vai trò của mô hình là Multimodal Intelligence Evaluator,
• Một thông điệp người dùng kết hợp hướng dẫn với nội dung hình ảnh, và
• Một JSON Schema được truyền qua response_format để đầu ra có cấu trúc và dễ phân tích.

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Được hỗ trợ bởi

Hàm call_mistral_large_multimodal() là động cơ cốt lõi của bản demo trí tuệ đa phương thức.

• Hàm xây dựng một JSON Schema định nghĩa mảng cho csv_tables, insights, risks, anomalies và một đối tượng translations với các khóa lấy từ danh sách languages. 
• Chúng ta cũng định nghĩa một system prompt chi tiết đóng khung mô hình như một Multimodal Intelligence Evaluator và hướng dẫn các nhiệm vụ đọc số liệu, tái tạo bảng thành CSV, trích xuất insight, rủi ro, bất thường và tóm tắt đa ngôn ngữ.
• Hàm call_mistral_large_multimodal() sau đó tạo mảng messages ở định dạng chat bằng cách kết hợp hướng dẫn hệ thống với thông điệp người dùng chứa cả hướng dẫn văn bản và payload image_url. Gọi client.chat() với MODEL_ID, giữ temperature thấp để đầu ra ổn định và response_format={"type": "json_schema",} để phản hồi tuân thủ schema. Cuối cùng, chúng ta thử phân tích bằng json.loads.

Với phần này, bạn đã có một điểm vào vững chắc để biến biểu đồ hay ảnh báo cáo thô thành một tường thuật có cấu trúc.

Bước 5: Xây dựng UI Streamlit

Với pipeline tiền xử lý và client Mistral đã sẵn sàng, bước cuối cùng là gói mọi thứ trong giao diện 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)Được hỗ trợ bởi

Đoạn mã UI StreamLit trên thực hiện một số việc chính:

Phương thức st.set_page_config chia bố cục thành hai cột. Bên trái xử lý đầu vào cốt lõi (trình tải tệp và vùng văn bản có thể chỉnh sửa với hướng dẫn mặc định). Trong khi đó, bên phải cung cấp tùy chọn đa ngôn ngữ qua st.multiselect và nút chính Run Analysis. Khi nhấn nút, ứng dụng xác thực rằng có tệp, đồng thời chuyển đổi ảnh hoặc PDF thành data URL base64 và hiển thị ảnh xem trước. 

Khi có kết quả, các bảng CSV được tái tạo sẽ được hiển thị dưới dạng dataframe, cùng với insight, rủi ro, bất thường và mọi tóm tắt đa ngôn ngữ. Tùy chọn, chúng ta có thể bật chế độ debug (đang comment) để kiểm tra JSON thô trong quá trình phát triển.

Hoàn tất bước này, bạn có thể lưu tất cả thành app.py và khởi chạy toàn bộ trải nghiệm với:

streamlit run app.pyĐược hỗ trợ bởi

Trong video dưới đây, bạn có thể thấy phiên bản rút gọn của quy trình hoạt động với cả đầu vào ảnh và PDF: