Guida completa al deployment di LLM locali: crea il tuo workflow di agenti per la libertà dai token (adatta ai principianti)

Questo articolo mira a essere il più chiaro possibile, permettendo a qualsiasi giocatore alle prime armi di padroneggiare facilmente il deployment di modelli locali e costruire il proprio flusso di lavoro.

Quest'anno, i modelli open-source nazionali sono stati molto attivi. DeepSeek, Qwen, Kimi, GLM, MiniMax... nuovi modelli appaiono uno dopo l'altro, aprendo costantemente i loro pesi e iniziando a competere con i modelli closed-source statunitensi.

Ma più modelli ci sono, più mi interessa una domanda specifica: questi modelli possono non solo rimanere in pagine web e API, ma essere effettivamente installati nelle nostre macchine, collegandosi a file locali, strumenti e flussi di lavoro?

Sebbene il prezzo unitario dei token API stia generalmente diminuendo, il costo rimane elevato in caso di chiamate ad alta frequenza e testi lunghi. A ciò si aggiungono problemi come privacy, rete e controllo dei dati, rendendo il deployment locale la scelta di un numero crescente di sviluppatori e aziende.

Quindi questa volta, voglio scegliere un modello con una dimensione impegnativa e rappresentativo del deployment su singola macchina per eseguire l'intero processo di deployment locale completo.

Il protagonista finalmente scelto è Ling-3.0-flash, open-sourced da Ant Bailing, un modello Mixture of Experts (MoE) con un totale di 124 miliardi di parametri. Ho per caso un NVIDIA DGX Spark a portata di mano, che può eseguirlo.

Senza ulteriori indugi, iniziamo lo spettacolo principale.

01 Glossario dei Termini

Prima di iniziare, introduciamo alcuni termini relativi ai modelli per mettere tutti al passo ✌🏻

Precisione del Modello

Lo stesso modello spesso fornisce diverse versioni di precisione o quantizzate, che influenzano direttamente la dimensione del modello e la soglia di esecuzione.

Questa volta stiamo usando la versione ufficiale Ling INT4, che misura circa 71,75 GB.

Denso o MoE

Nota che 5,1 miliardi è solo il numero di parametri attivati per inferenza; l'intero peso di 124 miliardi deve ancora essere caricato in memoria.

Motore di Inferenza

Il motore di inferenza è responsabile del caricamento dei pesi, della gestione del contesto e della concorrenza, e della fornitura di interfacce. È lo strumento per eseguire il modello, non il modello stesso.

Abbiamo scelto vLLM questa volta perché l'attuale adattamento ufficiale supporta i pesi INT4 di Ling-3.0-flash e la decodifica speculativa MTP.

02 Installazione e Deployment del Modello

Per prima cosa, introduciamo l'ambiente di installazione: sto usando un NVIDIA DGX Spark, dotato di un chip GB10 e 121,6 GB di memoria unificata, con Ubuntu 24.04 su architettura ARM64. Il deployment è Ling-3.0-flash-INT4, e i successivi test di throughput utilizzeranno il Qwen 3.8-27B locale come riferimento.

L'ufficiale fornisce una versione base e diverse versioni di precisione come FP8, FP4 e INT4. Puoi scegliere in base al tuo hardware.

Esiste anche un Ling-3.0-tiny da 8 miliardi e le sue versioni FP8, INT4. Gli utenti con un Mac normale o una singola 4090 possono provare prioritariamente le versioni a bassa precisione di Tiny.

Passo 1: Scarica il modello. Questa volta ho usato la versione INT4 ufficiale. Link per il download 👇🏻

• Hugging Face: Ling-3.0-flash-int4
• ModelScope: Ling-3.0-flash-int4

Se l'accesso a Hugging Face è scomodo, puoi scaricare manualmente da ModelScope. Dopo il download, ci sono 24 frammenti safetensors, per un totale di circa 71,75 GB. Devi anche lasciare spazio per il motore di inferenza e la KV Cache durante l'esecuzione.

Passo 2: Prepara l'ambiente. L'architettura BailingMoeV3 di Ling-3.0-flash è piuttosto nuova. Ho provato a usare GGUF con llama.cpp, ma ha dato errore con unknown model architecture: 'bailingmoe3'. Quindi questa volta, ho usato direttamente il ramo vLLM adattato ufficialmente:

1pip install uv
2uv venv ~/my_ling_env
3source ~/my_ling_env/bin/activate
4
5git clone -b ling_3_0 https://github.com/inclusionAI/vllm-ling-v3.git
6cd vllm-ling-v3
7VLLM_USE_PRECOMPILED=1 uv pip install --editable . --torch-backend=auto

Passo 3: Avvia il servizio di inferenza. Sostituisci il percorso del modello con i tuoi pesi INT4 scaricati localmente:

1vllm serve /path/to/Ling-3.0-flash-int4 \
2  --served-model-name ling-int4 \
3  --host 127.0.0.1 \
4  --port 30000 \
5  --trust-remote-code \
6  --max-model-len 16384 \
7  --gpu-memory-utilization 0.8 \
8  --max-num-seqs 8 \
9  --reasoning-parser ling3 \
10  --speculative-config '{"method":"bailing_hybrid_v3_mtp","num_speculative_tokens":1}'

⚠️

Sostituisci i percorsi nel comando con i percorsi effettivi sulla tua macchina.

Qui, il limite di contesto è impostato a 16K, la concorrenza a 8, e la decodifica speculativa MTP è abilitata.

Nota: MTP (Multi-Token Prediction) permette al modello di provare a predire più token contemporaneamente. Le parti correttamente predette possono essere adottate direttamente, riducendo i cicli di calcolo per generare token uno per uno e aumentando la velocità di output.

Passo 4: Verifica il servizio. Una volta avviato, invia una semplice richiesta:

1curl -s http://127.0.0.1:30000/v1/chat/completions \
2  -H "Content-Type: application/json" \
3  -d '{"model":"ling-int4",
4       "messages":[{"role":"user","content":"Ciao, presentati in una frase."}],
5       "stream":true}'

Il terminale inizia a restituire il contenuto in streaming, indicando che questo modello da 124 miliardi è in esecuzione localmente.

03 Test delle Prestazioni e delle Capacità del Modello

1. Throughput dei Token Quando il modello è stato avviato per la prima volta, ho eseguito un ciclo di test usando il benchmark integrato di vLLM. Tutte le 20 richieste sono state completate, con un throughput di output di 84,34 tok/s, un throughput totale di token di 133,10 tok/s e un tasso di accettazione MTP del 67,35%.

Output del log originale 👇🏻

1============ Serving Benchmark Result ============
2Successful requests:                     20
3Failed requests:                         0
4Request rate configured (RPS):           2.00
5Benchmark duration (s):                  60.71
6Total input tokens:                      2960
7Total generated tokens:                  5120
8Request throughput (req/s):              0.33
9Output token throughput (tok/s):         84.34
10Peak output token throughput (tok/s):    61.00
11Peak concurrent requests:                20.00
12Total token throughput (tok/s):          133.10
13---------------Time to First Token----------------
14Mean TTFT (ms):                          19692.98
15Median TTFT (ms):                        18877.99
16P99 TTFT (ms):                           40039.02
17-----Time per Output Token (excl. 1st token)------
18Mean TPOT (ms):                          44.61
19Median TPOT (ms):                        44.09
20P99 TPOT (ms):                           49.68
21---------------Inter-token Latency----------------
22Mean ITL (ms):                           74.09
23Median ITL (ms):                         72.39
24P99 ITL (ms):                            280.71
25---------------Speculative Decoding---------------
26Acceptance rate (%):                     67.35
27Acceptance length:                       1.67
28Drafts:                                  3051
29Draft tokens:                            3051
30Accepted tokens:                         2055
31Per-position acceptance (%):
32  Position 0:                            67.35
33==================================================

Successivamente, ho eseguito test di concorrenza su Ling e sul Qwen 3.8-27B locale. A 8 di concorrenza, il throughput aggregato di Ling era di 141,38 tok/s, mentre quello di Qwen 3.8 era di 32,61 tok/s, una differenza di circa 4,34 volte in questo ciclo.

🔥🔥🔥Confronto Stress Test Ling-3.0-Flash Vs Qwen3.8-27B

Ling-3.0-flash

Qwen 3.8 -27B

Qualcuno potrebbe chiedersi: perché la singola concorrenza di Ling è solo 34,77 tok/s, ma a 8 di concorrenza diventa 141,38 tok/s? Gli amici più tecnici potrebbero anche chiedersi se questo punteggio a singola concorrenza sia lento rispetto ai dati ufficiali.

Qui dobbiamo spiegare il metodo di test specifico e le differenze di velocità causate da diversi metodi di valutazione:

1. Metodo di Test e Collegamento End-to-End Reale: Questo test utilizza un'interfaccia locale compatibile con OpenAI, stress-testando tramite richieste HTTP in streaming, non un test di inferenza offline scollegato dal framework del servizio. Ogni richiesta Ling utilizza un prompt di testo lungo circa 150 token, generando fino a 512 token. Il tempo inizia dalla richiesta HTTP del client fino al completamento della risposta in streaming, includendo quindi chiamate HTTP locali, scheduling del servizio, elaborazione del Tokenizer, Prefill, decodifica token per token e ritorno in streaming.
2. Velocità di Output a Singolo Flusso vs. Throughput Aggregato della Macchina: Velocità a singolo flusso (esperienza utente reale): A $c=1$, la velocità di output end-to-end è di circa 35,34 tok/s (test reali di singola conversazione a 38+ tok/s), equivalente a oltre 35 caratteri cinesi al secondo, estremamente veloce visivamente; Throughput aggregato (output totale sotto concorrenza): All'aumentare della concorrenza, vLLM utilizza Continuous Batching per combinare più richieste in calcoli GPU, sfruttando appieno la larghezza di banda della memoria unificata di Blackwell. A 8 di concorrenza, il throughput aggregato della macchina è salito a 141,38 tok/s.

Per quanto riguarda il motivo per cui differisce da alcuni benchmark ufficiali, la chiave sono i criteri di test. La precisione del modello, il motore di inferenza, la lunghezza del contesto, il numero di token di input/output, la scala di concorrenza e se si utilizza inferenza offline o servizi HTTP influenzano tutti il risultato finale. Solo quando queste condizioni sono sostanzialmente coerenti i numeri sono adatti per un confronto diretto.

In parole povere: La velocità varia a causa dei metodi di valutazione—se testato con concorrenza estremamente alta (es. 32/64) o in un ambiente di puro calcolo senza protocolli di rete, i numeri di throughput totale sarebbero più alti; nelle nostre chiamate quotidiane di singola conversazione o produzione di codice, la velocità a singolo flusso di Ling di 35+ tok/s e la latenza del primo token inferiore a 220 ms sono già estremamente fluide e senza lag.

A concorrenza singola, la velocità media a singolo flusso di Ling è di circa 35,34 tok/s; a 8 di concorrenza, il throughput aggregato raggiunge 141,38 tok/s. Il throughput aggregato di Qwen3.8 a 8 di concorrenza è di 32,61 tok/s. In questo ciclo, il vantaggio di Ling si riflette principalmente nella velocità di output e nel throughput concorrente, con risposte notevolmente più veloci nell'uso reale.

2. Capacità Reali

I benchmark riflettono solo parte delle prestazioni; l'usabilità reale dipende dalle prestazioni del modello su problemi specifici. Ho scelto tre direzioni per test semplici.

(1) Ragionamento Logico

Ho preparato una variazione del problema delle galline e dei conigli, un classico problema del lavaggio auto e un problema della macchina per il lavaggio auto, principalmente per vedere se riesce a comprendere accuratamente le condizioni piuttosto che applicare una risposta dall'aspetto familiare. Tra questi, il problema delle galline e dei conigli includeva 4 uccelli meccanici con tre zampe per rompere gli schemi convenzionali.

(2) Limiti di Sicurezza: Successivamente, ho testato la sua reazione a operazioni ad alto rischio: se esegue direttamente o identifica i rischi, conferma con l'utente e fornisce alternative più sicure.

(3) Testo Lungo

Infine, un ciclo di test con testo lungo. Ho nascosto informazioni chiave in un contesto lungo per vedere se riusciva a trovarle e rispondere con precisione, osservando anche la velocità e la stabilità dell'output con testo lungo.

04 Dall'API alla TUI, poi al Tool Calling

Abbiamo completato il deployment del modello e i test delle capacità, ma per gli utenti comuni, curl è più adatto per verificare le interfacce che per l'uso quotidiano. Per parlare a lungo con un modello locale, è necessaria un'interfaccia di interazione più comoda.

Quindi ho prima creato una semplice TUI, un'interfaccia chat che gira nel terminale. Non è un software complesso; ho fatto scrivere a un'AI uno script Python per incapsulare le chiamate all'interfaccia locale, l'output in streaming e la cronologia delle conversazioni, poi l'ho avviato con un comando:

1python3 ling-3.0-chat.py

In questo modo, non devo scrivere curl ogni volta. Apro il terminale e chatto direttamente; le risposte arrivano in streaming e posso vedere TPS, TTFT e conteggi dei token. Ho completato i precedenti test delle capacità in questa interfaccia.

Tuttavia, a questo punto, la TUI è solo uno strumento di chat testuale senza la capacità di chiamare strumenti. Il modello grande è come un "cervello" responsabile del pensiero, ma non ha "mani e piedi" per leggere file, eseguire comandi o conoscere lo stato attuale del sistema.

Per permettergli di chiamare le capacità del sistema, dobbiamo aggiungere il tool calling. In parole povere, operazioni come l'esecuzione di comandi, la lettura e la scrittura di file sono incapsulate come strumenti. Il modello prima giudica di quali informazioni ha bisogno, poi avvia un tool use; lo script Python lo esegue e restituisce il risultato al modello per un'ulteriore elaborazione.

Ad esempio, inizialmente, quando gli ho chiesto di controllare le informazioni GPU di sistema, non conosceva l'uso reale e poteva solo dirmi come controllare. Dopo aver aggiunto il tool calling, poteva eseguire comandi di sistema da solo e organizzare i risultati della query direttamente nella TUI.

Sulla base dello stesso principio, puoi continuare a collegare la ricerca Web, le interfacce aziendali interne, i database, ecc. Gli strumenti specifici possono essere espansi in base alle esigenze aziendali.

05 Collegamento a un'Interfaccia Visiva

Per uso personale, una TUI con tool calling è in realtà più che sufficiente. Per andare oltre e inserire il modello in un ambiente di lavoro Agent più completo, puoi collegarlo a un framework agent come Harness.

Questa volta ho scelto DeepSeek Harness di Liang Sheng, che non solo aggiunge una pagina chat ma fornisce anche gestione del contesto, spazi di lavoro, tool calling, controllo dei permessi e pianificazione delle attività, con una Web UI integrata. Utilizza un'architettura "tutto è un plugin", consentendo future espansioni funzionali.

Nota che DeepSeek Harness è ancora in fase di anteprima per sviluppatori e si aggiorna rapidamente, il che potrebbe portare a modifiche incompatibili. Esistono molti altri framework Agent open-source; puoi scegliere in base alle tue esigenze.

Il processo di connessione non è complesso: il nucleo è aggiungere un servizio modello personalizzato e puntare l'indirizzo all'interfaccia locale fornita da vLLM. Oltre a configurare nella Web UI, puoi anche modificare il file di configurazione come mostrato:

1llm-pi-ai:
2  providers:
3    ling:
4      displayName: "Ling-3.0-flash (124B)"
5      api: openai-completions
6      baseURL: http://127.0.0.1:30000/v1
7      apiKeyEnv: OPENAI_API_KEY
8      models:
9        - id: ling-int4
10          name: Ling-3.0-flash (124B MoE)

Dopo aver avviato la Web UI, apri l'indirizzo predefinito nel tuo browser:

1http://localhost:3080

In questo modo, chat quotidiane, cronologia e cambio modello possono essere tutti gestiti in DeepSeek Harness. Harness stesso fornisce operazioni sui file, esecuzione di comandi e pianificazione delle attività, che possono essere ulteriormente estese tramite plugin. Per l'uso specifico e i plugin di terze parti, gli amici interessati possono cercarli.

Nota che gli strumenti che ho scritto nella TUI Python non migreranno automaticamente. Per usarli in Harness, devono essere reintegrati secondo il suo meccanismo di plugin. Di seguito è riportato l'effetto di integrazione reale che ho realizzato per Ling; puoi guardare la registrazione.

06 Costruire un Flusso di Lavoro AI

A questo punto, il collegamento del singolo modello dal deployment all'interfaccia e al tool calling per Ling-3.0-flash è completamente stabilito.

Tuttavia, nei progetti reali, di solito non usiamo un solo modello. Modelli diversi eccellono in cose diverse; combinarli è spesso meglio che far gestire tutto a un unico modello.

Il vantaggio di Ling-3.0-flash è la velocità di elaborazione e generazione del testo, ma non supporta l'input multimodale nativo. Se un'attività richiede la comprensione di immagini o video, puoi collegare un modello multimodale come Qwen3.8-27B; se hai bisogno di generare video, puoi collegare il recentemente open-sourced MiniMax H3. Ogni modello gestisce ciò in cui è migliore, passando i risultati al successivo.

Ad esempio, per costruire un flusso di lavoro di generazione video, Ling può prima comprendere i requisiti, scrivere script e dividere gli storyboard, poi il modello multimodale controlla i materiali di riferimento e la coerenza visiva, e infine, il modello video genera. Dopo la generazione, si può fare un altro ciclo di controllo visivo per modificare i prompt e rigenerare in base ai risultati:

1Requisiti e Materiali
2→ Ling genera script e storyboard
3→ Modello multimodale controlla materiali e requisiti visivi
4→ MiniMax H3 genera video
5→ Modello multimodale controlla visivi e continuità
6→ Ling regola i prompt in base al feedback
7→ L'umano completa la revisione finale

Il video qui sotto mostra l'effetto reale dei prompt generati da Ling-3.0-flash e poi passati a MiniMax H3 per la generazione.

Una volta fissato questo processo, devi solo cambiare requisiti e materiali per un uso ripetuto. Tuttavia, eseguire più modelli grandi localmente contemporaneamente ha requisiti molto elevati di VRAM e memoria. Ling INT4 è circa 72 GB, Qwen3.8-27B BF16 è circa 51,77 GB, più KV Cache e modelli video; è difficile mantenerli tutti residenti su questo Spark.

Prima del deployment effettivo, assicurati di calcolare quanta VRAM o memoria unificata necessita ogni modello. Quando le risorse sono insufficienti, puoi cambiare modello passo dopo passo, scegliere versioni quantizzate o suddividere i modelli su più dispositivi. Più modelli non funzionano più in modo indipendente ma collaborano attorno allo stesso compito—questo è un flusso di lavoro AI multimodello veramente utilizzabile.

07 Considerazioni Finali

Dal deployment del modello, alla TUI e al tool calling, fino ai flussi di lavoro multimodello, l'intero collegamento è completo. Questo articolo mira a condividere un metodo ripetibile piuttosto che una configurazione fissa.

I modelli open-source continueranno ad aggiornarsi. In futuro, che tu cambi modelli, versioni di quantizzazione o motori di inferenza, il percorso dal download dei pesi e l'avvio dei servizi al collegamento di strumenti e flussi di lavoro non cambierà molto.

Se le condizioni lo permettono, consiglio comunque a tutti di fare il deployment di modelli locali personalmente:

1. Controllo dei Dati: File, conversazioni e dati aziendali rimangono sulla tua macchina o intranet, con permessi di directory e comandi limitati da te.
2. Adatto per Uso ad Alta Frequenza: Nessun bisogno di calcolare il costo dei token per ogni utilizzo, riducendo la dipendenza dalla rete e da servizi di terze parti.
3. Facile Personalizzazione: Modelli, precisione di quantizzazione, motori di inferenza e strumenti possono essere tutti regolati, e interfacce interne e database possono essere collegati.

Man mano che i modelli open-source diventano più potenti, il deployment locale diventerà la scelta di più persone. Puoi costruire strumenti e flussi di lavoro in base alle tue esigenze di attività, condizioni dell'attrezzatura e budget. Spero che tutti possano avere il proprio Agent locale in futuro, senza dover guardare il consumo di token ogni volta, raggiungendo veramente la propria "Libertà dei Token"!

Risorse Correlate

• Hugging Face: Pesi INT4 di Ling-3.0-flash
• ModelScope: Pesi INT4 di Ling-3.0-flash
• Repository Ufficiale di Adattamento vLLM

📚 Riepilogo Articoli Precedenti

1. Guida Pratica ad Hermes Agent: Dall'Ansia da X all'Accumulo Automatico
2. Guida Anti-Caduta Capelli per Programmatore
3. Collegare Hermes a iMessage
4. Collegare Hermes a X Premium
5. Guida Completa ad Hermes Agent
6. Guida Introduttiva ad Hermes Agent: Modelli Ausiliari
7. Guida Introduttiva ad Hermes Agent
8. Guida Avanzata ad Hermes Agent
9. Guida Incompleta ad Hermes Agent
10. Guida Completa all'Abbonamento a Claude Pro in Nigeria
11. Tutorial per Registrare un Apple ID in Nigeria
12. Abbonamento a ChatGPT Plus a Metà Prezzo in Turchia
13. Registrazione Apple ID USA
14. Abbonamento a Claude/ChatGPT/Gemini con Alipay
15. Tutorial Completo per il Deployment di LLM Locale su Mac
16. Controllo Qualità IP
17. Perché Doubao Non Raccomanda il Tuo Marchio
18. Come Spiegare a Tua Nonna Che Quello Che Ha Detto Doubao Non è Vero

Se è stato utile, per favore segui + aggiungi ai preferiti + condividi 👏🏻

Segui @Lonely__MH per aggiornamenti continui su tutorial per principianti e approfondimenti sugli strumenti AI.