'Po prostu odpal to lokalnie" to technologiczny odpowiednik 'po prostu hoduj sobie jedzenie". Czasem faktycznie zaoszczędzisz majątek. Częściej kosztuje więcej, wymaga więcej roboty i daje gorsze wyniki. Ale ciągle to słyszysz — na Twitterze, na Reddicie, od tego jednego znajomego, który postawił serwer w domu. Więc pomińmy gorące opinyjki i spojrzyjmy na konkretne liczby. 🔍

Prawdziwe pytanie nie brzmi czy powinienem hostować lokalnie. Brzmi przy jakim wolumenie self-hosting staje się tańszy — i czy te kompromisy w ogóle mają znaczenie dla tego, co budujesz?

Co porównujemy

Cloud AI oznacza płacenie za użycie. Za każdym razem, gdy twoja apka wysyła tekst do Claude, GPT lub Gemini, płacisz za tokeny — kawałki słów przetwarzane przez AI, mniej więcej ¾ angielskiego słowa. Pomyśl o tym jak o taksometrze: krótkie kursy są tanie, długie się sumują.

Self-hosted AI oznacza uruchomienie open-source'owego LLM-a (large language model — mózg stojący za narzędziami typu ChatGPT) na własnym sprzęcie. Płacisz za maszynę i prąd, ale każde kolejne zapytanie jest darmowe. Pomyśl o tym jak o kupnie samochodu: drogie na starcie, ale zero opłat za przejazd.

Aktualne ceny chmurowe (stan na marzec 2026), za milion tokenów:

Dostawca Model Koszt input / output
Anthropic Haiku 4.5 $1 / $5
Anthropic Sonnet 4.6 $3 / $15
Anthropic Opus 4.6 $5 / $25
OpenAI GPT-4o mini $0.15 / $0.60
OpenAI GPT-4o $2.50 / $10
Google Gemini Flash Darmowy tier (15 req/min)
Google Gemini Pro $1.25 / $5

A po stronie self-hosted: Ollama z open-source'owymi modelami typu Llama 3.1, Mistral czy DeepSeek na własnej maszynie lub wynajętym serwerze z GPU.

Fundamentalny tradeoff: chmura liczy za użycie, self-hosted za czas. Przy niskim ruchu chmura wygrywa, bo płacisz tylko za to, co zużyjesz. Przy dużym ruchu wygrywa self-hosted, bo koszt sprzętu jest stały. Musimy znaleźć punkt przełamania. 💰

Matematyka kosztów, której nikt ci nie pokazuje

Koszty chmury przy skali

Biorąc Claude Haiku 4.5 jako baseline (najtańszy jakościowy model w chmurze), zakładając typowy split 30% input / 70% output:

Tokeny dziennie Koszt miesięczny Koszt roczny
10K $0.90 $10.80
100K $9 $108
500K $45 $540
1M $90 $1,080
5M $450 $5,400
10M $900 $10,800

Koszty self-hosted

Opcja A — sprzęt, który już masz:

Jeśli masz maszynę z GPU (karta graficzna przyspieszająca obliczenia AI), jedyny dodatkowy koszt to prąd:

Sprzęt Jakie modele udźwignie Prąd miesięcznie
16 GB RAM, bez GPU modele 7B (wolno) ~$10
RTX 3090 24GB modele 13B (szybko) ~$20
RTX 4090 24GB modele 13B-30B (szybko) ~$25
M2/M3 Mac 32GB+ 7B-13B (dobra prędkość) ~$5

'7B" i '13B" to miliardy parametrów — rozmiar modelu. Większe modele są mądrzejsze, ale potrzebują więcej pamięci.

Opcja B — wynajem serwera z GPU:

Dostawca GPU Koszt miesięczny
Hetzner (tylko CPU) Brak ~$50
Vast.ai RTX 3090 ~$150
Vast.ai RTX 4090 ~$250
Lambda A10G ~$350
RunPod A100 40GB ~$800

Opcja C — kupno domowego serwera:

Zestaw Koszt początkowy Miesięcznie (na 3 lata)
Używany RTX 3090 + basic PC ~$1,200 ~$33 + prąd
RTX 4090 + porządny PC ~$2,500 ~$70 + prąd
2× RTX 4090 ~$4,500 ~$125 + prąd
Mac Studio M3 Ultra 192GB ~$6,000 ~$167 + prąd

Gdzie linie się przecinają

Cloud Haiku vs. lokalny 7B na istniejącym sprzęcie:

Koszt self-hosted to ~$15/mies. na prąd. Cloud Haiku przekracza tę kwotę przy mniej więcej 5 milionach tokenów miesięcznie. Poniżej tego — a większość solo founderów siedzi znacznie poniżej — chmura jest tańsza.

Cloud Haiku vs. wynajęty GPU (RTX 3090 za $150/mies.):

Musisz generować 50 milionów tokenów miesięcznie, żeby wynajęty serwer się zwrócił. To 1,7 miliona tokenów dziennie — poważny produkcyjny workload.

Dla większości indie builderów i małych zespołów API w chmurze kosztuje mniej niż self-hosting na dedykowanym sprzęcie. Kropka.

Różnica w jakości

Koszt to tylko połowa historii. Oto jak modele wypadają w praktyce:

Zdolność Chmura (Claude/GPT) Self-hosted (7B-13B)
Jakość rozumowania Doskonała Średnia
Generowanie kodu Doskonałe Dobre przy prostych zadaniach
Okno kontekstowe 200K-1M tokenów Zwykle 4K-32K
Szybkość 50-100+ tok/sek 20-40 (GPU), 5-10 (CPU)
Używanie narzędzi Natywne, niezawodne Możliwe, mniej niezawodne

Okno kontekstowe — ile tekstu AI 'widzi" naraz, coś jak jego pamięć robocza — to największa przepaść. Modele chmurowe ogarniają całe bazy kodu. Lokalne modele widzą kilka stron na raz.

Llama 3.1 70B robi naprawdę solidne wrażenie i jest konkurencyjny w ogólnych zadaniach. Ale potrzebuje poważnego GPU, a nadal nie ma lokalnego odpowiednika Opusa czy topowego GPT do złożonego rozumowania. Dystans się zmniejszył. Nie zniknął.

Kiedy self-hosting faktycznie ma sens

1. Prywatność i suwerenność danych

Jeśli twoje dane nie mogą opuścić sieci — dokumentacja medyczna, prawna, dane finansowe, systemy rządowe — self-hosting to nie opcja, to konieczność. Żadne warunki użytkowania API nie zastąpią 'dane nigdy nie opuściły naszego budynku".

# Ollama robi z tego setup na 2 minuty
curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.1:8b

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Podsumuj tę dokumentację pacjenta..."
}'

Żadnego requestu w sieć. Żadnego logowania przez stronę trzecią. Pełna zgodność.

2. Środowiska offline

Urządzenia brzegowe, sieci air-gapped, lokalizacje zdalne bez internetu. Brak połączenia oznacza brak API — lokalne to jedyna opcja.

3. Proste zadania przy dużym wolumenie

Embeddingi — numeryczne odciski palców tekstu używane do wyszukiwania — klasyfikacja i krótkie podsumowania. Zadania, w których mały model wystarczy, a wolumen jest ogromny: ⚡

import ollama

def classify_document(text: str) -> str:
    response = ollama.chat(model='llama3.1:8b', messages=[
        {'role': 'user', 'content': f'Sklasyfikuj: faktura, umowa, paragon, list, inne.\n\n{text[:500]}'}
    ])
    return response['message']['content']

# 100K dokumentów dziennie:
# Koszt chmury: ~$30/dzień
# Self-hosted: ~$0.50/dzień na prąd
# Miesięczna oszczędność: ~$900

4. Aplikacje wrażliwe na opóźnienia

Wywołania API dodają 100-500ms opóźnienia sieciowego. Lokalna inferencja — proces generowania odpowiedzi przez model — startuje natychmiast:

Chmura:  150-500ms sieć + 500-2000ms inferencja = 650-2500ms
Lokalnie: 0ms sieć + 200-1000ms inferencja = 200-1000ms

Przy autouzupełnianiu, tłumaczeniu na żywo czy interaktywnych narzędziach ta różnica jest odczuwalna.

5. Rozwój i eksperymentowanie

Testowanie 50 wariantów prompta lokalnie kosztuje $0. Ten sam eksperyment na API Claude to $5-20. Nie jest to ogromna kwota, ale kumuluje się przy intensywnym R&D.

Praktyczny setup (10 minut)

Jeśli zdecydowałeś, że self-hosting pasuje do twojego przypadku:

Instalacja Ollama

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

ollama pull llama3.1:8b          # 4.7 GB, ogólnego przeznaczenia
ollama pull codellama:13b         # 7.4 GB, zadania kodowe
ollama pull nomic-embed-text      # 274 MB, do embeddingów

Użyj jako drop-in replacement

Ollama mówi tym samym językiem co API OpenAI. Większość kodu działa bez zmian — wystarczy podmienić URL:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="not-needed"
)

response = client.chat.completions.create(
    model="llama3.1:8b",
    messages=[{"role": "user", "content": "Wyjaśnij MCP w 3 zdaniach"}]
)
print(response.choices[0].message.content)

Devuj na lokalnych modelach, deployuj z chmurą — albo odwrotnie. Ten sam kod, inny URL.

Benchmarki wydajności

Sprzęt Tokeny/sek Odpowiedź 500 tokenów
M2 MacBook Pro 16GB ~35 ~14 sekund
RTX 3060 12GB ~40 ~12 sekund
RTX 4090 24GB ~80 ~6 sekund
Tylko CPU (16 rdzeni) ~8 ~60 sekund

Inferencja na samym CPU jest bolesna przy czymkolwiek interaktywnym. Nie masz GPU ani Apple Silicon? Zostań przy chmurze.

Podejście hybrydowe (to jest ten ruch) 🚀

Najmądrzejszy setup to nie czysta chmura ani czysty self-hosted. To routowanie każdego zadania w odpowiednie miejsce:

def get_ai_client(task_type: str):
    if task_type in ["embedding", "classification", "simple_summary"]:
        # Lokalnie — szybko, za darmo, jakość wystarczy
        return OpenAI(base_url="http://localhost:11434/v1", api_key="x")
    elif task_type in ["code_generation", "complex_analysis", "tool_use"]:
        # Chmura — lepsza jakość, warta swojej ceny
        return anthropic.Anthropic()
    else:
        return OpenAI(base_url="http://localhost:11434/v1", api_key="x")

Leci lokalnie: embeddingi, klasyfikacja, generowanie draftu, dev/testowanie. Leci w chmurze: złożone rozumowanie, generowanie kodu, użycie narzędzi, wszystko customer-facing.

Realny przykład kosztów dla setupu hybrydowego:

Zadanie Wolumen Gdzie Koszt miesięczny
Embeddingi 50K/dzień Lokalnie $0
Klasyfikacja 10K/dzień Lokalnie $0
Code review 30/dzień Chmura (Haiku) $2
Generowanie treści 50/dzień Chmura (Sonnet) $15
Złożona analiza 10/dzień Chmura (Sonnet) $5
Razem $22/mies.

Czysta chmura dla tego samego workloadu: ~$180/mies. Hybryda oszczędza 88%.

Ściągawka decyzyjna

Przetwarzasz ponad 5M tokenów dziennie? → Self-hostuj zadania wolumenowe, chmura dla jakościowych.

Ścisłe wymagania prywatności danych? → Self-host, bez dyskusji.

Masz już sprzęt z GPU? → Hybryda: lokalnie proste rzeczy, chmura dla złożonych.

Nic z powyższych? → Sama chmura. Najtaniej i najlepsze modele.

Dla większości solo founderów w marcu 2026: zacznij od chmury. Claude Haiku za $1/$5 za milion tokenów jest tak tani, że self-hosting dla oszczędności to jak hodowla pszenicy, żeby zaoszczędzić na chlebie. Sprzęt kosztuje więcej niż lata korzystania z API przy typowym wolumenie foundera. 💰

Wyjątek: masz wymagania prywatności albo już posiadasz GPU. Wtedy zainstaluj Ollama, odpal Llamę 3.1 do zadań masowych i wzywaj Claude do trudnych problemów. Taka hybryda ścina koszty o 80%+, zachowując jakość tam, gdzie to się liczy. Wszystko inne to over-engineering. 🦝