Automatizzare Attività Ripetitive con AI Locale e LLM Open Source

Come Automatizzo le Attività Ripetitive sul PC con l’AI Locale: Script e Workflow Pratici con LLM Open Source

Se c’è una cosa che ho imparato in anni di lavoro come System Administrator è che le attività ripetitive sono il nemico numero uno della produttività. Rinominare centinaia di file, analizzare log, generare report, classificare email, scrivere documentazione: operazioni che singolarmente richiedono pochi minuti, ma che sommate divorano ore preziose ogni settimana. Da quando ho iniziato a usare modelli AI in locale tramite Ollama e script personalizzati, ho drasticamente ridotto il tempo dedicato a queste operazioni.

In una guida precedente vi ho mostrato come installare e usare un modello AI in locale con Ollama. Oggi faccio un passo avanti: vi mostro come automatizzo concretamente le attività ripetitive sul PC combinando LLM open source, script Python e Bash, e workflow che potete replicare subito. Tutto gira in locale, senza inviare dati a servizi cloud, il che è fondamentale per chi lavora con dati sensibili o semplicemente vuole mantenere il controllo totale sulla propria infrastruttura.

In questo articolo condivido i workflow pratici che uso quotidianamente, con codice funzionante e testato. Non si tratta di teoria: sono soluzioni nate da esigenze reali che ho affinato nel tempo.

Perché Automatizzare con l’AI Locale invece dei Servizi Cloud

Prima di entrare nel vivo, lasciatemi spiegare perché preferisco l’approccio locale. I servizi AI cloud come ChatGPT API o Claude API sono potentissimi, ma presentano alcuni limiti concreti per l’automazione quotidiana:

Privacy dei dati: i log dei server, le email dei clienti, i file di configurazione contengono informazioni sensibili che non voglio far transitare su server di terze parti.
Costi ricorrenti: se automatizzo decine di task al giorno, le chiamate API si accumulano rapidamente.
Latenza e dipendenza dalla rete: se la connessione cade o l’API ha problemi, l’automazione si blocca.
Controllo totale: posso scegliere il modello, ottimizzarlo, e farlo girare anche su macchine air-gapped.

Con Ollama e modelli come Llama 3.1, Mistral, Phi-3 o Qwen2.5, ottengo risultati eccellenti per task di automazione senza uscire dalla mia rete locale.

Prerequisiti: Configurazione dell’Ambiente

Per seguire questa guida, avete bisogno di:

Ollama installato e funzionante – se non l’avete ancora configurato, seguite la mia guida completa all’installazione di Ollama.
Python 3.10+ con la libreria requests (oppure il pacchetto ufficiale ollama).
Un modello adatto: per l’automazione consiglio Llama 3.1 8B o Qwen2.5 7B come buon compromesso tra velocità e qualità.
Almeno 8 GB di RAM liberi per il modello (16 GB consigliati). Se state valutando un upgrade della RAM, ho scritto un’analisi sui costi della RAM e come risparmiare.

Installiamo le dipendenze Python:

pip install ollama requests

Scarichiamo il modello che useremo negli esempi:

ollama pull llama3.1

Script 1: Analisi Automatica dei Log con AI Locale

Uno dei task più frequenti nel mio lavoro è analizzare i log dei server per individuare anomalie, tentativi di intrusione o errori ricorrenti. Invece di fare grep manuali su file da migliaia di righe, ho creato uno script che passa i log all’LLM locale e mi restituisce un report strutturato.

Il Codice Python per l’Analisi dei Log

Ecco lo script che uso quotidianamente:

#!/usr/bin/env python3 """Analisi automatica dei log server con LLM locale via Ollama.""" import ollama import sys from pathlib import Path


def analizza_log(filepath, max_lines=200):
    """Legge un file di log e lo analizza con il modello locale."""
    log_content = Path(filepath).read_text(encoding='utf-8', errors='ignore')
    # Prendiamo le ultime N righe per non superare il context window
    lines = log_content.strip().split('n')[-max_lines:]
    log_chunk = 'n'.join(lines)
    prompt = f"""Sei un system administrator esperto. Analizza questo log e fornisci:
1. ERRORI CRITICI trovati (con riga e spiegazione)
2. PATTERN SOSPETTI (tentativi brute force, accessi anomali)
3. RACCOMANDAZIONI operative
Rispondi in italiano, in modo conciso e strutturato.
LOG:
{log_chunk}"""
    response = ollama.chat(
        model='llama3.1',
        messages=[{'role': 'user', 'content': prompt}]
    )
    return response['message']['content']

if __name__ == '__main__': if len(sys.argv) < 2: print("Uso: python analizza_log.py /percorso/file.log") sys.exit(1) risultato = analizza_log(sys.argv[1]) print(risultato)

Nella mia esperienza, questo script mi ha permesso di individuare in pochi secondi un pattern di tentativi di accesso SSH che avrei impiegato 20 minuti a identificare manualmente. Ho poi integrato il risultato con la configurazione di Fail2Ban su Plesk per bloccare automaticamente gli IP sospetti.

Script 2: Rinominare e Classificare File in Massa

Un altro task che mi capitava spesso: rinominare e organizzare centinaia di file (documenti, screenshot, backup) in cartelle strutturate. L’AI locale è perfetta per analizzare il contenuto o il nome del file e suggerire una classificazione.

Script di Classificazione Automatica

#!/usr/bin/env python3 """Classifica e rinomina file usando LLM locale.""" import ollama import os import json from pathlib import Path


def classifica_file(filename):
    """Chiede al modello di classificare un file dal nome."""
    prompt = f"""Dato il seguente nome file, restituisci SOLO un JSON valido con:
- "categoria": una tra [documenti, immagini, backup, log, configurazione, altro]
- "nome_suggerito": un nome più descrittivo e pulito (snake_case, senza spazi)
Nome file: {filename}
JSON:"""
    response = ollama.chat(
        model='llama3.1',
        messages=[{'role': 'user', 'content': prompt}],
        options={'temperature': 0.1}  # Bassa creatività per output consistente
    )
    try:
        return json.loads(response['message']['content'])
    except json.JSONDecodeError:
        return {'categoria': 'altro', 'nome_suggerito': filename}

def organizza_cartella(directory): """Scansiona una cartella e organizza i file.""" base = Path(directory) for f in base.iterdir(): if f.is_file(): info = classifica_file(f.name) dest_dir = base / info['categoria'] dest_dir.mkdir(exist_ok=True) new_name = info['nome_suggerito'] + f.suffix print(f" {f.name} → {info['categoria']}/{new_name}") # Decommentare per eseguire davvero lo spostamento: # f.rename(dest_dir / new_name)

Un consiglio: all’inizio non funzionava bene perché il modello restituiva JSON con formattazione extra o commenti. Abbassare la temperature a 0.1 e specificare chiaramente “SOLO un JSON valido” nel prompt ha risolto il problema al 90%.

Script 3: Generazione Automatica di Documentazione

Documentare le configurazioni è fondamentale ma noioso. Ho creato uno script che prende un file di configurazione (Nginx, Apache, firewall) e genera automaticamente una documentazione leggibile.

Documentazione da File di Configurazione

#!/usr/bin/env python3 """Genera documentazione da file di configurazione.""" import ollama from pathlib import Path import sys


def documenta_config(filepath):
    config = Path(filepath).read_text()
    prompt = f"""Sei un sysadmin senior. Analizza questa configurazione e genera
documentazione in Markdown italiano con:
- Descrizione generale dello scopo del file
- Spiegazione di ogni sezione/blocco importante
- Eventuali problemi di sicurezza o performance
- Suggerimenti di miglioramento
File: {filepath}
Contenuto:
{config}"""
    response = ollama.chat(
        model='llama3.1',
        messages=[{'role': 'user', 'content': prompt}]
    )
    # Salva la documentazione generata
    doc_path = Path(filepath).with_suffix('.md')
    doc_path.write_text(response['message']['content'])
    print(f"Documentazione salvata in: {doc_path}")

if __name__ == '__main__': documenta_config(sys.argv[1])

Questo mi è stato utilissimo quando ho dovuto documentare le configurazioni dei virtual host Nginx con HTTP/3 che avevo configurato su diversi server Plesk.

Script 4: Automazione Bash con AI per Task di Sistema

Non tutto deve essere in Python. Per task più leggeri, uso direttamente curl verso l’API locale di Ollama da script Bash. Ecco un esempio che uso per generare un riassunto giornaliero delle attività del server:

#!/bin/bash # Report giornaliero server generato con AI locale REPORT_DATE=$(date +%Y-%m-%d) OUTPUT="/var/reports/daily_${REPORT_DATE}.txt"


# Raccogliamo le informazioni
DISK_USAGE=$(df -h | head -10)
MEMORY=$(free -h)
FAILED_LOGINS=$(journalctl --since "24 hours ago" | grep -i "failed" | tail -20)
TOP_PROCESSES=$(ps aux --sort=-%mem | head -10)
PROMPT="Genera un report giornaliero conciso in italiano per il sysadmin basandoti su questi dati del server:nnDISCO:n${DISK_USAGE}nnMEMORIA:n${MEMORY}nnLOGIN FALLITI (ultime 24h):n${FAILED_LOGINS}nnPROCESSI TOP MEMORIA:n${TOP_PROCESSES}nnEvidenzia criticità e azioni consigliate."
curl -s http://localhost:11434/api/generate 
  -d "{"model": "llama3.1", "prompt": "${PROMPT}", "stream": false}" 
  | python3 -c "import sys,json; print(json.load(sys.stdin)['response'])" 
  > "${OUTPUT}"

echo "Report salvato in ${OUTPUT}"

Inserisco questo script in un cron job che gira ogni mattina alle 7:00, così quando apro il PC trovo già il report pronto.

Workflow Avanzato: Pipeline di Automazione Completa

Il vero potere emerge quando concateno più script in una pipeline. Ecco il workflow che uso per la gestione quotidiana dei server:

Ore 6:00 – Cron esegue lo script di analisi log su auth.log, mail.log ed error.log.
Ore 6:30 – Lo script di report giornaliero genera il riassunto aggregato.
Ore 7:00 – Un ulteriore script AI analizza il report e, se trova criticità, mi invia una notifica via webhook su Telegram.
Su richiesta – Uso lo script di documentazione ogni volta che modifico una configurazione.

La notifica Telegram è semplicissima:

#!/bin/bash REPORT=$(cat /var/reports/daily_$(date +%Y-%m-%d).txt) TELEGRAM_TOKEN="il_tuo_token" CHAT_ID="il_tuo_chat_id"


# Chiediamo all'AI se ci sono criticità
CHECK=$(curl -s http://localhost:11434/api/generate 
  -d "{"model": "llama3.1", "prompt": "Rispondi SOLO con SI o NO: ci sono criticità urgenti in questo report?n${REPORT}", "stream": false}" 
  | python3 -c "import sys,json; print(json.load(sys.stdin)['response'])")

if echo "$CHECK" | grep -qi "SI"; then curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_TOKEN}/sendMessage" -d chat_id="${CHAT_ID}" -d text="⚠️ CRITICITÀ SERVER: ${REPORT:0:500}" fi

Consigli Pratici per Prompt Efficaci nell’Automazione

Dopo mesi di utilizzo, ho raccolto alcune regole d’oro per i prompt nell’automazione con LLM open source:

Sii specifico sul formato di output: se vuoi JSON, scrivi “Rispondi SOLO con JSON valido”. Se vuoi una lista, specifica il formato esatto.
Usa temperature basse (0.1-0.3) per task di analisi e classificazione, dove serve consistenza.
Limita il contesto: non passare file da 10.000 righe. Spezzali in chunk gestibili.
Definisci un ruolo: “Sei un sysadmin esperto” aiuta il modello a calibrare il registro e la profondità tecnica.
Testa con dry-run: prima di far rinominare o spostare file, stampa le operazioni senza eseguirle.

Scelta del Modello: Quale LLM Open Source per Quale Task

Non tutti i modelli sono uguali per l’automazione. Ecco cosa ho osservato nella mia esperienza:

Llama 3.1 8B: il miglior tuttofare. Eccellente per analisi log, documentazione, classificazione. Richiede circa 5-6 GB di RAM.
Qwen2.5 7B: ottimo per generazione di codice e output strutturato (JSON). Molto preciso con le istruzioni di formato.
Phi-3 Mini 3.8B: perfetto se avete hardware limitato. Più veloce ma meno preciso sui task complessi.
Mistral 7B: buone performance generali, particolarmente forte nella comprensione del contesto lungo.
Codellama / DeepSeek Coder: se il task principale è generare o analizzare codice, questi modelli specializzati sono la scelta migliore.

Sicurezza e Best Practice

Automatizzare con l’AI locale non significa abbassare la guardia. Ecco le best practice di sicurezza che seguo sempre:

L’API di Ollama di default ascolta solo su localhost:11434. Non esponetela su interfacce pubbliche senza autenticazione.
Non date mai agli script permessi di root se non strettamente necessario.
Validate sempre l’output dell’AI prima di eseguire operazioni distruttive (rinomina, cancellazione, modifica configurazioni).
Mantenete i log delle operazioni automatizzate per audit.
Se lavorate con dati particolarmente sensibili, considerate la segmentazione della rete per isolare la macchina che esegue l’AI.

FAQ

Quanta RAM serve per far girare gli script di automazione con LLM locale?

Per un modello 7-8B parametri come Llama 3.1 servono almeno 8 GB di RAM liberi, ma consiglio 16 GB totali per lavorare comodamente. Modelli più piccoli come Phi-3 Mini girano anche con 4-5 GB liberi. La GPU non è strettamente necessaria ma accelera notevolmente l’inferenza.

Posso usare questi script su Windows oltre che su Linux?

Sì, gli script Python funzionano identicamente su Windows, macOS e Linux. Per gli script Bash, su Windows potete usare WSL2 (Windows Subsystem for Linux) oppure riscriverli in PowerShell. Ollama è disponibile per tutte le piattaforme principali.

L’output dell’AI locale è affidabile per l’automazione in produzione?

Dipende dal task. Per analisi e classificazione (dove l’AI suggerisce e un umano valida) è estremamente utile. Per operazioni distruttive automatiche (cancellazione file, modifica configurazioni) consiglio sempre un passaggio di validazione umana o almeno un dry-run. Il modello può sbagliare, soprattutto con input ambigui.

Quali alternative a Ollama esistono per eseguire LLM in locale?

Le alternative principali sono LM Studio (interfaccia grafica, ottimo per principianti), llama.cpp (riga di comando puro, massima performance), LocalAI (compatibile con API OpenAI) e GPT4All. Io preferisco Ollama per la semplicità di gestione dei modelli e l’API REST integrata che si presta perfettamente all’automazione via script.

Posso automatizzare anche task legati a WordPress con questo approccio?

Assolutamente sì. Ad esempio uso un approccio simile per generare meta description, analizzare i log di errore di WordPress, o classificare commenti spam. Se gestite WordPress su Plesk, gli script di analisi log si integrano perfettamente con i log di accesso del web server. Per la sicurezza di WordPress vi rimando alla mia guida sulla protezione da attacchi brute force.

Conclusione

Automatizzare le attività ripetitive con l’AI locale è una delle scelte più produttive che ho fatto negli ultimi anni. Con Ollama e modelli LLM open source come Llama 3.1 o Qwen2.5, ho costruito un ecosistema di script che mi fa risparmiare ore ogni settimana, mantenendo il pieno controllo sui miei dati e senza costi ricorrenti per API cloud.

Il bello di questo approccio è che è modulare e incrementale: potete partire da un singolo script (magari quello per l’analisi dei log) e aggiungere gradualmente altri workflow man mano che prendete confidenza. Non serve essere sviluppatori esperti – i prompt fanno il grosso del lavoro, e Python con la libreria Ollama rende tutto estremamente accessibile.

Se avete domande, volete condividere i vostri script di automazione con AI locale, o avete trovato workflow ancora più efficienti, scrivete nei commenti: sono sempre curioso di scoprire come altri professionisti IT sfruttano queste tecnologie nel lavoro quotidiano.