Source: Ollama

Run Pixtral 12B Locally with Ollama

Mistral's multimodal vision model — analyze images, documents, and charts without sending visual data to the cloud.

Most enterprise AI use cases eventually hit a wall: the data that matters most — contracts with signatures, financial charts, engineering schematics, medical imaging reports, ID documents — exists as images or PDFs, not clean text. Cloud vision APIs can process these files, but doing so means transmitting sensitive visual content to external servers. Pixtral 12B, run locally with Ollama, eliminates that exposure entirely.

Released by Mistral AI in September 2024, Pixtral 12B is the first truly capable open-source multimodal model at this parameter count. It combines a 400M-parameter vision encoder with Mistral Nemo's 12B language backbone, supports variable image resolutions up to high-definition, and can process multiple images in a single context window. For organizations handling confidential visual content, the ability to run Pixtral on local hardware is not a nice-to-have — it is a compliance requirement.

Why Vision Privacy Matters More Than Text Privacy

When professionals think about AI data privacy, they typically focus on the text they type into chat interfaces. But visual data carries far greater risk of sensitive information exposure. Consider what passes through a typical enterprise vision workflow:

A law firm processing discovery materials uploads scanned exhibits — witness signatures, handwritten annotations, physical document metadata — to a cloud vision API. A hospital's radiology department runs AI-assisted report drafting on DICOM-exported images. A financial analyst feeds earnings presentation slides into a vision model to extract chart data before public release. An HR team processes uploaded ID documents for onboarding verification.

In each case, the visual content carries identification, privilege, or confidentiality implications that text summaries alone cannot capture. Cloud vision APIs are technically processing this content on external infrastructure, regardless of contractual protections. Pixtral 12B deployed locally processes every image on your hardware, with no network transmission of visual content.

Technical Specifications

Hardware Requirements

Quickstart with Ollama

Pull and Run

# Pull Pixtral 12B
ollama pull pixtral

# Interactive session with image
ollama run pixtral "Describe what you see in this chart" --image ./q3_revenue.png

# CLI with local image path
ollama run pixtral "Extract all text visible in this document" \
  --image /path/to/scanned_contract.jpg

REST API with Image

import ollama
import base64

# Load and encode image locally
with open("financial_chart.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode("utf-8")

response = ollama.chat(
    model="pixtral",
    messages=[
        {
            "role": "user",
            "content": "Analyze this financial chart. Extract: "
                       "1) The time period shown "
                       "2) Key data series and their values "
                       "3) The overall trend "
                       "4) Any anomalies or notable data points",
            "images": [image_data]
        }
    ]
)

print(response['message']['content'])

Multi-Image Analysis

import ollama
import base64

def encode_image(path):
    with open(path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

# Compare multiple documents or images in one pass
response = ollama.chat(
    model="pixtral",
    messages=[
        {
            "role": "user",
            "content": """Compare these two contract pages and identify:
            1) Any differences in key terms
            2) Clauses present in one but not the other
            3) Any redline changes or annotations""",
            "images": [
                encode_image("contract_v1_page3.jpg"),
                encode_image("contract_v2_page3.jpg")
            ]
        }
    ]
)

print(response['message']['content'])

Document Processing Pipeline

One of Pixtral's highest-value enterprise applications is processing scanned documents — contracts, invoices, forms, and reports that exist only as images. Unlike OCR-only solutions, Pixtral understands document structure, layout, and context, enabling extraction that goes beyond raw text.

Invoice and Receipt Processing

import ollama, json, base64

def process_invoice(image_path: str) -> dict:
    with open(image_path, "rb") as f:
        image_data = base64.b64encode(f.read()).decode("utf-8")

    response = ollama.chat(
        model="pixtral",
        messages=[
            {
                "role": "system",
                "content": "Extract structured data from documents. Return only valid JSON."
            },
            {
                "role": "user",
                "content": """Extract all invoice data from this image as JSON with fields:
                {
                  "vendor_name": string,
                  "invoice_number": string,
                  "invoice_date": "YYYY-MM-DD",
                  "due_date": "YYYY-MM-DD",
                  "line_items": [{"description": string, "qty": number, "unit_price": number, "total": number}],
                  "subtotal": number,
                  "tax": number,
                  "total_due": number,
                  "currency": string,
                  "payment_terms": string
                }""",
                "images": [image_data]
            }
        ],
        format="json"
    )

    return json.loads(response['message']['content'])

# Process locally — invoice image never leaves your server
invoice_data = process_invoice("invoices/acme_inv_2024_0847.jpg")
print(invoice_data)

Contract Clause Extraction

import ollama, base64

def extract_contract_clauses(scanned_pdf_images: list) -> str:
    """Process multi-page scanned contract."""
    encoded_pages = []
    for path in scanned_pdf_images:
        with open(path, "rb") as f:
            encoded_pages.append(base64.b64encode(f.read()).decode("utf-8"))

    response = ollama.chat(
        model="pixtral",
        messages=[
            {
                "role": "user",
                "content": """Review these contract pages and extract:
                1. Parties involved (names, roles)
                2. Effective date and term
                3. Key obligations of each party
                4. Payment terms and amounts
                5. Termination conditions
                6. Governing law and jurisdiction
                7. Any unusual or non-standard clauses
                
                Flag any clauses that appear to be handwritten additions 
                or differ from standard formatting.""",
                "images": encoded_pages
            }
        ]
    )

    return response['message']['content']

Use Cases by Sector

Who Pixtral Is For

Available Model Sizes

The Pixtral line spans the accessible 12B and the high-end Pixtral Large. NoCloudGPT will confirm current model availability, license terms, tags, and hardware fit before deployment begins. NoCloudGPT confirms GPU requirements and selects the right quantization before your pilot begins.

Licensing Information

Pixtral licensing varies by model. Pixtral 12B is released under the permissive Apache 2.0 license — clear for commercial use. Pixtral Large, the 124B flagship, is released under the Mistral Research License (MRL), which permits research and non-commercial use but requires a separate commercial agreement with Mistral for production use. Confirm which model you are deploying before building on it.

Pixtral 12B is Apache 2.0; Pixtral Large is the non-commercial Mistral Research License. License information sourced from Hugging Face model cards and may change between releases. Always verify the current terms before commercial deployment. NoCloudGPT is not a legal advisor.

Batch Document Processing

import ollama, base64, json
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor
import time

def process_single_document(doc_path: Path) -> dict:
    """Process one document image through Pixtral locally."""
    with open(doc_path, "rb") as f:
        image_data = base64.b64encode(f.read()).decode("utf-8")

    response = ollama.chat(
        model="pixtral",
        messages=[{
            "role": "user",
            "content": "Classify this document type, extract key metadata, "
                       "and summarize main content in 2-3 sentences.",
            "images": [image_data]
        }]
    )

    return {
        "file": doc_path.name,
        "analysis": response['message']['content'],
        "processed_at": time.time()
    }

def batch_process_documents(folder: str, workers: int = 2) -> list:
    """
    Process folder of document images in parallel.
    workers=2 is conservative for single GPU — increase for multi-GPU setups.
    """
    doc_paths = list(Path(folder).glob("*.{jpg,jpeg,png,webp}"))
    results = []

    with ThreadPoolExecutor(max_workers=workers) as executor:
        futures = {executor.submit(process_single_document, p): p 
                   for p in doc_paths}
        for future in futures:
            try:
                results.append(future.result(timeout=120))
            except Exception as e:
                results.append({"file": str(futures[future]), "error": str(e)})

    return results

# Process entire folder of scanned documents — nothing leaves your server
results = batch_process_documents("/data/incoming_contracts/")
with open("processing_results.json", "w") as f:
    json.dump(results, f, indent=2)

Pixtral vs. Alternative Vision Models

Pixtral's key differentiator is multi-image support combined with a 128K context window under an Apache 2.0 license. Llama 3.2 Vision, while competitive on single-image tasks, processes only one image per request. Pixtral's ability to compare, cross-reference, and analyze multiple images in a single context window is essential for document comparison, multi-page processing, and before/after analysis workflows.

Optimizing for Document Workloads

# Modelfile optimized for document processing
FROM pixtral

PARAMETER temperature 0.1      # Low temperature for factual extraction
PARAMETER top_p 0.9
PARAMETER num_ctx 32768        # 32K is sufficient for most documents
PARAMETER repeat_penalty 1.05

SYSTEM """
You are a precise document analysis assistant. Your role is to:
- Extract information accurately and completely
- Preserve exact numbers, dates, names, and amounts as written
- Note any text that is unclear, handwritten, or potentially misread
- Flag document sections that appear incomplete, altered, or unusual
- Return structured data when requested as valid JSON

Never infer or guess information that is not clearly visible in the document.
If text is illegible, indicate [ILLEGIBLE] rather than guessing.
"""

# Build document-optimized model
ollama create doc-analyzer -f Modelfile.docanalyzer
ollama run doc-analyzer

Frequently Asked Questions