🤖 Ollama in locale, endpoint esterno… o modelli “Mini”?

Guida rapida per scegliere la soluzione LLM più adatta a te

TL;DR — Se vuoi tenere i dati a casa, non spendere un centesimo e hai una GPU decente, Ollama con un modello Mini (o quantizzato) è la scelta giusta. Se invece cerchi il massimo della potenza, la minima latenza e non ti preoccupa il costo, un’API cloud è la soluzione più semplice.

1. Perché parlare di LLM ora?

Negli ultimi mesi i Large Language Models (LLM) hanno invaso sia le chat di classe sia i videogiochi, passando da “cose da scienziati pazzi” a strumenti pratici per fare i compiti, scrivere canzoni o creare meme.

Il problema? Troppe opzioni:

• Modelli di frontiera (GPT-4o, Claude 3.5, Gemini 1.5)

• Modelli “Mini” (Llama-3-8B, Gemma-2-2B, Phi-3-mini)

• Versioni quantizzate (INT8, INT4)

• E tanto altro.

In questo post ti spiego, passo dopo passo, come orientarti tra locale e cloud, perché la GPU è importante e come testare tutto con un semplice script Python.

2. I concetti chiave da tenere a mente

2.1 LLM di frontiera e “distillato”

Termine	Cos’è?	Perché è importante
Frontier Model	Il modello più avanzato disponibile in quel momento (es. GPT-4o, Claude 3.5 Sonnet, Gemini 1.5 Pro).	Richiede server giganteschi e costi elevati, ma offre prestazioni al top.
Distillazione (Knowledge Distillation)	Tecnica in cui un modello “piccolo” (studente) impara a imitare il comportamento di un modello “grande” (maestro).	Permette di avere modelli più leggeri, ma con gran parte delle capacità del modello più grande.

2.2 Cosa sono i modelli “Mini”?

• Dimensione: 1–8 miliardi di parametri (es. Llama-3-8B, Gemma-2-2B, Phi-3-mini).

• Obiettivo: ridurre drasticamente RAM/VRAM e potenza di calcolo, rendendoli adatti a PC consumer.

• Uso tipico: chat locale, assistenti per lo studio, prototipi di videogiochi indie.

2.3 GPU vs. CPU: la differenza che conta

Caratteristica	GPU	CPU
Architettura	Migliaia di core piccoli, ottimizzati per calcoli paralleli (matrici).	Pochi core veloci, ottimizzati per operazioni sequenziali.
Performance LLM	Ideale per modelli grandi, riduce il tempo per token.	Sufficientemente buona per Mini e modelli quantizzati.
Consumo energetico	Più alto, ma più veloce → meno tempo acceso.	Più basso, ma può richiedere più tempo.

Curiosità: le moderne GPU da 8 GB (tipo RTX 3050) possono far girare un modello Mini in pochi secondi; una CPU i5-12400 può fare lo stesso se il modello è quantizzato a 4 bit.

3. Locale vs. endpoint esterno: il classico “trade-off”

Fattore	Esecuzione locale (es. Ollama)	Endpoint cloud (es. OpenAI, Anthropic)
Privacy	Massima – i dati rimangono sul tuo PC.	I dati viaggiano su Internet e dipendono dalle policy del provider.
Hardware richiesto	GPU consigliata, altrimenti CPU potente + RAM.	Nessun requisito particolare, solo una connessione Internet.
Costo	Gratuito (solo energia elettrica).	Pay-per-token o abbonamento (da pochi centesimi a dollari al mese).
Aggiornamenti	Devi scaricare nuovi modelli manualmente.	Modelli aggiornati e gestiti dal provider.
Latenza	Dipende dalla velocità del tuo PC.	Dipende dalla connessione e dal carico del servizio.
Scalabilità	Limitata alle risorse del tuo hardware.	Elevata: puoi aumentare le risorse tramite API e infrastruttura cloud.

Quando scegliere cosa?

Scenario	Consiglio
Devi gestire informazioni sensibili (es. verifiche scolastiche)	Usa Ollama in locale.
Hai un laptop senza GPU e vuoi provare qualcosa subito	Vai con un endpoint cloud (API gratuita o trial).
Vuoi sperimentare modelli più grandi senza spendere	Prova un modello Mini quantizzato su CPU.
Ti serve la massima qualità per un progetto YouTube	Usa un’API cloud con un modello di frontiera.

4. I modelli quantizzati: la chiave per far volare gli LLM su CPU

4.1 Che cosa significa “quantizzato”?

• I pesi di un LLM sono normalmente rappresentati come numeri in FP16/FP32 (16/32 bit in virgola mobile).

• Quantizzare significa comprimere questi numeri a INT8, INT4 o addirittura INT2 (8, 4 o 2 bit interi).

• Il termine quantizzazione indica il passaggio da una rappresentazione continua a una rappresentazione discreta.

4.2 Caratteristiche dei modelli quantizzati

Pro	Contro
Dimensioni ridotte – un modello da 8 B di parametri passa da ~16 GB a ~4–5 GB.	Leggera perdita di precisione: la perdita dipende dal metodo di quantizzazione e dal modello.
Minor consumo di RAM/VRAM – può girare anche su laptop con 8 GB di RAM.	Alcune operazioni matematiche più complesse possono richiedere implementazioni specifiche.
Velocità su CPU – meno dati da leggere significa meno colli di bottiglia nella memoria.	Non tutti i framework supportano tutti i tipi di quantizzazione.

4.3 Perché i modelli quantizzati possono essere più veloci su CPU?

1. Banda di memoria: riducendo la rappresentazione da 16 bit a 4 bit, la CPU deve trasferire molti meno dati per elaborare i pesi.

2. Istruzioni SIMD (Single Instruction, Multiple Data): le architetture moderne dispongono di istruzioni ottimizzate per elaborazioni vettoriali e, in alcuni casi, per operazioni su interi.

Esempio pratico:Llama-3-8B non quantizzato su una CPU i5-12400 impiega ~6 s per generare 50 token.Lo stesso modello quantizzato a 4 bit (GGUF) impiega ~1,5 s per gli stessi 50 token.

5. Metti alla prova il tuo hardware: lo script Python di benchmark

Di seguito trovi uno script super semplice che ti permette di:

1. Caricare un modello Mini (normale o quantizzato) tramite Ollama.

2. Inviare una richiesta a un endpoint cloud (es. OpenAI).

3. Misurare il tempo al primo token, i token al secondo e l’uso della RAM.

Nota: lo script usa SDK openai. Puoi sostituire openai con requests per le API cloud e la libreria Python di Ollama (ollama), se preferisci.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Riassuntore veloce con Ollama + MiniCPM‑V 8B

Come usarlo
-----------
$ ollama pull minicpm-v:8b
$ echo "Il Sole è una stella ..." | python3 test_ollama.py
# oppure
$ python3 test_ollama.py < mio_testo.txt
"""

import sys
import time
from openai import OpenAI          # pip install openai


def send_to_ollama(text: str,
                   prompt_system: str,
                   model: str = "minicpm-v:8b:q4_0") -> str:
    """Invia la richiesta a Ollama (endpoint OpenAI‑compatible)."""
    OLLAMA_BASE_URL = "http://localhost:11434/v1"
    client = OpenAI(base_url=OLLAMA_BASE_URL, api_key="ollama")  # api_key è ignorata

    response = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": prompt_system},
            {"role": "user",   "content": text}
        ],
        temperature=0.0,                # output deterministico per il riassunto
    )
    return response.choices[0].message.content


def main() -> None:
    # Legge tutto il testo da STDIN (funziona anche con < file.txt)
    user_text = sys.stdin.read().strip()
    if not user_text:
        sys.stderr.write("[ERROR] Nessun testo da riassumere (stdin vuoto).\n")
        sys.exit(1)

    # Prompt di sistema –‑ può essere modificato a piacere
    system_prompt = (
        "Sei un assistente specializzato nel riassumere testi. "
        "Fornisci un riassunto di massimo 150 parole, "
        "preservando le informazioni più importanti."
    )

    # Misura il tempo di risposta
    start = time.time()
    try:
        summary = send_to_ollama(user_text, system_prompt, model="minicpm-v:8b")
    except Exception as e:
        sys.stderr.write(f"[ERROR] Ollama ha risposto con errore: {e}\n")
        sys.exit(1)
    elapsed = time.time() - start

    # Stampa risultato
    print("\n===== RIASSUNTO =====\n")
    print(summary.strip())
    print("\n=====================\n")
    print(f"⏱️  Tempo impiegato: {elapsed:.2f} s")


if __name__ == "__main__":
    main()

Come usarlo?

1. Installa le dipendenze:

   pip install ollama

2. Scarica il modello con Ollama:

   ollama pull minicpm-v:8b

3. Esegui lo script:

   test_ollama.py < mio_testo.txt

Con il calcolo del tempo puoi decidere subito se la tua CPU è sufficiente o se è più conveniente passare al cloud.

6. Checklist veloce: cosa controllare prima di scegliere

✅ Cosa controllare	✔️ Come verificarlo
Hai una GPU dedicata?	nvidia-smi (Windows/Linux) oppure “Info GPU” su macOS.
RAM/VRAM disponibili?	Controlla in Task Manager o Activity Monitor (almeno 4 GB per un Mini quantizzato).
Ti interessa la privacy?	Preferisci il locale se lavori con dati sensibili (es. app di studio).
Budget mensile?	Calcola il costo cloud: token × $0,00002 ≈ $1,50 per 75k token.
Hai tempi di risposta stretti?	Testa con lo script; la latenza cloud è spesso più bassa, ma dipende dalla rete e dal servizio.
Vuoi aggiornamenti automatici?	Scegli un endpoint cloud; i modelli locali vanno aggiornati manualmente.

7. Conclusioni: la tua decisione in 3 step

1. Definisci la priorità: privacy ↔ costi ↔ prestazioni.

2. Controlla l’hardware: se hai una GPU decente, parti subito con Ollama; se non ce l’hai, scegli un modello quantizzato o il cloud.

3. Prova con lo script: i dati reali ti daranno la risposta più chiara.

Consiglio da esperto: inizia con Ollama + modello Mini quantizzato (es. gemma-2-2b-quantized). Ti costerà zero, avrai il massimo controllo sui dati e scoprirai rapidamente se il tuo PC è adatto. Se il risultato non è soddisfacente, passa a un endpoint cloud e sfrutta la potenza dei modelli di frontiera.

🎉 Vuoi andare oltre?

• Scarica Ollama: https://ollama.com

• Prova i modelli quantizzati:

  per esempio : ollama pull llama-3-8b-4bit

• Leggi la documentazione di llama.cpp per capire come funziona la quantizzazione sotto al cofano.

#IntelligenzaArtificiale #LLM #Ollama #AI #MachineLearning #Python #GPU #CloudComputing #OpenSource #Tecnologia