Ollama, modele językowe uruchamiane lokalnie

Ollama, modele językowe uruchamiane lokalnie

Czy zdarzyło ci się chcieć porozmawiać z AI, ale nie mogłeś wysłać danych do chmury? Albo chciałeś poeksperymentować z różnymi modelami bez płacenia za tokeny? A może po prostu chciałeś mieć pełną kontrolę nad tym, co się dzieje z twoimi danymi?

Ollama rozwiązuje te problemy w najprostszy możliwy sposób. Jedna komenda i masz potężny model językowy działający lokalnie na twoim komputerze - bez chmury, bez subskrypcji, bez limitów tokenów.

Czym jest Ollama?

Ollama to darmowy, open-source framework do pobierania, uruchamiania i zarządzania dużymi modelami językowymi (LLM) na lokalnym komputerze. Działa jak Docker dla modeli AI - wpisujesz jedną komendę, a Ollama zajmuje się resztą: pobiera model, konfiguruje kwantyzację, zarządza pamięcią i uruchamia lokalny serwer API.

Pod maską Ollama opiera się na bibliotece llama.cpp, dostarczając warstwę abstrakcji, która ukrywa niskopoziomowe szczegóły i sprawia, że praca z lokalnymi modelami jest tak prosta jak ollama run llama3.2.

Projekt ma ponad 178 tysięcy gwiazdek na GitHubie i licencję MIT, a bieżące wydanie nosi numer 0.32.6 z 4 sierpnia 2026 roku. Wydania poprawkowe wychodzą tu mniej więcej co tydzień, więc trzecia liczba w numerze wersji zmienia się szybciej, niż zdąży się ją zapisać. Sam program napisano w języku Go.

Ile sprzętu to naprawdę wymaga

To jest pytanie, które decyduje o wszystkim, a odpowiedź „zależy od modelu" jest prawdziwa i bezużyteczna. Warto więc podać regułę, która pozwala oszacować to samodzielnie.

Model musi zmieścić się w pamięci, a jego rozmiar zależy od liczby parametrów i od precyzji zapisu. Przy domyślnej kwantyzacji czterobitowej przyjmij mniej więcej pół gigabajta na miliard parametrów. Model siedmiomiliardowy zajmie więc około czterech gigabajtów, trzynastomiliardowy około ośmiu, a siedemdziesięciomiliardowy około czterdziestu. Do tego trzeba doliczyć miejsce na kontekst, które rośnie wraz z długością rozmowy.

Drugie pytanie brzmi, gdzie ta pamięć się znajduje. Na karcie graficznej model działa szybko, w pamięci systemowej wolno, a rozłożony między jedno i drugie działa z prędkością tej wolniejszej części. To dlatego model, który ledwo mieści się w karcie, potrafi być kilkakrotnie szybszy niż ten o kilka gigabajtów większy.

Komputery Apple z układami własnej konstrukcji mają tu przewagę wynikającą z architektury, bo pamięć jest wspólna dla procesora i układu graficznego. Maszyna z trzydziestoma dwoma gigabajtami takiej pamięci uruchomi modele, które na typowym komputerze wymagałyby karty z drogiej półki.

Praktyczna rada przy pierwszym podejściu: zacznij od modelu w okolicach ośmiu miliardów parametrów. Zmieści się na większości sprzętu z ostatnich lat, odpowiada w tempie nadającym się do rozmowy i daje realne pojęcie o tym, czego się spodziewać. Sięganie od razu po największy dostępny model kończy się zwykle odpowiedzią przychodzącą po minucie i wnioskiem, że to się nie nadaje do niczego.

Kwantyzacja, czyli na czym polega kompromis

Kwantyzacja to zapisywanie wag modelu z mniejszą precyzją i jest tym, co w ogóle umożliwia uruchamianie dużych modeli poza serwerownią. Warto rozumieć, co się przy tym traci.

Model w pełnej precyzji zajmuje mniej więcej dwa gigabajty na miliard parametrów. Wersja czterobitowa mieści się w ćwierci tego, więc różnica jest czterokrotna i decyduje o tym, czy model w ogóle zmieści się w Twojej pamięci.

Cena to spadek jakości, który nie jest liniowy. Przejście z pełnej precyzji na osiem bitów jest praktycznie niezauważalne, przejście na cztery bity kosztuje niewiele przy większych modelach i wyraźnie więcej przy małych. Poniżej czterech bitów model zaczyna gubić spójność w dłuższych odpowiedziach i mylić fakty, które wcześniej podawał poprawnie.

Reguła, która się broni: przy wyborze między większym modelem mocniej skwantyzowanym a mniejszym w wyższej precyzji, zwykle wygrywa ten pierwszy. Model trzynastomiliardowy na czterech bitach daje lepsze wyniki niż siedmiomiliardowy na ośmiu, przy podobnym zużyciu pamięci.

Dlaczego Ollama?

Prywatność danych

To główny powód, dla którego ludzie sięgają po Ollama. Twoje dane nigdy nie opuszczają twojego komputera. Żadne promptu, żadne odpowiedzi, żadne pliki nie są wysyłane do żadnej chmury. Dla firm pracujących z wrażliwymi danymi, kodem źródłowym czy dokumentacją wewnętrzną - to game changer.

Zero kosztów operacyjnych

Po pobraniu modelu nie płacisz za tokeny, za API calls, za subskrypcje. Model działa na twoim sprzęcie, a jedyny koszt to energia elektryczna. Jeśli dużo korzystasz z AI w pracy, oszczędności mogą być znaczące.

Prostota

Ollama robi jedną rzecz i robi ją dobrze. Nie ma skomplikowanej konfiguracji, nie ma dashboardów, nie ma setup wizardów. Instalacja to jedna komenda, uruchomienie modelu to jedna komenda, integracja z aplikacjami to jedno ustawienie URL.

Praca offline

Raz pobrany model działa bez internetu. Idealnie sprawdza się w samolotach, w miejscach bez WiFi, czy w środowiskach z ograniczonym dostępem do sieci.

Porównanie z alternatywami

Instalacja

macOS

brew install ollama

Lub pobierz natywny instalator ze strony ollama.com.

Linux

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

Windows

Pobierz instalator ze strony ollama.com lub użyj WSL2:

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

Docker

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

Z obsługą GPU (NVIDIA):

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

Pierwsze kroki

Uruchamianie modelu

Po instalacji wystarczy jedna komenda:

ollama run llama3.2

Ollama automatycznie pobierze model (jeśli nie był jeszcze pobrany) i uruchomi interaktywną sesję czatu. Możesz od razu pisać i dostawać odpowiedzi.

Podstawowe komendy

ollama run llama3.2         # Uruchom model i rozpocznij czat
ollama pull gemma3           # Pobierz model bez uruchamiania
ollama list                  # Wyświetl zainstalowane modele
ollama ps                    # Pokaż aktualnie działające modele
ollama rm llama3.2           # Usuń model
ollama show llama3.2         # Pokaż szczegóły modelu
ollama serve                 # Uruchom serwer API (bez GUI)

Praca z modelem

W trybie interaktywnym możesz normalnie rozmawiać z modelem:

>>> Wyjaśnij mi czym jest TypeScript w 3 zdaniach

TypeScript to nadzbiór JavaScriptu, który dodaje statyczne typowanie do języka.
Pozwala wykrywać błędy na etapie kompilacji, zanim kod trafi do przeglądarki
lub środowiska Node.js. Jest rozwijany przez Microsoft i stał się standardem
w dużych projektach front-endowych i back-endowych.

Tryb multimodalny

Modele z obsługą wizji (np. Llama 3.2 Vision) pozwalają analizować obrazy:

ollama run llama3.2-vision
>>> What's in this image? /path/to/screenshot.png

Biblioteka modeli

Ollama udostępnia ponad 230 modeli w swojej bibliotece na ollama.com/library. Oto najważniejsze:

Modele ogólnego przeznaczenia

Modele do kodowania

Modele wizyjne

Modele embeddingowe

Jak wybrać model?

• 8 GB RAM: Llama 3.2 3B, Gemma 3 1B, Phi-3 3.8B
• 16 GB RAM: Llama 3.1 8B, Gemma 3 4B, Mistral 7B
• 32 GB RAM: Gemma 3 12B-27B, DeepSeek-R1 14B
• 64+ GB RAM: Llama 3.1 70B, DeepSeek-R1 32B+

Ogólna zasada: zacznij od mniejszego modelu (3B-8B) i zwiększaj rozmiar w zależności od potrzeb i dostępnego sprzętu.

Powyższe tabele to modele sprawdzone i szeroko opisane, a nie lista wszystkiego, co nowe. Biblioteka nadąża za premierami, więc znajdziesz w niej także kolejne generacje tych samych rodzin, między innymi llama4, gemma4 i qwen3. Przed wyborem zajrzyj na stronę biblioteki, bo nazwy i dostępne rozmiary zmieniają się co kilka miesięcy.

REST API

Ollama uruchamia lokalny serwer API na porcie 11434, kompatybilny z formatem OpenAI. To oznacza, że wiele istniejących narzędzi i bibliotek może się z nim integrować bez zmian w kodzie.

Generowanie odpowiedzi

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Wyjaśnij czym jest React",
  "stream": false
}'

Chat API

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "system", "content": "Jesteś pomocnym asystentem programisty."},
    {"role": "user", "content": "Jak stworzyć hook w React?"}
  ],
  "stream": false
}'

Generowanie embeddingów

curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "Ollama to framework do lokalnych LLM"
}'

OpenAI-compatible endpoint

Ollama oferuje endpoint kompatybilny z API OpenAI:

curl http://localhost:11434/v1/chat/completions -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "user", "content": "Hello!"}
  ]
}'

Dzięki temu wystarczy zmienić base_url w istniejącym kodzie:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Czym jest TypeScript?"}]
)
print(response.choices[0].message.content)

Tryb JSON

Wymuszenie odpowiedzi w formacie JSON:

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Podaj 3 frameworki JavaScript jako JSON array",
  "format": "json",
  "stream": false
}'

Biblioteki klienckie

Python

pip install ollama

import ollama

response = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Czym jest Rust?"}]
)
print(response["message"]["content"])

Streaming:

import ollama

stream = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Napisz wiersz o programowaniu"}],
    stream=True
)
for chunk in stream:
    print(chunk["message"]["content"], end="", flush=True)

JavaScript/TypeScript

npm install ollama

import { Ollama } from "ollama"

const ollama = new Ollama({ host: "http://localhost:11434" })

const response = await ollama.chat({
  model: "llama3.2",
  messages: [{ role: "user", content: "What is Next.js?" }],
})
console.log(response.message.content)

Modelfile - Tworzenie własnych modeli

Modelfile to plik konfiguracyjny (podobny do Dockerfile), który pozwala tworzyć niestandardowe warianty modeli. Możesz zmienić system prompt, parametry generowania, a nawet połączyć bazowy model z własnymi wagami.

Podstawowy Modelfile

FROM llama3.2

PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 4096

SYSTEM """
Jesteś doświadczonym programistą TypeScript i React.
Odpowiadasz zwięźle i podajesz praktyczne przykłady kodu.
Zawsze używasz najnowszych wzorców i best practices.
"""

Tworzenie i uruchamianie

ollama create typescript-helper -f Modelfile
ollama run typescript-helper

Zaawansowany Modelfile

FROM llama3.2

PARAMETER temperature 0.2
PARAMETER top_p 0.85
PARAMETER repeat_penalty 1.1
PARAMETER num_ctx 8192

TEMPLATE """
{{ if .System }}<|start_header_id|>system<|end_header_id|>
{{ .System }}<|eot_id|>{{ end }}{{ if .Prompt }}<|start_header_id|>user<|end_header_id|>
{{ .Prompt }}<|eot_id|>{{ end }}<|start_header_id|>assistant<|end_header_id|>
{{ .Response }}<|eot_id|>
"""

SYSTEM """
You are a code review assistant. Analyze code for bugs, security issues,
and performance problems. Always suggest specific improvements with code examples.
"""

Import modeli GGUF

Jeśli masz model w formacie GGUF (np. z Hugging Face), możesz go zaimportować:

FROM ./my-model-q4_K_M.gguf

PARAMETER temperature 0.8
SYSTEM "You are a helpful assistant."

ollama create my-custom-model -f Modelfile

Akceleracja GPU

Ollama automatycznie wykrywa i wykorzystuje dostępne GPU:

NVIDIA (CUDA)

Wymagania: compute capability 5.0+ oraz sterownik w wersji 550 lub nowszej. Karty o compute capability od 5.0 do 6.2 wymagają sterownika 570 lub nowszego.

ollama run llama3.2

Ollama automatycznie użyje CUDA jeśli jest dostępne. Dla wielu GPU:

CUDA_VISIBLE_DEVICES=0,1 ollama serve

Apple Silicon (Metal)

Na Macach z chipami M1/M2/M3/M4 Ollama automatycznie korzysta z Metal. Apple Silicon jest szczególnie dobrze obsługiwany - zunifikowana pamięć sprawia, że nawet większe modele działają płynnie.

AMD (ROCm)

Obsługiwane karty AMD z ROCm. Flash attention jest automatycznie włączany.

Wydajność GPU

Przybliżona prędkość generowania (tokeny/s) dla Llama 3.1 8B:

Docker i deployment produkcyjny

Podstawowy Docker Compose

services:
  ollama:
    image: ollama/ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

volumes:
  ollama-data:

Z Open WebUI

Popularna kombinacja - Ollama jako backend + Open WebUI jako interfejs graficzny:

services:
  ollama:
    image: ollama/ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    restart: unless-stopped

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - open-webui-data:/app/backend/data
    depends_on:
      - ollama
    restart: unless-stopped

volumes:
  ollama-data:
  open-webui-data:

Preload modeli w Docker

FROM ollama/ollama

RUN ollama serve & sleep 5 && ollama pull llama3.2 && ollama pull nomic-embed-text

Konfiguracja

Zmienne środowiskowe

Udostępnianie w sieci lokalnej

Domyślnie Ollama słucha tylko na localhost. Żeby udostępnić w sieci:

OLLAMA_HOST=0.0.0.0:11434 ollama serve

Zmiana katalogu modeli

Modele mogą zajmować dużo miejsca. Żeby przenieść je na inny dysk:

OLLAMA_MODELS=/mnt/ssd/ollama/models ollama serve

Integracje

Ekosystem Ollama obejmuje 50+ integracji:

Interfejsy graficzne

• Open WebUI - najbardziej popularny interfejs webowy, wygląda jak ChatGPT
• LibreChat - wieloproviderowy czat z obsługą wielu modeli
• Chatbox - desktopowa aplikacja wieloplatformowa
• Enchanted - natywna aplikacja macOS
• Lobe Chat - nowoczesny interfejs z pluginami

Frameworki AI

• LangChain - budowanie pipeline'ów RAG, agentów, łańcuchów
• LlamaIndex - indeksowanie dokumentów i wyszukiwanie semantyczne
• CrewAI - orkiestracja zespołów agentów AI
• AutoGen - multi-agentowe konwersacje, projekt przeszedł w tryb utrzymania i rozpadł się na następców

Narzędzia deweloperskie

• Continue - asystent kodowania w VS Code i JetBrains
• Aider - AI pair programming w terminalu
• Cody - Sourcegraph AI coding assistant
• GitHub Copilot (self-hosted backend) - przez OpenAI-compatible API

RAG i wyszukiwanie

• RAGFlow - silnik RAG czytający układ dokumentu: tabele, kolumny i skany
• AnythingLLM - all-in-one AI z RAG
• PrivateGPT - prywatne Q&A po dokumentach

Praktyczne zastosowania

Asystent kodowania

ollama create code-assistant -f - <<EOF
FROM codellama:13b
PARAMETER temperature 0.3
SYSTEM "You are a senior software engineer. Write clean, well-tested code. Always include error handling."
EOF

ollama run code-assistant
>>> Write a TypeScript function that fetches data with retry logic

Analiza kodu źródłowego

cat src/components/App.tsx | ollama run llama3.2 "Review this React component for potential issues"

Generowanie dokumentacji

cat src/utils/helpers.ts | ollama run llama3.2 "Generate JSDoc documentation for these functions"

Lokalne tłumaczenia

ollama run llama3.2 "Translate to Polish: The quick brown fox jumps over the lazy dog"

RAG z własnymi dokumentami

Połączenie Ollama z LlamaIndex do wyszukiwania po własnych dokumentach:

from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

llm = Ollama(model="llama3.2", request_timeout=120)
embed = OllamaEmbedding(model_name="nomic-embed-text")

documents = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(documents, embed_model=embed)
query_engine = index.as_query_engine(llm=llm)

response = query_engine.query("Jak skonfigurować autentykację?")
print(response)

Wymagania sprzętowe

Minimalne

• RAM: 8 GB (modele 1B-3B)
• Dysk: 5-10 GB na model
• CPU: Dowolny współczesny procesor x86_64 lub ARM64
• GPU: Opcjonalnie (znacząco przyspiesza)

Rekomendowane

• RAM: 16-32 GB (modele 7B-13B)
• Dysk: SSD z min. 50 GB wolnego miejsca
• GPU: NVIDIA RTX 3060+ (12GB VRAM) lub Apple Silicon M1+
• CPU: 8+ rdzeni

Dla dużych modeli (70B+)

• RAM: 64-128 GB
• GPU: NVIDIA RTX 4090 (24GB) lub 2x RTX 3090
• Dysk: NVMe SSD

Wskazówki i triki

Szybkie komendy pipe

echo "Explain Docker in one paragraph" | ollama run llama3.2

cat error.log | ollama run llama3.2 "What's causing these errors?"

git diff | ollama run llama3.2 "Summarize these code changes"

Utrzymywanie modelu w pamięci

OLLAMA_KEEP_ALIVE=-1 ollama serve

Wartość -1 trzyma model w pamięci nieskończenie, eliminując czas ładowania.

Równoległe żądania

OLLAMA_NUM_PARALLEL=4 ollama serve

Pozwala obsłużyć 4 żądania jednocześnie - przydatne gdy wielu użytkowników korzysta z jednego serwera.

Monitoring

ollama ps

Wyświetla aktualnie załadowane modele, zużycie pamięci i czas ostatniego użycia.

FAQ

Czy Ollama jest darmowe?

Tak, Ollama jest w pełni darmowe i open-source pod licencją MIT. Nie ma żadnych płatnych planów, limitów ani ukrytych kosztów.

Jakie GPU są obsługiwane?

NVIDIA z CUDA (compute capability 5.0+), Apple Silicon z Metal, AMD z ROCm, oraz Vulkan jako fallback.

Czy mogę uruchomić model bez GPU?

Tak, ale będzie znacznie wolniejsze. CPU inference działa, szczególnie dla mniejszych modeli (1B-7B).

Ile miejsca na dysku potrzebuję?

Zależy od modelu. Llama 3.2 3B to ~2 GB, Llama 3.1 8B to ~4,9 GB, Llama 3.1 70B to ~43 GB.

Czy mogę używać modeli z Hugging Face?

Tak, Ollama obsługuje import modeli w formacie GGUF przez Modelfile. Wiele modeli z Hugging Face jest też dostępnych bezpośrednio w bibliotece Ollama.

Jak udostępnić Ollama innym w sieci?

Ustaw OLLAMA_HOST=0.0.0.0:11434 i upewnij się, że port jest otwarty w firewallu.

Czy Ollama obsługuje function calling?

Tak, nowsze wersje Ollama wspierają tool calling, co pozwala modelom wywoływać zewnętrzne funkcje.

Czym różni się od ChatGPT/Claude?

ChatGPT i Claude to usługi w chmurze - twoje dane trafiają na serwery OpenAI/Anthropic. Ollama uruchamia modele lokalnie - dane nigdy nie opuszczają twojego komputera. Modele lokalne są zazwyczaj mniejsze i mniej zdolne niż najlepsze modele chmurowe, ale zapewniają pełną prywatność.

Czy mogę uruchomić wiele modeli jednocześnie?

Tak, i domyślnie nie trzeba nic ustawiać: serwer trzyma równolegle do trzech modeli na każdy układ graficzny, a przy pracy na procesorze także trzy. Zmienna OLLAMA_MAX_LOADED_MODELS służy do podniesienia albo obniżenia tej liczby. Każdy model zajmuje osobną pamięć RAM lub VRAM, a jeśli kolejny się nie mieści, żądania czekają w kolejce, aż wcześniejszy model zostanie wyładowany.

Warstwa chmurowa, czyli koniec czystej lokalności

Warto odnotować zmianę, której starsze materiały nie uwzględniają, a która komplikuje prosty obraz „Ollama to model na Twoim komputerze".

Projekt udostępnia dziś także uruchamianie modeli w chmurze, rozliczane według wykorzystania układów graficznych, a nie za tokeny. Sens jest praktyczny: te same polecenia i to samo API obsługują model lokalny i zdalny, więc możesz rozwijać na małym modelu u siebie, a do zadań wymagających większego sięgnąć po zasoby zewnętrzne, bez zmiany kodu.

Konkretnych stawek świadomie nie podaję, bo zestawienia krążące po sieci różnią się między sobą co do kwot poszczególnych planów. Aktualne wartości sprawdź bezpośrednio u dostawcy.

Warto natomiast zauważyć jedną rzecz, która ma znaczenie przy wyborze tego narzędzia. Jeśli powodem, dla którego sięgasz po lokalne modele, jest to, żeby dane nie opuszczały Twojej maszyny, to korzystanie z modelu chmurowego ten powód unieważnia. Nie jest to zarzut wobec projektu, bo obie opcje są jawne, ale przy wdrożeniu w organizacji warto ustalić wprost, którą z nich zespół ma prawo używać, zanim ktoś odruchowo wywoła model zdalny na danych, które nie powinny nigdzie wyjechać.

Kiedy lokalny model ma sens, a kiedy nie

Uczciwa odpowiedź jest bardziej wyważona niż entuzjastyczna narracja, która towarzyszy temu tematowi.

Ma sens tam, gdzie dane nie mogą opuścić maszyny albo organizacji. To jest argument, którego żadna usługa zewnętrzna nie przebije, i najczęstszy realny powód wyboru tej drogi.

Ma sens przy zadaniach powtarzalnych o dużym wolumenie i niskiej trudności: klasyfikacja, tagowanie, wyciąganie danych z tekstu, generowanie osadzeń. Tam różnica jakości między modelem lokalnym a najlepszym komercyjnym jest niewielka, a różnica w koszcie przy setkach tysięcy wywołań ogromna.

Ma sens przy nauce i prototypowaniu, bo brak licznika kosztów zmienia sposób pracy. Można próbować bez zastanawiania się, ile kosztowała nieudana próba.

Nie ma sensu tam, gdzie liczy się jakość rozumowania przy trudnych zadaniach. Modele, które zmieścisz na typowym sprzęcie, są o klasę słabsze od najlepszych modeli komercyjnych, takich jak Claude, i przy pisaniu kodu, analizie długich dokumentów czy zadaniach wieloetapowych ta różnica jest odczuwalna, a nie kosmetyczna.

Nie ma też sensu jako sposób na oszczędzanie w małej skali. Prąd, sprzęt i czas poświęcony na konfigurację przy kilkuset wywołaniach miesięcznie kosztują więcej niż rachunek za API. Oszczędność zaczyna się przy wolumenie, przy którym rachunek za usługę zewnętrzną robi się widoczny w budżecie.

Wpięcie w istniejący kod

Największą praktyczną zaletą jest tu API zgodne z interfejsem znanym z usług komercyjnych. Oznacza to, że biblioteka kliencka napisana pod inną usługę zadziała po zmianie adresu bazowego i klucza, bez przepisywania logiki.

Ten sam mechanizm sprawia, że narzędzia orkiestrujące, w tym LangChain i LlamaIndex, traktują model lokalny jak każdego innego dostawcę. Przy budowaniu wyszukiwania wspomaganego generowaniem możesz więc trzymać całość u siebie: model do osadzeń, bazę wektorową i model generujący odpowiedź.

Warto pamiętać o dwóch różnicach wobec usług komercyjnych, które ujawniają się dopiero w kodzie. Pierwsza to brak kolejkowania: serwer obsługuje ograniczoną liczbę równoległych żądań i przy większym obciążeniu zaczyna je ustawiać w kolejce, co objawia się rosnącym czasem odpowiedzi zamiast błędem. Przy jednym użytkowniku to drobiazg, przy kilkunastu robi się ścianą i wtedy właściwym narzędziem jest vLLM, który grupuje żądania w locie i utrzymuje przepustowość zamiast wydłużać kolejkę, kosztem trudniejszej konfiguracji i wymogu karty obsługującej cały model. Druga to pierwsze wywołanie po dłuższej przerwie, przy którym model ładuje się do pamięci i odpowiedź przychodzi z wyraźnym opóźnieniem.

Kod źródłowy i wydania znajdziesz w repozytorium Ollama, a katalog modeli na stronie projektu.