Cum rulam modelele locale de AI ?

de | august 30, 2026
Niciun comentariu

Acest articol îți arată cum să rulăm efectiv un model folosind trei instrumente: Ollama (calea cea mai ușoară), Docker ( pentru implementări curate și reproductibile) și LM Studio (un aplicație vizuală de desktop). Apoi explicăm diferențele între scalarea bazată pe GPU versus CPU, astfel încât să înțelegi ce se întâmplă în spatele scenei.

Opțiunea 1: Ollama (Punct de plecare recomandat)

Ollama este cea mai simplă modalitate de a rula modele locale. Se ocupă de descărcare, quantizare, gestionarea memoriei și expunerea unei API – toate acestea prin intermediul unui singur comandă. Dacă ești începător, începe de aici.

Instalare

Linux:

curl -fsSL https://ollama.com/install.sh | sh

macOS: descărcați programul de instalare de la https://ollama.com/download, sau:

Instalează ollama folosind brew

Windows: descărcați și executați programul de instalare de la https://ollama.com/download. După instalare, Ollama rulează ca un serviciu în fundal.

Verificați că este în funcțiune.

ollama --versiune

Ollama expune o interfață API locală pe portul 11434 în mod implicit. Confirmați că răspunde:

curl http://localhost:11434/api/tags

O listă goală ({„models”:[]}) este în regulă – înseamnă că Ollama este pornit, dar încă nu ai extras niciun model.

Trage și rulează primul tău model

Descărcați un model performant – alegeți-l în funcție de hardware-ul dvs.:

# Download a workhorse model - pick one to match your hardware:
ollama pull qwen3.6:27b          # Best quality, needs ~18-24 GB VRAM
ollama pull qwen3.6:35b-a3b      # Fast MoE (~3B active), runs on 16 GB
ollama pull qwen3.6:9b           # Lightweight, runs on 8 GB

# Conversați cu el interactiv pentru a confirma că funcționează
ollama run qwen3.6:27b "Summarize this firewall log line in one sentence: DROP TCP 10.0.0.5:44321 -> 185.220.101.7:443"

Dacă ai primit înapoi un rezumat coerent de o singură propoziție, felicitări – folosești un model local de IA. Scrie /bye pentru a ieși dintr-o sesiune interactivă.

Apelați-l din API (acesta este ceea ce va face n8n)

curl http://localhost:11434/api/generate -d '{
  "model": "qwen3.6:27b",
  "prompt": "Classify this alert as benign, suspicious, or malicious. Reply with one word only: Multiple failed SSH logins from a single IP followed by a success.",
  "stream": false,
  "options": {
    "temperature": 0.2,
    "num_ctx": 8192
  }
}'

Un model personalizat de dimensiuni mici cu un prompt de sistem integrat (Modelfile)

Ollama îți permite să creezi un preset numit de model folosind un Modelfile. Acesta este modul elegant de a fixa un prompt de sistem și setările implicite pentru o anumită sarcină de securitate.

# File: Modelfile
FROM qwen3.6:27b

# Default generation settings tuned for analytical security work
PARAMETER temperature 0.2
PARAMETER top_k 40
PARAMETER top_p 0.9
PARAMETER num_ctx 8192

# A system prompt that constrains behavior
SYSTEM """
You are a SOC triage assistant. Analyze security data factually.
Never speculate beyond the evidence provided. If information is missing,
say so explicitly. Always respond in the exact format requested.
"""

Construiește și rulează-l:

ollama create soc-triage -f Modelfile
ollama run soc-triage "Triage: 200 failed logins then 1 success from 185.220.101.7"

Acum aveți un model de triaj-soc reutilizabil care începe întotdeauna cu setările voastre.

Optiunea 2: Docker (Executii curate și reproductibile)

Docker împachetează totul în containere, astfel încât configurația ta este identică de fiecare dată și ușor de mutat între mașini. Acesta este abordarea preferată pentru implementările SOC și MSSP, deoarece este reproducibilă și ușor de gestionat împreună cu n8n.

Rulează Ollama în Docker

Doar CPU:

docker run -d \
  --name ollama \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  ollama/ollama

Cu accelerarea GPU NVIDIA (necesită instalarea NVIDIA Container Toolkit pe sistemul gazdă):

docker run -d \
  --name ollama \
  --gpus all \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  ollama/ollama

Trageți un model în containerul în funcțiune:

docker exec -it ollama ollama pull qwen3.6:27b

Orchestrează Ollama + n8n împreună, cu Docker Compose

Acest fișier singur aduce întregul tau stack local de automatizare AI – modelului AI in executie și motorul de automatizare n8n – conectate împreună pe o rețea privată. Salvează-l ca docker-compose.yml:

services:
  ollama:
    image: ollama/ollama
    container_name: ollama
    # Uncomment the next 3 lines if you have an NVIDIA GPU
    # deploy:
    #   resources:
    #     reservations:
    #       devices: [{ driver: nvidia, count: all, capabilities: [gpu] }]
    volumes:
      - ollama:/root/.ollama
    ports:
      - "11434:11434"
    restart: unless-stopped

  n8n:
    image: docker.n8n.io/n8nio/n8n
    container_name: n8n
    ports:
      - "5678:5678"
    environment:
      - N8N_SECURE_COOKIE=false
      # n8n reaches Ollama by its service name on the internal network:
      - OLLAMA_HOST=http://ollama:11434
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - ollama
    restart: unless-stopped

volumes:
  ollama:
  n8n_data:

Porneste-l:

docker compose up -d
docker compose exec ollama ollama pull qwen3.6:27b

Acum n8n se află la http://localhost:5678 și poate accesa modelul la http://ollama:11434 (notă: în interiorul rețelei Docker, numele de gazdă este numele serviciului ollama, nu localhost). Acest detaliu este foarte important – notează-l.

Opțiunea 3: LM Studio (Aplicație vizuală pentru desktop)

LM Studio este o aplicație grafică sofisticată pentru Windows, macOS și Linux. Este cel mai ușor mod de a naviga, descărca și a comunica cu modelele, iar aceasta include un server API local accesibil printr-un singur click, care imită formatul API-ului OpenAI.

Pași de configurare:

  1. Descărcați LM Studio de la https://lmstudio.ai și instalați-l.
  2. Deschideți aplicația și accesați butonul Căutare / Descoperire. Căutați un model (de exemplu, „Qwen3.6 27B” sau „Gemma 4 31B”).
  3. Alegeți o quantizare – pentru majoritatea oamenilor, un build GGUF de tipul Q4_K_M reprezintă echilibrul potrivit între calitate și dimensiune. LM Studio vă indică dacă se potrivește hardware-ului dvs.
  4. Faceți clic pe Descarcă, apoi încărcați modelul din secțiunea Chat și testați-l.
  5. Pentru a-l folosi în cadrul unei automatizari, accesați secțiunea Local Server și apăsați Start Server. Acesta expune un punct de terminare compatibil cu OpenAI, de obicei la adresa http://localhost:1234/v1.

Testați serverul dintr-un terminal:

curl http://localhost:1234/v1/chat/completions -H "Content-Type: application/json" -d '{
  "model": "local-model",
  "messages": [{"role": "user", "content": "Extract all IPv4 addresses: traffic from 10.0.0.5 to 185.220.101.7 via 8.8.8.8"}],
  "temperature": 0.2
}'

Când să folosiți LM Studio: experimentarea, compararea modelelor unul lângă altul, analiza interactivă rapidă și pentru consultanții care doresc o experiență fără terminal. Pentru automatizarea nefolosită în continuu, Ollama sau vLLM sunt de obicei opțiunile mai bune pe termen lung, dar serverul LM Studio funcționează și el bine.

GPU versus CPU: Cum funcționează de fapt scalarea

Acesta este partea care determină dacă modelul dumneavoastră pare ca se executa instantaneu sau foarte încet. Iată explicația.

În esență, rularea unui model de limbaj mare (LLM) constă într-o cantitate uriașă de calcule matematice (multiplicare matricială) repetate pentru fiecare token. Două aspecte sunt esențiale: cât de rapid poți efectua acele calcule și cât de rapid poți muta greutățile modelului acolo unde au loc calculele.

Inferență CPU:

  • Procesorul tău are câteva nuclee puternice cu scop general (4, 8, 16…).
  • Modelul se află în memoria RAM obișnuită a sistemului.
  • Procesoarele sunt flexibile, dar efectuează acest tip de calcule masiv paralele relativ încet.
  • Rezultat: Funcționează, în special pentru modele mici, dar așteptați răspunsuri mai lente – măsurate în secunde, uneori chiar multe secunde, pentru fiecare răspuns în cazul modelelor mai mari.

Inferență pe GPU:

  • O unitate de procesare grafică (GPU) are mii de nuclee mici concepute special pentru calculul matematic în paralel.
  • Modelul este stocat în memoria extrem de rapidă a GPU-ului (VRAM).
  • Acesta este un task pentru care au fost nascute unitățile grafice (GPU).
  • Rezultat: Semnificativ mai rapid – adesea de 10–50 de ori mai rapid decât CPU pentru același model – dacă întregul model încape în VRAM.

Conceptul critic este potrivirea in VRAM.

 MODEL incape intreg in VRAM        MODEL prea mare pentru VRAM
   --------------------------         ----------------------
   GPU does all the work.             Part lives in VRAM, part
   Fast and consistent.               spills to slow system RAM.
                                      The GPU constantly waits on
   [====== VRAM ======]              the slow part. Performance
   [###### MODEL #####]              collapses ("offloading tax").

                                      [== VRAM ==][== slow RAM ==]
                                      [## MODEL ###############]

De aceea, mărimea memoriei este esențială. Un model care încapă exact în VRAM rulează perfect. Același model, cu doar 10% mai mare, poate funcționa chiar mai prost decât pe CPU singur, pentru că sistemul petrece tot timpul mutând greutățile între memoria rapidă și cea lentă.

Reguli practice:

  • Alegeți un model și o quantizare care se potrivesc perfect VRAM-ului dvs., cu puțin spațiu în plus pentru dimensiunea contextului. Aceasta este decizia cea mai importantă pentru performanță.
  • Quantizarea este prietena ta. Un model de 4 biți (Q4) folosește mult mai puțină VRAM decât versiunea cu precizie completă, cu un impact redus asupra calității – adesea diferența dintre a încăpea și a nu încăpea.
  • Fără GPU? Folosește modele mici. Qwen3.6 9B, Gemma 4 E2B/E4B și Granite 4.1 3B sunt cu adevărat utilizabile pe CPU.
  • Există configurații mixte (transferul unor straturi către GPU, iar restul către CPU) și motoarele de execuție le susțin — însă considerați-le ca o soluție de rezervă, nu ca un obiectiv. A se încadra complet în VRAM este întotdeauna cea mai bună opțiune.

Citeste si alte articole: