הרצת LLM מקומית
פרטיות מלאה, בלי ענן, על החומרה שכבר יש לך

מתי מקומי הוא באמת התשובה

הרצה מקומית עולה בביצועים ובאיכות לעומת מודלי החזית. היא משתלמת כשיש סיבה מהותית, לא בגלל העיקרון:

• הנתונים אינם רשאים לצאת — רגולציה, סודיות רפואית או משפטית, קוד לקוח.
• נפח גדול וחוזר — סיווג מיליוני רשומות, שבו עלות ה-API מצטברת מהר.
• אין רשת — סביבה מבודדת פיזית.
• עצמאות — הספק לא ישנה את המודל מתחתיך ולא יעלה מחיר.

ולעומת זאת: למשימות שדורשות היגיון מורכב, הפער מול מודלי החזית עדיין משמעותי. שקול ארכיטקטורה מעורבת — מקומי למה שרגיש, ענן לשאר.

מה החומרה שלך מאפשרת

האילוץ הבולם הוא כמעט תמיד זיכרון, לא מהירות. חישוב הגודל פשוט:

זיכרון נדרש ≈ (מספר פרמטרים × ביטים לפרמטר / 8) × 1.2

Llama 3.1 8B  ב-Q4  →  8 × 0.5 × 1.2  ≈ 5 GB
Llama 3.1 70B ב-Q4  →  70 × 0.5 × 1.2 ≈ 42 GB
Mistral 7B    ב-Q8  →  7 × 1.0 × 1.2  ≈ 8.4 GB

התוספת של 1.2 היא ה-KV cache — והיא גדלה עם אורך ההקשר.

מק עם 16GB  → מודלי 8B בנוחות
מק עם 32GB  → 8B–14B, או 34B בקוונטיזציה נמוכה
מק עם 64GB+ → 70B ריאלי

RTX 3060 12GB → 8B ב-Q4
RTX 4090 24GB → 14B בנוחות, 34B דחוק
CPU בלבד     → עובד, אך איטי מאוד. שמור לעיבוד אצווה ברקע.

קוונטיזציה — מה באמת קורה

קוונטיזציה מקטינה את הדיוק של כל משקל: מ-16 ביט ל-4, למשל. המודל מתכווץ פי ארבעה ומאבד מעט איכות. הפורמטים הנפוצים:

Q8_0    ~50% מהגודל   איכות כמעט זהה למקור
Q6_K    ~40%          הפרש כמעט בלתי מורגש
Q4_K_M  ~28%          נקודת האיזון המומלצת — ברירת מחדל טובה
Q3_K_M  ~22%          ירידה מורגשת; רק כשאין מספיק זיכרון
Q2_K    ~16%          לרוב לא שווה את זה

כלל אצבע מעשי: מודל גדול יותר בקוונטיזציה נמוכה עדיף על מודל קטן בדיוק מלא. 13B ב-Q4 כמעט תמיד יעלה על 7B ב-Q8 באותה תפוסת זיכרון. לרקע על אימון והתאמה ראה מדריך LoRA.

Ollama — הדרך המהירה להתחיל

# התקנה
curl -fsSL https://ollama.com/install.sh | sh        # Linux
brew install ollama                                  # macOS

ollama pull llama3.1:8b
ollama run llama3.1:8b "הסבר מהי קוונטיזציה בשתי שורות"

ollama ps      # מה טעון בזיכרון כרגע
ollama list    # מה יש מקומית

Ollama חושף API תואם OpenAI, כך שרוב הקוד הקיים עובר בשינוי שורה אחת:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",                     # לא נבדק, אבל נדרש על ידי ה-SDK
)

resp = client.chat.completions.create(
    model="llama3.1:8b",
    messages=[{"role": "user", "content": "סכם את הטקסט הבא בשלוש נקודות..."}],
    temperature=0.2,
)
print(resp.choices[0].message.content)

התאמת המודל עם Modelfile

# Modelfile
FROM llama3.1:8b

PARAMETER temperature 0.2
PARAMETER num_ctx 8192          # הקשר גדול = יותר זיכרון

SYSTEM """אתה עוזר לניתוח מסמכים משפטיים בעברית.
ענה רק על סמך המסמך שסופק. אם התשובה אינה במסמך — אמור זאת במפורש."""

ollama create legal-he -f Modelfile
ollama run legal-he

llama.cpp — כשצריך שליטה

Ollama בנוי מעל llama.cpp. כשצריך לכוון ביצועים מדויק, עבוד ישירות מולו:

git clone https://github.com/ggerganov/llama.cpp && cd llama.cpp

# macOS — Metal מופעל כברירת מחדל
cmake -B build && cmake --build build --config Release

# Linux עם NVIDIA
cmake -B build -DGGML_CUDA=ON && cmake --build build --config Release

# שרת תואם OpenAI
./build/bin/llama-server \
  -m models/llama-3.1-8b-instruct-Q4_K_M.gguf \
  -c 8192 \          # גודל הקשר
  -ngl 99 \          # כמה שכבות ל-GPU; 99 = הכול
  --host 0.0.0.0 --port 8080

-ngl הוא הפרמטר שמשנה הכול. אם המודל לא נכנס כולו ל-GPU, הורד את המספר עד שהטעינה מצליחה — כל שכבה שנשארת ב-CPU מאטה משמעותית.

סביבה מבודדת עם Docker

הפרדה בקונטיינר נותנת שני דברים: שחזוריות, ויכולת להוכיח שאין יציאה לרשת — מה שנדרש בדרך כלל בביקורת.

# docker-compose.yml
services:
  ollama:
    image: ollama/ollama:latest
    volumes:
      - ./models:/root/.ollama
    networks: [internal]
    deploy:
      resources:
        reservations:
          devices:
            - { driver: nvidia, count: all, capabilities: [gpu] }

  app:
    build: .
    environment:
      OLLAMA_HOST: http://ollama:11434
    networks: [internal]
    depends_on: [ollama]

networks:
  internal:
    internal: true        # אין ניתוב החוצה. זו כל הנקודה.

# משיכה מראש, לפני הבידוד
docker compose run --rm ollama ollama pull llama3.1:8b
docker compose up -d

# אימות שאין יציאה
docker compose exec app curl -m 5 https://example.com || echo "מבודד ✓"

Apple Silicon — MLX לביצועים מיטביים

MLX היא ספריית אפל, מותאמת לזיכרון המאוחד. בדרך כלל מהירה יותר מ-llama.cpp על אותה חומרה:

pip install mlx-lm

# הרצה ישירה
mlx_lm.generate --model mlx-community/Meta-Llama-3.1-8B-Instruct-4bit \
                --prompt "הסבר מהו RAG" --max-tokens 512

# שרת תואם OpenAI
mlx_lm.server --model mlx-community/Meta-Llama-3.1-8B-Instruct-4bit --port 8080

from mlx_lm import load, generate

model, tokenizer = load("mlx-community/Meta-Llama-3.1-8B-Instruct-4bit")
prompt = tokenizer.apply_chat_template(
    [{"role": "user", "content": "סכם את המסמך המצורף"}],
    add_generation_prompt=True, tokenize=False)
print(generate(model, tokenizer, prompt=prompt, max_tokens=512))

RAG מקומי לחלוטין

אם הנתונים לא יוצאים, גם ה-embeddings חייבים להיווצר מקומית. השילוב הזה נותן צינור סגור מקצה לקצה:

from langchain_ollama import OllamaEmbeddings, ChatOllama
from langchain_chroma import Chroma
from langchain.chains import RetrievalQA

# הטמעות מקומיות — שום טקסט לא עוזב את המכונה
embeddings = OllamaEmbeddings(model="nomic-embed-text")
store = Chroma(persist_directory="./vectors", embedding_function=embeddings)

qa = RetrievalQA.from_chain_type(
    llm=ChatOllama(model="llama3.1:8b", temperature=0),
    retriever=store.as_retriever(search_kwargs={"k": 4}),
)
print(qa.invoke({"query": "מה תקופת ההתיישנות לפי המסמך?"}))

למבנה ה-RAG עצמו ולשיפור האיכות ראה מדריך RAG וRAG מתקדם.

בעיות נפוצות

• איטי מאוד — כנראה חלק מהמודל ב-CPU. בדוק עם ollama ps את פיצול GPU/CPU, והקטן קוונטיזציה או הקשר.
• קורס בטעינה — אין מספיק זיכרון. הקטן num_ctx לפני שאתה מקטין את המודל; ההקשר צורך יותר ממה שנדמה.
• תשובות באיכות ירודה — בדוק שאתה על מודל instruct ולא base, ושתבנית הצ'אט נכונה. מודל base לא מיועד לשיחה.
• עברית חלשה — רוב מודלי הקוד הפתוח אומנו בעיקר על אנגלית. בדוק מודלים רב-לשוניים, או שקול לתת הוראות באנגלית ולבקש פלט בעברית.

סיכום מעשי

• זיכרון הוא האילוץ. חשב לפני שאתה מוריד.
• Q4_K_M היא ברירת מחדל טובה; מודל גדול יותר בקוונטיזציה נמוכה עדיף על קטן בדיוק מלא.
• Ollama להתחלה, llama.cpp לשליטה, MLX על מק.
• internal: true הופך הבטחת פרטיות להוכחה.
• שקול ארכיטקטורה מעורבת — מקומי לרגיש, ענן לשאר.