Знакът на КАГАМИ КАГАМИ
kagami.bg/academy · lesson · machine-readable viewVERIFIED 2026-10-01 · UPDATED 2026-10-01
IDENTITY
module
01-00c · Lab: first local LLM, live
series
KAGAMI Academy · Blocks 0–10 · Block 0 — AI Fundamentals · part 3 of 3 (series colour: mint)
level
Beginner
duration
2–4 h hands-on
trust_label
VERIFIED 2026-10-01 (model sizes on ollama.com, published DGX Spark decode speeds, PyTorch/CUDA wheel index, BgGPT 3.0 GGUF, LangChain packages, all source links) · UPDATED 2026-10-01 (speed figures, 70B memory math, install commands, BgGPT 3.0, fictional demo document, EUR)
prerequisites
01-00a (tokenisation) · 01-00b (AI stack)
language
human view: bg · english edition: /en/academy/blokove/moduli/01-00c_Блок_0_Част_3_Лаборатория.html
next
01-01a · Block 1 part 1 · vLLM inference
PURPOSE

Install a local AI environment (GB10-class desktop such as DGX Spark / ASUS Ascent GX10, Ubuntu + NVIDIA GPU, or Apple Silicon), run a model with Ollama, measure decode speed honestly, build a mini RAG that answers "I don't know" outside its documents, call the model from Python three ways, and A/B-test BgGPT 3.0 on Bulgarian tasks.

KEY CONCEPTS
COMMANDS / PATHS
CHECKLIST
NEXT MODULE

01-01a · Block 1 part 1 · vLLM inference (local deployment and optimisation) · offer: Quick experiment (kagami.bg/stalbata/)

SOURCES
TAGS
local-llmollamabenchmarkraglangchainbggptdgx-sparkgb10python-api
ПРОВЕРЕНО · 01.10.2026 ОБНОВЕНО · 01.10.2026

Лаборатория: първи локален LLM на живо

Теорията свърши. Сега инсталираме средата, пускаме реален езиков модел, измерваме скоростта честно и решаваме първи бизнес сценарий — изцяло локално, без API ключ и без облак. Това е финалната част на Блок 0.

⏱ 2–4 ч практика Начинаещ Блок 0 · Част 3 от 3 Ollama · RAG · Python API
Ollama🔒 локално Python + LangChain + Chroma🔒 локално BgGPT 3.0🔒 локално Hugging Face (сваляне)🌐 глобален
🔄
ОБНОВЕНО · 01.10.2026 — какво
Скоростите са заменени с публикуваните измервания на Ollama за DGX Spark (70B дава ~4,4 ток/с, не ~140). Поправена е сметката за памет: 70B в пълна точност (~141 GB) не се побира в 128 GB — Ollama по подразбиране сваля Q4 (~43 GB). Инсталацията минава през виртуална среда (Ubuntu 24.04 не позволява системен pip), PyTorch — през колелата за CUDA 13. BgGPT 3.0 вече има официален GGUF — без ръчно конвертиране. Демо документът за RAG е измислен правилник (старият съдържаше неточни правни текстове). Сумите — в евро.

01Какво ще научиш

02Преди да започнеш

03Стъпки

  1. Инсталация на средата (~20 мин)

    Процедурата се различава малко по платформи. GB10 машините идват с DGX OS (Ubuntu с драйвери и CUDA от NVIDIA) — там само проверяваш и допълваш. Защо виртуална среда: от Ubuntu 24.04 системният Python е „външно управляван“ (PEP 668) и pip install извън venv дава грешка. Пакетите на урока живеят в собствена папка и не пречат на системата.

    bash · GB10 машина (DGX OS) — проверка и допълване
    # 1. Системен ъпдейт (препоръчан от NVIDIA и за фърмуера)
    sudo apt update && sudo apt dist-upgrade -y
    
    # 2. Вижда ли се чипът?
    nvidia-smi              # трябва да видиш NVIDIA GB10
    
    # 3. Ollama — провери; ако липсва, инсталирай
    ollama --version || curl -fsSL https://ollama.com/install.sh | sh
    
    # 4. Работна папка и виртуална среда за урока
    mkdir -p ~/ai-lab/{models,datasets,outputs} && cd ~/ai-lab
    python3 -m venv .venv && source .venv/bin/activate
    pip install --upgrade pip
    
    # 5. PyTorch с CUDA 13 (има колела и за ARM64/aarch64)
    pip install torch --index-url https://download.pytorch.org/whl/cu130
    python -c "import torch;print(torch.__version__, torch.cuda.is_available(), torch.cuda.get_device_name(0))"
    
    # 6. Пакетите на урока
    pip install ollama openai rich requests langchain langchain-community \
                langchain-ollama langchain-chroma langchain-text-splitters
    echo "✅ Готово"
    bash · Ubuntu 24.04 с NVIDIA карта — от нулата
    # 1. Драйвер (за колелата с CUDA 13 трябва драйвер от серия 580 или по-нов)
    sudo apt update && sudo apt install -y ubuntu-drivers-common python3-venv
    sudo ubuntu-drivers install && sudo reboot
    nvidia-smi              # след рестарта: виждаш картата и версията на драйвера
    
    # 2. Отделен CUDA Toolkit НЕ е нужен — PyTorch и Ollama носят своите библиотеки.
    #    Трябва ти само ако ще компилираш CUDA код (nvcc).
    
    # 3. Виртуална среда + PyTorch
    mkdir -p ~/ai-lab && cd ~/ai-lab
    python3 -m venv .venv && source .venv/bin/activate
    pip install torch --index-url https://download.pytorch.org/whl/cu130
    
    # 4. Ollama
    curl -fsSL https://ollama.com/install.sh | sh
    
    # 5. Пакетите на урока
    pip install ollama openai rich requests langchain langchain-community \
                langchain-ollama langchain-chroma langchain-text-splitters
    bash · macOS с Apple Silicon
    # Ollama: приложението от ollama.com или през Homebrew
    brew install ollama && ollama serve &
    
    mkdir -p ~/ai-lab && cd ~/ai-lab
    python3 -m venv .venv && source .venv/bin/activate
    pip install torch ollama openai rich requests langchain langchain-community \
                langchain-ollama langchain-chroma langchain-text-splitters
    
    # На Mac ускорението е MPS (Metal), не CUDA
    python -c "import torch;print('MPS:', torch.backends.mps.is_available())"
    ✅
    Правило: една среда на проект
    Всяка лаборатория — своя папка и своя .venv. Когато нещо се счупи, триеш средата, не системата.
  2. Ollama — първият модел (~15 мин)

    Ollama 🔒 локално работи като docker pull за езикови модели: команда, изчакваш свалянето, моделът е готов. Изборът зависи от паметта и от задачата. Размерите по-долу са на етикетите по подразбиране в библиотеката на Ollama (проверени на 01.10.2026).

    МоделРазмерЗа каквоGB10 (128 GB)Карта 24 GB
    llama3.2:3b2,0 GBбързи тестове, прототипи✅✅
    llama3.1:8b4,9 GBежедневна работа, RAG✅✅
    mistral:7b4,4 GBкод, структуриран изход✅✅
    llama3.1:70b (Q4)43 GBпо-високо качество, бавен✅❌ не се побира
    nomic-embed-text274 MBвграждания (embeddings) за RAG✅✅
    ⚠️
    Капан: „70B в пълна точност“
    70 милиарда параметъра × 2 байта (FP16/BF16) ≈ 141 GB — не се побират в 128 GB обща памет. Етикетът llama3.1:70b в Ollama е квантизиран до Q4 (~43 GB); Q8 е ~75 GB. Това е нормалният избор за настолна машина.
    bash · сваляне и първи разговор
    # Всяка машина: 8B е добрата отправна точка
    ollama pull llama3.1:8b
    ollama pull nomic-embed-text      # за RAG в стъпка 5
    
    # Само ако имаш ~50 GB свободна памет (напр. GB10): 70B за сравнение
    ollama pull llama3.1:70b
    
    ollama list
    ollama run llama3.1:8b "Обясни в 3 изречения какво е RAG система."
    ollama run llama3.1:8b            # интерактивен режим; изход с /bye
  3. Modelfile — асистент с характер

    Modelfile задава системен промпт, температура и дължина на контекста. Това е първата стъпка към специализиран асистент за конкретен сектор — без никакво обучение на модела.

    bash · български бизнес асистент
    cat > Modelfile <<'EOF'
    FROM llama3.1:8b
    PARAMETER temperature 0.2
    PARAMETER num_ctx 8192
    PARAMETER top_p 0.9
    SYSTEM """Ти си AI асистент за български бизнес.
    Отговаряш САМО на български език.
    Даваш конкретни, практични отговори.
    Когато не знаеш нещо — казваш го директно.
    Никога не измисляш факти или цифри.
    При правни и медицински въпроси препращаш към специалист."""
    EOF
    
    ollama create bg-assistant -f Modelfile
    ollama run bg-assistant "Каква е разликата между ЕООД и АД?"
  4. Измерване на производителността (~20 мин)

    Архитектът не само пуска модела — той го измерва. Скорост на писане (токени/с), време до първия токен и заета памет са числата, с които обосноваваш избор на хардуер и модел пред клиент. Защо точно така: Ollama връща отделно времето за четене на промпта и времето за писане; ако делиш токените на общото време, смесваш двете и числото лъже.

    Python · benchmark.py
    import requests
    from rich.console import Console
    from rich.table import Table
    
    console = Console()
    URL = "http://localhost:11434/api/generate"
    
    def bench(model, prompt):
        d = requests.post(URL, json={"model": model, "prompt": prompt,
                                     "stream": False}, timeout=600).json()
        ns = 1e9
        out_tok = d.get("eval_count", 0)
        decode_s = d.get("eval_duration", 0) / ns
        return {
            "tokens": out_tok,
            "tok_s": round(out_tok / decode_s, 1) if decode_s else 0,   # скорост на писане
            "first_s": round((d.get("load_duration", 0) + d.get("prompt_eval_duration", 0)) / ns, 2),
            "total_s": round(d.get("total_duration", 0) / ns, 2),
        }
    
    PROMPTS = [
        "Кажи 'здравей' на български.",
        "Обясни в 5 изречения какво е инфлация.",
        "Напиши кратък бизнес план за кафе на открито във Варна.",
        "Какви са разликите между GDPR и EU AI Act?",
    ]
    MODEL = "llama3.1:8b"   # после повтори с llama3.1:70b, ако го имаш
    
    bench(MODEL, "здравей")   # загрявка: зарежда модела в паметта
    t = Table(title=f"Benchmark — {MODEL}")
    for c in ("Промпт", "Токени", "ток/с", "1-ви токен (с)", "Общо (с)"):
        t.add_column(c)
    rows = [(p, bench(MODEL, p)) for p in PROMPTS]
    for p, r in rows:
        t.add_row(p[:38], str(r["tokens"]), str(r["tok_s"]), str(r["first_s"]), str(r["total_s"]))
    console.print(t)
    console.print(f"Средно: {sum(r['tok_s'] for _, r in rows)/len(rows):.1f} ток/с")

    Ориентир — какво да очакваш. Публикуваните измервания на Ollama за DGX Spark (същият чип GB10; октомври 2025, 500 токена изход):

    МоделКвантизацияПисане (ток/с)Отговор от 200 токена
    llama3.1 8BQ4_K_M~38~5 с
    gemma3 27BQ4_K_M~11~18 с
    llama3.1 70BQ4_K_M~4,4~45 с
    gpt-oss 20B (MoE)MXFP4~58~3,5 с
    gpt-oss 120B (MoE)MXFP4~41~5 с
    💡
    Защо 70B е бавен, а 120B MoE — бърз
    За всеки нов токен плътният модел прочита всичките си тегла от паметта. При ~273 GB/s пропускателност и ~43 GB тегла таванът е около 6 ток/с — точно затова 70B дава ~4,4. Моделите „смес от експерти“ (MoE) активират само малка част от теглата си на токен, затова 120B пише по-бързо от 70B. Изводът за клиента: за разговор в реално време на такава машина избирай 8B–27B или MoE; 70B е за нощни пакетни задачи.
    ✅
    Бизнес стойност: сметни, не гадай
    Локалният модел няма цена на заявка — плащаш хардуера и тока, а данните не напускат сградата (важно при GDPR). Облачният API таксува на милион токена. Вземи актуалната цена от страницата на доставчика 🌐 глобален и сметни: заявки на ден × токени на заявка × 365 × цена на токен. Сравни с цената на машината, разпределена за 3 години. Точката на изплащане е числото, което клиентът иска да види.
  5. Реален сценарий: RAG вместо дообучение

    Теорията от Част 1: езиковият модел халюцинира, когато въпросът е извън данните, на които е учен. Наредби и вътрешни правила се менят често — никой модел не знае версията от миналия месец. Без RAG — уверено грешни отговори. С RAG — точни отговори с цитат.

    ⛔
    Типичен капан (пример от практиката, анонимизиран)
    Счетоводна фирма вложи ~7 700 € (15 000 лв.) в дообучение на облачен модел, за да автоматизира справки по здравноосигурителни правила. Моделът връщаше уверено грешни суми: правилата се обновяват често и данните бяха остарели още при пускането. Правилният подход — RAG върху актуална база от официални документи + локален модел + автоматично опресняване — струва няколко пъти по-малко (порядък ~1 000 €). Заключение: дообучението за често променяща се информация почти винаги е грешният избор.

    Мини RAG за 15 минути. Документът по-долу е измислен вътрешен правилник на примерна фирма — нарочно, за да не учим модела (или теб) на неточни правни текстове. Сложи на негово място свой реален документ.

    Python · mini_rag.py
    from langchain_community.document_loaders import TextLoader
    from langchain_text_splitters import RecursiveCharacterTextSplitter
    from langchain_ollama import OllamaEmbeddings, ChatOllama
    from langchain_chroma import Chroma
    from langchain_core.prompts import ChatPromptTemplate
    from langchain_core.runnables import RunnablePassthrough
    from langchain_core.output_parsers import StrOutputParser
    
    # 1. Тестов документ — ИЗМИСЛЕН правилник на примерна фирма
    with open("pravilnik.txt", "w", encoding="utf-8") as f:
        f.write("""ВЪТРЕШЕН ПРАВИЛНИК НА „ПРИМЕР“ ЕООД (редакция 2026)
    Чл. 3. Работното време е от 9:00 до 17:30, с обедна почивка 30 минути.
    Чл. 7. Командировъчните се отчитат до 5 работни дни след връщане.
    Чл. 9. Служител има право на 2 дни работа от вкъщи седмично,
    след съгласуване с прекия ръководител.
    Чл. 12. Заявка за отпуск се подава поне 10 работни дни предварително.
    Чл. 15. Фирмените лаптопи се връщат до 3 дни след края на договора.""")
    
    # 2. Зареждане и нарязване
    docs = TextLoader("pravilnik.txt", encoding="utf-8").load()
    chunks = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50).split_documents(docs)
    print(f"✅ Парчета: {len(chunks)}")
    
    # 3. Вграждания и векторна база (в паметта)
    store = Chroma.from_documents(chunks, OllamaEmbeddings(model="nomic-embed-text"))
    retriever = store.as_retriever(search_kwargs={"k": 3})
    
    # 4. Модел и строг промпт
    llm = ChatOllama(model="llama3.1:8b", temperature=0.1)
    prompt = ChatPromptTemplate.from_template("""Отговори САМО въз основа на контекста.
    Ако отговорът не е в контекста — кажи "Не знам от документите."
    Цитирай члена.
    Контекст: {context}
    Въпрос: {question}""")
    
    chain = ({"context": retriever, "question": RunnablePassthrough()}
             | prompt | llm | StrOutputParser())
    
    for q in ["Колко дни работа от вкъщи са разрешени?",
              "Кога се подава заявка за отпуск?",
              "До кога се връща фирменият лаптоп?",
              "Каква е ставката на ДДС в България?"]:   # не е в документа!
        print(f"\n❓ {q}\n💬 {chain.invoke(q)}")
    Очакван изход (съкратено; формулировките варират)
    ❓ Колко дни работа от вкъщи са разрешени?
    💬 Съгласно чл. 9 — 2 дни седмично, след съгласуване с прекия ръководител.
    
    ❓ Каква е ставката на ДДС в България?
    💬 Не знам от документите.
    ✅
    Ключовото наблюдение
    Последният въпрос показва най-важното свойство на добрия RAG: да каже „не знам“, вместо да измисля. Без RAG моделът би отговорил уверено — понякога вярно, понякога не, и ти не знаеш кога. Клиентите се доверяват на системи, които знаят границите си.

    Пренеси го в своя сектор — сменя се само документът:

    СекторДокументиТипичен въпросДопълнителни мерки
    🏥 Здравеопазванепротоколи, вътрешни правила„Каква е процедурата за прием?“предпазни правила, одитен лог
    ⚖️ Праводоговори, закони„Открий рисковете в тази клауза“цитиране на членове
    💼 Счетоводствонаредби, ЗДДС, ЗКПО„Как се осчетоводява тази фактура?“опресняване при промяна
    🤝 Социални услугизакон, вътрешни процедури„Какви документи трябват за…“BgGPT 3.0 за българските термини
    🌱 ESG / зелен преходEU таксономия, климатични регламенти„Отговаря ли дейността на зелен критерий?“GraphRAG за връзките
  6. Python API — три начина (~30 мин)

    Командният ред е за проби. Истинските системи викат модела от код — през библиотеката ollama или през OpenAI-съвместимия интерфейс на Ollama 🔒 локално. Вторият е ценен: код, писан за облачен API, минава на локален модел със смяна на два реда.

    Python · api_three_ways.py
    import json, ollama
    from openai import OpenAI
    
    MODEL = "llama3.1:8b"
    
    # 1. Библиотеката ollama
    r = ollama.generate(model=MODEL, prompt="Обясни токенизацията в 2 изречения.",
                        options={"temperature": 0.2, "num_ctx": 4096})
    print(r["response"])
    
    # 2. Поточно (за чат интерфейс)
    for part in ollama.generate(model=MODEL, prompt="Кратка история за AI в 100 думи.", stream=True):
        print(part["response"], end="", flush=True)
    
    # 3. OpenAI-съвместим интерфейс — ключът е само запълване
    client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
    resp = client.chat.completions.create(model=MODEL, temperature=0.2, messages=[
        {"role": "system", "content": "Ти си AI асистент за човешки ресурси."},
        {"role": "user", "content": "Как се изчислява обезщетение при уволнение?"}])
    print(resp.choices[0].message.content)
    
    # Бонус: структуриран JSON от фактура — форматът е JSON схема
    schema = {"type": "object", "required": ["vendor", "amount", "currency", "date", "vat_included"],
              "properties": {"vendor": {"type": "string"}, "amount": {"type": "number"},
                             "currency": {"type": "string"}, "date": {"type": "string"},
                             "vat_included": {"type": "boolean"}}}
    r = ollama.generate(model=MODEL, format=schema, options={"temperature": 0},
        prompt="Извлечи данните. Фактура: Доставчик: Технологии ООД, Сума: 1 230 EUR с ДДС, Дата: 15.03.2026")
    try:
        print(json.loads(r["response"]))
    except json.JSONDecodeError:
        print("⚠️ Невалиден JSON — повтори заявката или я прати на човек")
    # {'vendor': 'Технологии ООД', 'amount': 1230, 'currency': 'EUR', 'date': '2026-03-15', 'vat_included': True}
    ⚠️
    JSON режимът не е гаранция
    format="json" или JSON схема рязко намаляват невалидния изход, но не до нула — а валиден JSON може да носи грешна стойност. В продукция: try/except, проверка по схема (напр. Pydantic), повторен опит и човешки преглед при пари и лични данни.
  7. Бонус: BgGPT 3.0 срещу Llama на български (~15 мин)

    BgGPT 3.0 на INSAIT е серия модели, адаптирани към български, върху Gemma 3 (4B, 12B и 27B). Има официални GGUF файлове — Ollama 🔒 локално ги сваля директно от Hugging Face 🌐 глобален, без ръчно конвертиране. Моделът после работи изцяло локално.

    bash · сваляне на BgGPT 3.0
    # 27B, Q4_K_M (~17 GB) — за GB10 или карта с 24 GB
    ollama pull hf.co/INSAIT-Institute/BgGPT-Gemma-3-27B-IT-GGUF:Q4_K_M
    # По-малка машина: BgGPT-Gemma-3-12B-IT-GGUF или BgGPT-Gemma-3-4B-IT-GGUF
    Python · bggpt_ab.py — A/B тест
    import ollama
    
    TASKS = {
        "Терминология": "Обясни разликата между 'социален работник' и 'социален педагог'.",
        "Фактура": "Какви реквизити трябва да има една фактура според ЗДДС?",
        "Официално писмо": "Напиши кратко официално писмо до общината за достъп до обществена информация.",
    }
    MODELS = {
        "BgGPT 3.0 27B": "hf.co/INSAIT-Institute/BgGPT-Gemma-3-27B-IT-GGUF:Q4_K_M",
        "Llama 3.1 8B": "llama3.1:8b",
    }
    for name, prompt in TASKS.items():
        print(f"\n{'='*60}\n📋 {name}: {prompt}")
        for label, mid in MODELS.items():
            try:
                r = ollama.generate(model=mid, prompt=prompt, options={"temperature": 0.1})
                print(f"\n[{label}]\n{r['response'][:400]}…")
            except Exception as e:
                print(f"\n[{label}] недостъпен: {e}")
    👤
    Кой отсъжда
    Сравнението не е с число, а с преглед от човек, който познава материята: граматика, термини, фактическа вярност. Фактите в отговорите (реквизити, срокове) провери в първоизточника — и двата модела могат да грешат.

04Проверка

Практическо предизвикателство — преди Блок 1:

1. RAG асистентът отговаря вярно на 8 от 10 въпроса, но за „Каква е цената на тока?“ уверено дава грешна цена. Най-вероятната причина?

2. Клиент иска 70B модел на машина със 128 GB обща памет. Кое е вярно?

3. Как се мери правилно скоростта на писане?

4. Гарантира ли JSON режимът на Ollama 100% валиден и верен резултат?

05Какво следва

С това Блок 0 е завършен: имаш локална среда, измерени числа, RAG, който знае границите си, и три начина да викаш модела от код.

06Източници

  1. Библиотека на Ollama — модели, етикети и размери.
  2. Ollama: производителност на NVIDIA DGX Spark — измерванията в стъпка 4.
  3. Ollama API · OpenAI съвместимост · структуриран изход · Modelfile.
  4. ollama-python — официалната Python библиотека.
  5. LangChain + Ollama · Chroma.
  6. BgGPT-Gemma-3-27B-IT-GGUF · обявяване на BgGPT 3.0 — INSAIT.
  7. Hugging Face: модели в Ollama — сваляне с hf.co/….
  8. PyTorch: локална инсталация · PEP 668 — защо виртуална среда.
  9. NVIDIA DGX Spark — документация · vLLM — за Блок 1.