Ollama CLI – ściągawka: ls, serve, run, ps + polecenia (aktualizacja 2026)

Ta ściągawka do CLI Ollama koncentruje się na poleceniach, których używasz każdego dnia (ollama ls, ollama serve, ollama run, ollama ps, zarządzanie modelami i typowe workflow), wraz z przykładami, które możesz skopiować i wkleić.

Obejmuje również pełną referencję do zmiennych środowiskowych ollama serve (OLLAMA_NUM_PARALLEL, OLLAMA_CONTEXT_LENGTH, OLLAMA_KV_CACHE_TYPE i inne), flagi dla modeli myślenia (--think, --hidethinking) oraz rozszerzone integracje ollama launch dla asystentów kodowania AI. Polecenia i flagi poniżej są zweryfikowane w oparciu o Ollama v0.33.2 (październik 2026).

Ta ściągawka do Ollama koncentruje się na poleceniach CLI, zarządzaniu modelami i dostosowywaniu, ale zawiera również kilka wywołań curl.

Aby uzyskać pełny obraz tego, gdzie Ollama plasuje się wśród opcji lokalnych, self-hosted i chmurowych — w tym vLLM, Docker Model Runner, LocalAI i dostawcy chmury — zobacz Hosting LLM: porównanie infrastruktury lokalnej, self-hosted i chmurowej. Jeśli porównujesz różne rozwiązania do lokalnego hostowania LLM, sprawdź nasz kompleksowe porównanie Ollama, vLLM, LocalAI, Jan, LM Studio i innych. Dla osób szukających alternatyw dla interfejsów wiersza poleceń, Docker Model Runner oferuje inne podejście do wdrażania LLM. Jeśli równoległy ruch lub kolejkowanie zaczynają obciążać pojedynczą instancję Ollama, Ollama do vLLM: Kiedy migrować lokalny serwer LLM przeprowadza Cię przez sygnały migracji i plan stopniowego wdrażania.

Instalacja Ollama (pobieranie i instalacja CLI)

• Opcja 1: Pobierz ze strony internetowej
  • Odwiedź ollama.com i pobierz instalator dla swojego systemu operacyjnego (Mac, Linux lub Windows).
• Opcja 2: Zainstaluj przez wiersz poleceń
  • Dla użytkowników Mac i Linux użyj polecenia:

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

• Postępuj zgodnie z instrukcjami na ekranie i podaj hasło, jeśli zostaniesz poproszony.

Wymagania systemowe Ollama (RAM, pamięć masowa, CPU)

• System operacyjny: Mac, Linux lub Windows
• Pamięć (RAM): minimum 8GB, zalecane 16GB lub więcej
• Pamięć masowa: co najmniej ~10GB wolnego miejsca (pliki modeli mogą być naprawdę duże — zobacz sekcję zarządzania modelami poniżej, aby je przenosić)
• Procesor: stosunkowo nowoczesny CPU (z ostatnich 5 lat). Jeśli jesteś ciekawy, jak Ollama wykorzystuje różne architektury CPU, zobacz naszą analizę jak Ollama wykorzystuje rdzenie wydajnościowe i efektywnościowe CPU Intel.

Podstawowe polecenia CLI Ollama

Uruchomienie samego ollama bez argumentów otwiera teraz ten sam interaktywny menu konfiguracyjny jak ollama launch — wybierasz integrację i model z listy.

CLI Ollama (czym jest)

CLI Ollama to interfejs wiersza poleceń do zarządzania modelami i ich lokalnego uruchamiania/służenia. Większość workflow sprowadza się do:

• Uruchom serwer: ollama serve
• Uruchom model: ollama run <model>
• Zobacz, co jest załadowane/uruchomione: ollama ps
• Zarządzaj modelami: ollama pull, ollama list, ollama rm
• Uruchom asystenta kodowania AI: ollama launch

Zarządzanie modelami Ollama: polecenia pull i list

Lista modeli:

ollama list

to samo co:

ollama ls

To polecenie wyświetla listę wszystkich modeli pobranych na Twój system wraz z ich rozmiarami plików na dysku HDD/SSD, na przykład:

$ ollama ls
NAME                                                    ID              SIZE      MODIFIED     
deepseek-r1:8b                                          6995872bfe4c    5.2 GB    2 weeks ago     
gemma3:12b-it-qat                                       5d4fa005e7bb    8.9 GB    2 weeks ago     
LoTUs5494/mistral-small-3.1:24b-instruct-2503-iq4_NL    4e994e0f85a0    13 GB     3 weeks ago     
dengcao/Qwen3-Embedding-8B:Q4_K_M                       d3ca2355027f    4.7 GB    4 weeks ago     
dengcao/Qwen3-Embedding-4B:Q5_K_M                       7e8c9ad6885b    2.9 GB    4 weeks ago     
qwen3:8b                                                500a1f067a9f    5.2 GB    5 weeks ago     
qwen3:14b                                               bdbd181c33f2    9.3 GB    5 weeks ago     
qwen3:30b-a3b                                           0b28110b7a33    18 GB     5 weeks ago     
devstral:24b                                            c4b2fa0c33d7    14 GB     5 weeks ago  

Pobierz model: ollama pull

ollama pull mistral-nemo:12b-instruct-2407-q6_K

To polecenie pobiera określony model (np. Gemma 2B lub mistral-nemo:12b-instruct-2407-q6_K) na Twój system. Pliki modeli mogą być dość duże, więc pilnuj miejsca zajętego przez modele na dysku twardym lub SSD. Może nawet chcieć przenieść wszystkie modele Ollama z katalogu domowego na inny, większy i lepszy dysk

Wgraj model: ollama push

ollama push my-custom-model

Wgrywa lokalny model do rejestru Ollama, aby inni mogli go pobrać. Najpierw musisz się zalogować (ollama signin) i nazwa modelu musi mieć prefiks z Twoim nazwą użytkownika Ollama, np. myuser/my-model. Użyj --insecure, jeśli wgrujesz do prywatnego rejestru przez HTTP:

ollama push myuser/my-model --insecure

Skopiuj model: ollama cp

ollama cp llama3.2 my-llama3-variant

Tworzy lokalną kopię modelu pod nową nazwą, bez ponownego pobierania czegokolwiek. To przydatne przed edycją Modelfile — najpierw skopiuj, dostosuj kopię i zachowaj oryginał nienaruszony:

ollama cp qwen3:14b qwen3-14b-custom
ollama create qwen3-14b-custom -f ./Modelfile

Usuń modele: ollama rm

ollama rm qwen3:8b
# nowsze wersje akceptują kilka modeli w jednym wywołaniu:
ollama rm qwen3:8b qwen3:14b

ollama rm usuwa manifest modelu i wszelkie bloki (blobs), które nie są już referencjowane przez inne modele, więc współdzielone warstwy bazowe pochodnych modeli są zachowane.

Polecenie Ollama show

ollama show wyświetla informacje o pobranym modelu.

ollama show qwen3:14b

Domyślnie wyświetla kartę modelu (architektura, długość kontekstu, długość wbudowania, kwantyzacja itp.). Istnieje sześć przydatnych flag:

# Zobacz dokładnie, z jakim promptem systemowym i szablonem zbudowano model
ollama show deepseek-r1:8b --modelfile

# Sprawdź rozmiar okna kontekstowego i inne parametry inferencji
ollama show qwen3:14b --parameters

# Tylko prompt systemowy zcustomizowanego modelu
ollama show mymodel --system

# Sprawdź licencję przed wdrożeniem modelu wewnątrz produktu
ollama show llama3.2 --license

# Pełne szczegóły na poziomie tensorów (przydatne przy debugowaniu kwantyzacji)
ollama show llama3.2 --verbose

Wyjście --modelfile jest szczególnie przydatne przed dostosowywaniem modelu: możesz skopiować bazowy Modelfile i edytować z tego poziomu, zamiast pisać go od zera.

Polecenie Ollama serve

ollama serve uruchamia lokalny serwer Ollama (domyślny port HTTP 11434).

ollama serve

Polecenie “ollama serve” (przyjazne systemd przykład):

# ustaw zmienne środowiskowe, a następnie uruchom serwer
# zrób ollama dostępnym na adresie IP gospodarza
export OLLAMA_HOST=0.0.0.0:11434
export OLLAMA_NUM_PARALLEL=2
ollama serve

ollama start jest aliasem dla ollama serve, więc oba uruchamiają ten sam serwer.

Bindowanie do 0.0.0.0 wystawia serwer na Twoją sieć bez uwierzytelnienia — ustaw przed nim proxy odwrócone z TLS, jak opisano w Ollama za proxy odwróconym Caddy lub Nginx, lub uzyskaj do niego dostęp przez prywatny tunel, following wzorce dostępu zdalnego do Ollama. Aby uruchomić serwer w kontenerze, zobacz Ollama w Docker Compose z GPU i trwałym magazynowaniem modeli.

Zmienne środowiskowe Ollama serve (pełna referencja)

To są zmienne środowiskowe, które ollama serve odczytuje przy uruchomieniu (stan na Ollama v0.33):

Na przykład, aby podnieść domyślną długość okna kontekstowego dla każdego modelu:

OLLAMA_CONTEXT_LENGTH=32768 ollama serve

Domyślna długość kontekstu w oparciu o VRAM

Gdy OLLAMA_CONTEXT_LENGTH nie jest ustawiony, serwer wybiera domyślną wartość stopniową w oparciu o całkowitą VRAM Twojej maszyny (dodane w Ollama v0.15.5):

Ollama zaleca co najmniej 64 000 tokenów dla obciążeń wymagających dużo kontekstu — wyszukiwanie w sieci, agenci i narzędzia do kodowania — a stopa pamięciowa skaluje się z OLLAMA_NUM_PARALLEL, więc wysoka wartość równoległa w połączeniu z dużym domyślnym kontekstem może wypychać warstwy modelu z VRAM. Serwer loguje wybraną wartość jako vram-based default context przy uruchomieniu.

Typ bufora KV wymienia pamięć za szybkość — kwantyzacja bufora KV do q8_0 w przybliżeniu zmniejsza jego stopę VRAM i nadaje się do uruchomień z długim kontekstem; nasz test bufora KV na GPU 16GB przy długim kontekście mierzy realny efekt. OLLAMA_NUM_PARALLEL i OLLAMA_MAX_QUEUE są szczegółowo omówione w Jak Ollama obsługuje równoległe żądania.

Polecenie Ollama run

Uruchom model:

ollama run gpt-oss:20b

To polecenie uruchamia określony model i otwiera interaktywny REPL do interakcji. Chcesz zrozumieć, jak Ollama zarządza wieloma równoległymi żadaniami? Dowiedz się więcej na temat jak Ollama obsługuje równoległe żądania w naszej szczegółowej analizie.

ollama run uruchamia model w interaktywnej sesji, więc w przypadku gpt-oss:120b zobaczylibyś coś w rodzaju:

$ ollama run gpt-oss:120b
>>> Wyślij wiadomość (/? dla pomocy)

możesz wpisać swoje pytania lub polecenia, a model odpowie.

>>> kim jesteś?
Thinking...
The user asks "who are you?" Simple question. Should respond as ChatGPT, an AI language model, trained by OpenAI, 
etc. Provide brief intro. Probably ask if they need help.
...done thinking.

I’m ChatGPT, an AI language model created by OpenAI. I’ve been trained on a wide range of text so I can help 
answer questions, brainstorm ideas, explain concepts, draft writing, troubleshoot problems, and much more. Think 
of me as a versatile virtual assistant—here to provide information, support, and conversation whenever you need 
it. How can I help you today?

>>> Wyślij wiadomość (/? dla pomocy)

Aby zakończyć interaktywną sesję ollama, naciśnij Ctrl+D lub możesz wpisać /bye, ten sam efekt:

>>> /bye
$ 

Przykłady polecenia Ollama run

Aby uruchomić model i zadać jedno pytanie w trybie nieinteraktywnym:

printf "Give me 10 bash one-liners for log analysis.\n" | ollama run llama3.2

Jeśli chcesz zobaczyć szczegółową, obszerną odpowiedź LLM w sesji ollama - uruchom model z parametrem --verbose lub -v:

$ ollama run gpt-oss:20b --verbose
>>> kim jesteś?
Thinking...
We need to respond to a simple question: "who are you?" The user is asking "who are you?" We can answer that we 
are ChatGPT, a large language model trained by OpenAI. We can also mention capabilities. The user likely expects 
a brief introduction. We'll keep it friendly.
...done thinking.

I’m ChatGPT, a large language model created by OpenAI. I’m here to help answer questions, offer explanations, 
brainstorm ideas, and chat about a wide range of topics—everything from science and history to creative writing 
and everyday advice. Just let me know what you’d like to talk about!

total duration:       1.118585707s
load duration:        106.690543ms
prompt eval count:    71 token(s)
prompt eval duration: 30.507392ms
prompt eval rate:     2327.30 tokens/s
eval count:           132 token(s)
eval duration:        945.801569ms
eval rate:            139.56 tokens/s
>>> /bye
$ 

Tak, to prawda, to jest 139 tokenów na sekundę. gpt-oss:20b jest bardzo szybki. Jeśli, jak ja, masz GPU z 16GB VRAM, zobacz szczegóły porównania prędkości LLM w Najlepsze LLM dla Ollama na GPU 16GB VRAM.

Wskazówka: Jeśli chcesz, aby model był dostępny przez HTTP dla wielu aplikacji, uruchom serwer z ollama serve i użyj klienta API zamiast długich sesji interaktywnych.

Flagi polecenia Ollama run (pełna referencja)

Dwie zmienne środowiskowe wpływają na samo ollama run: OLLAMA_EDITOR ustawia edytor otwierany przez Ctrl+G w REPL, a OLLAMA_NOHISTORY=1 wyłącza utrwalanie historii readline.

Modele myślenia: –think i –hidethinking

Modele zdolne do myślenia (deepseek-r1, qwen3, gpt-oss i inne) myślą domyślnie w CLI, a ślad rozumowania jest wyświetlany przed odpowiedzią:

ollama run qwen3:14b --think=false "Odpowiedz prosto, bez śladu rozumowania"
ollama run deepseek-r1:8b --hidethinking "Czy 9.9 jest większe niż 9.11?"   # myśli, ale wyświetla tylko odpowiedź

Modele GPT-OSS akceptują poziomy zamiast wartości boolean — dostosowują długość śladu zamiast włączać lub wyłączać:

ollama run gpt-oss:20b --think=low "Szkic nagłówka"

Wewnątrz sesji interaktywnej przełączaj myślenie za pomocą /set think i /set nothink.

Nadpisywanie parametrów modelu bez Modelfile

Starsze posty w blogach pokazują flagę -p / --parameters w ollama run; nie istnieje ona już w bieżących wydaniach. Obsługiwany sposób zmiany parametrów inferencji bez edycji Modelfile to REPL:

$ ollama run qwen3:14b
>>> /set parameter num_ctx 32768
Set parameter 'num_ctx' to '32768'
>>> /save qwen3-14b-32k
>>> /bye

/set parameter dotyczy tylko bieżącej sesji, a /save utrwalia go w nowym lokalnym modelu, który możesz później uruchomić z ollama run qwen3-14b-32k. /show parameters wyświetla listę ustawień w bieżącej sesji. Dla wszystkich modeli na serwerze, OLLAMA_CONTEXT_LENGTH w ollama serve zmienia globalnie domyślne okno kontekstowe.

Wspólne parametry, które możesz ustawić w ten sposób:

ollama show <model> raportuje długość kontekstu, którą model może obsłużyć, podczas gdy ollama ps pokazuje kontekst faktycznie przydzielony dla załadowanej instancji — zobacz polecenie Ollama ps, jeśli długi prompt wydaje się być cicho przycinany.

Wiele linii w REPL

Otocz tekst potrójnymi cudzysłowami ("""), aby wprowadzić wieloliniowy prompt bez wczesnego wysyłania:

>>> """Summarise this in one sentence:
... The quick brown fox jumps over the lazy dog.
... It happened on a Tuesday.
... """

Dłuższe prompty: Ctrl+G otwiera bieżący prompt w pełnym edytorze tekstu ($EDITOR lub to, na co wskazuje OLLAMA_EDITOR) i wysyła go, gdy zapiszesz i wyjdziesz — przydatne do iteracji nad długim promptem w stylu systemowym (dodane w Ollama v0.16).

Modele wielomodalne (obrazy)

Dla modeli zdolnych do widzenia (np. gemma3, llava), podaj ścieżkę do obrazu bezpośrednio w prompt:

ollama run gemma3 "What's in this image? /home/user/screenshot.png"

Generowanie wbudowań przez CLI

Modele wbudowań wyprowadzają tablicę JSON zamiast tekstu. Przekaż tekst bezpośrednio dla szybkich, jednorazowych wbudowań:

echo "Hello world" | ollama run nomic-embed-text

Dwie flagi ollama run są specyficzne dla modeli wbudowań: --dimensions 512 przycina wyjściowy wektor do 512 wymiarów (przydatne dla modeli zdolnych do Matryoshki, takich jak nomic-embed, gdy chcesz mniejszych wektorów), a --truncate=false sprawia, że wejścia dłuższe niż kontekst modelu zwracają błąd zamiast być cicho przycinane.

Dla produkcyjnych obciążeń wbudowań użyj punktu końcowego REST /api/embed lub klienta Python.

Wymuś wyjście JSON (–format)

ollama run llama3.2 --format json "List 5 capital cities as JSON"

Model jest instruowany, aby zwrócić poprawny JSON. Przydatne przy przekazywaniu wyjścia do jq lub skryptu oczekującego danych strukturalnych.

Polecenie Ollama stop

To polecenie zatrzymuje określony uruchomiony model.

ollama stop llama3.1:8b-instruct-q8_0

Ollama automatycznie usuwa modele po pewnym czasie. Domyślnie jest to 5 minut (OLLAMA_KEEP_ALIVE=5m); starsze wydania Ollama używały 4 minut. Jeśli nie chcesz czekać pozostały czas, użyj polecenia ollama stop. Przy uruchamianiu modelu możesz również przekazać --keepalive do ollama run (np. --keepalive 30s, --keepalive -1, aby model pozostawał załadowany na zawsze) lub wywołać punkt końcowy API /generate z parametrem keep_alive=0, aby natychmiast wyrzucić model z VRAM — zobacz poniżej opis i przykład.

Polecenie Ollama ps

ollama ps pokazuje obecnie uruchomione modele i sesje (przydatne do debugowania „dlaczego moja VRAM jest pełna?”).

ollama ps

Przykład wyjścia ollama ps poniżej:

NAME           ID              SIZE     PROCESSOR    CONTEXT    UNTIL
gpt-oss:20b    17052f91a42e    14 GB    100% GPU     4096       4 minutes from now

Kolumna CONTEXT to kontekst faktycznie przydzielony dla tej załadowanej instancji. Różni się od ollama show <model>, które raportuje długość kontekstu obsługiwaną przez model — jeśli model cicho przycina długie prompty, ollama ps to polecenie, które ujawnia realną wartość w czasie wykonania.

Widzisz tutaj na moim PC, że gpt-oss:20b bardzo dobrze mieści się w 16GB VRAM mojego GPU i zajmuje tylko 14GB.

Gdybym wykonał ollama run gpt-oss:120b, a następnie wywołał ollama ps, wynik nie byłby tak jasny: 78% warstw jest na CPU, a to jest tylko z oknem kontekstowym 4096 tokenów — stopa pamięciowa rośnie dalej, jeśli zwiększę kontekst.

NAME            ID              SIZE     PROCESSOR          CONTEXT    UNTIL
gpt-oss:120b    a951a23b46a1    66 GB    78%/22% CPU/GPU    4096       4 minutes from now

Polecenie Ollama launch (integracje z kodowaniem AI)

ollama launch to polecenie wprowadzone w Ollama v0.15 (styczeń 2026), które daje Ci konfigurację bez ustawień, w jednym wierszu, dla popularnych asystentów kodowania AI działających z Twoim lokalnym serwerem Ollama.

Po co używać ollama launch?

Przed ollama launch, podłączenie agenta kodującego, takiego jak Claude Code lub Codex, do lokalnego backendu Ollama oznaczało ręczne ustawianie zmiennych środowiskowych, wskazywanie narzędzia na odpowiedni punkt końcowy API i wybieranie kompatybilnego modelu. ollama launch obsługuje to wszystko interaktywnie.

Jeśli już uruchamiasz Ollama lokalnie i chcesz agenticznego asystenta kodowania bez płacenia za wywołania API ani wysyłania kodu do chmury, ollama launch to najszybsza droga do tego.

Obsługiwane integracje

Lista znacznie urosła poza cztery integracje z v0.15. Stanem na Ollama v0.33, ollama launch obsługuje:

Podstawowe użycie

# Interaktywny wybór — wybierz integrację i model z menu
# (wybór modelu jest zawsze wyświetlany od v0.16.3)
ollama launch

# Uruchom określoną integrację bezpośrednio
ollama launch claude

# Uruchom z określonym modelem
ollama launch claude --model qwen3-coder

# Skonfiguruj integrację bez jej uruchamiania (przydatne do przeglądu ustawień)
ollama launch droid --config

# Zresetuj integrację do domyślnego profilu
ollama launch codex --restore

# Przekazuj dodatkowe argumenty do integracji po --
ollama launch codex -- --sandbox workspace-write

--yes (-y) automatycznie odpowiada na pytania potwierdzające, co jest przydatne w skryptach i流程 onboardingu.

Zalecane modele

Agenci kodowania potrzebują długiego okna kontekstowego, aby utrzymać kontekst całego pliku i historię wieloturnowej rozmowy. Ollama zaleca modele z kontekstem co najmniej 64 000 tokenów:

Jeśli Twoje GPU nie mieści modelu, Ollama oferuje również warianty hostowane w chmurze (np. qwen3-coder:480b-cloud), które integrują się w ten sam sposób, ale kierują inferencję do warstwy chmurowej Ollama — wymaga to ollama signin.

Przykład: uruchamianie Claude Code lokalnie z Ollama

# 1. Upewnij się, że model jest dostępny
ollama pull qwen3-coder

# 2. Uruchom Claude Code wobec niego
ollama launch claude --model qwen3-coder

Ollama ustawia niezbędne zmienne środowiskowe i uruchamia Claude Code wskazując na http://localhost:11434 automatycznie. Możesz wtedy używać Claude Code dokładnie tak, jak zwykle — jedyna różnica polega na tym, że inferencja dzieje się na Twoim własnym sprzęcie.

Ustawienia wydajności (OLLAMA_NUM_PARALLEL)

Jeśli widzisz kolejkowanie lub przekroczenia czasu pod obciążeniem, pierwszym pokrętłem do poznanie jest OLLAMA_NUM_PARALLEL.

• OLLAMA_NUM_PARALLEL = ile żądań Ollama wykonuje równolegle.
• Wyższa wartość może zwiększyć przepustowość, ale może zwiększyć presję VRAM i szczyty opóźnień.
• Żądania, które przychodzą, gdy wszystkie sloty równoległe są zajęte, trafiają do kolejki; jej głębokość jest ograniczona przez OLLAMA_MAX_QUEUE.

Szybki przykład:

OLLAMA_NUM_PARALLEL=2 ollama serve

Dla pełnego wyjaśnienia (w tym strategie strojenia i tryby awarii), zobacz:

• Jak Ollama obsługuje równoległe żądania

Zwolnienie modelu Ollama z VRAM (keep_alive)

Gdy model jest załadowany do VRAM (pamięć GPU), pozostaje tam, nawet po zakończeniu jego używania. Aby jawnie zwolnić model z VRAM i uwolnić pamięć GPU, możesz wysłać żądanie do API Ollama z keep_alive: 0.

• Zwolnij model z VRAM używając curl:

curl http://localhost:11434/api/generate -d '{"model": "MODELNAME", "keep_alive": 0}'

Zastąp MODELNAME swoją faktyczną nazwą modelu, na przykład:

curl http://localhost:11434/api/generate -d '{"model": "qwen3:14b", "keep_alive": 0}'

• Zwolnij model z VRAM używając Python:

import requests

response = requests.post(
    'http://localhost:11434/api/generate',
    json={'model': 'qwen3:14b', 'keep_alive': 0}
)

To jest szczególnie przydatne, gdy:

• Musisz uwolnić pamięć GPU dla innych aplikacji
• Uruchamiasz wiele modeli i chcesz zarządzać zużyciem VRAM
• Zakończyłeś używanie dużego modelu i chcesz natychmiast zwolnić zasoby

Uwaga: Parametr keep_alive kontroluje, jak długo (w sekundach) model pozostaje załadowany w pamięci po ostatnim żądaniu. Ustawienie go na 0 natychmiast wyładowuje model z VRAM, wartość ujemna (np. -1) utrzymuje model załadowany na zawsze, a ciąg czasu (np. 10m, 24h) jest również akceptowany. Domyślnie dla całego serwera to OLLAMA_KEEP_ALIVE=5m, a keep_alive per żądanie zawsze je nadpisuje.

Jeśli wolisz całkowicie unikać warstwy abstrakcji Ollama i chcesz bezpośredniej kontroli nad tym, który model GGUF jest rezydentny w danym momencie, tryb routera llama-server omawia natywne dla llama.cpp podejście do dynamicznego przełączania modeli.

Dostosowywanie modeli Ollama (prompt systemowy, Modelfile)

• Ustaw prompt systemowy: Wewnątrz REPL Ollama możesz ustawić prompt systemowy, aby dostosować zachowanie modelu:

  >>> /set system For all questions asked answer in plain English avoiding technical jargon as much as possible
  >>> /save ipe
  >>> /bye
  

  Następnie uruchom zcustomizowany model:

  ollama run ipe
  

  To ustawia prompt systemowy i zapisuje model do przyszłego użycia.

• Utwórz plik modelu custom: Utwórz plik tekstowy (np. custom_model.txt) z następującą strukturą:

  FROM llama3.1
  PARAMETER num_ctx 32768
  SYSTEM [Twoje niestandardowe instrukcje tutaj]
  

  Następnie uruchom:

  ollama create mymodel -f custom_model.txt
  ollama run mymodel
  

  To tworzy dostosowany model na podstawie instrukcji w pliku. ollama create może również kwantyzować podczas budowania — -q q4_K_M produkuje GGUF Q4_K_M z niekwantyzowanego źródła (safetensors), --draft-quantize ustawia kwantyzację dla modelu draft (spekulatywnego dekodowania), a --experimental włącza funkcje tworzenia modeli safetensors, które nadal są oznaczone jako eksperymentalne.

Ollama signin i signout (uwierzytelnianie rejestru)

ollama signin
ollama signout

ollama signin uwierzytelnia Twoją lokalną instalację Ollama w rejestrze Ollama pod adresem ollama.com. Po zalogowaniu klient przechowuje dane uwierzytelniające lokalnie i automatycznie ponownie ich używa dla kolejnych poleceń.

Co odblokowuje signin:

• Pobieranie i wgrywanie prywatnych modeli z Twojego konta lub organizacji.
• Używanie modeli hostowanych w chmurze (np. qwen3-coder:480b-cloud), które są zbyt duże, aby działać lokalnie.
• Publikowanie modeli w rejestrze za pomocą ollama push.

Alternatywa: uwierzytelnianie kluczem API

Jeśli uruchamiasz Ollama w pipeline CI lub na serwerze bez interfejsu, gdzie interaktywne ollama signin nie jest praktyczne, utwórz klucz API w ustawieniach Twojego konta Ollama i udostępnij go jako zmienną środowiskową:

export OLLAMA_API_KEY=ollama_...
ollama pull myorg/private-model

Zmienna OLLAMA_API_KEY jest automatycznie pobierana przez każde polecenie Ollama i żądanie API — nie ma potrzeby uruchamiać ollama signin na każdej maszynie.

Używanie polecenia Ollama run z plikami (podsumowanie, przekierowanie)

• Podsumowanie tekstu z pliku:

  ollama run llama3.2 "Summarize the content of this file in 50 words." < input.txt
  

  To polecenie podsumowuje zawartość input.txt używając określonego modelu.

• Zapisuj odpowiedzi modelu do pliku:

  ollama run llama3.2 "Tell me about renewable energy." > output.txt
  

  To polecenie zapisuje odpowiedź modelu do output.txt.

Przypadki użycia CLI Ollama (generowanie tekstu, analiza)

• Generowanie tekstu:

  • Podsumowanie dużego pliku tekstowego:

    ollama run llama3.2 "Summarize the following text:" < long-document.txt
    

  • Generowanie treści:

    ollama run llama3.2 "Write a short article on the benefits of using AI in healthcare." > article.txt
    

  • Odpowiadanie na konkretne pytania:

    ollama run llama3.2 "What are the latest trends in AI, and how will they affect healthcare?"
    

  • Odpowiedzi one-shot bez śladu myślenia (dla modeli myślenia):

    ollama run qwen3:14b --think=false --hidethinking "What are the latest trends in AI, and how will they affect healthcare?"
    

• Przetwarzanie i analiza danych:

  • Klasyfikowanie tekstu na pozytywne, negatywne lub neutralne sentymenty:

    ollama run llama3.2 "Analyze the sentiment of this customer review: 'The product is fantastic, but delivery was slow.'"
    

  • Kategorizowanie tekstu w predefiniowane kategorie: Użyj podobnych poleceń, aby klasyfikować lub kategoryzować tekst na podstawie predefiniowanych kryteriów.

Używanie Ollama z Python (klient i API)

• Zainstaluj bibliotekę Python Ollama:

  pip install ollama
  

• Generuj tekst używając Python:

  import ollama
  
  response = ollama.generate(model='gemma:2b', prompt='what is a qubit?')
  print(response['response'])
  

  Ten fragment kodu generuje tekst używając określonego modelu i promptu.

Dla zaawansowanej integracji z Python, zapoznaj się z używaniem API wyszukiwania w sieci Ollama w Python, które obejmuje funkcje wyszukiwania w sieci, wywoływanie narzędzi i integrację z serwerem MCP.

Szukasz interfejsu opartego na sieci? Open WebUI zapewnia self-hostowany interfejs z funkcjami RAG i wsparciem wielu użytkowników.

Przydatne linki

Konfiguracja i zarządzanie

• Przenieś modele Ollama na inny dysk lub folder
• Ollama w Docker Compose z GPU i trwałym magazynowaniem modeli

Alternatywy i porównania

• Lokalne hostowanie LLM: Kompletny przewodnik na 2026 - Ollama, vLLM, LocalAI, Jan, LM Studio i inne
• llama.cpp vs Ollama w 2026: Który runtime powinien uruchamiać?
• Szybki start vLLM: Wysokowydajne serwowanie LLM
• Docker Model Runner vs Ollama: Co wybrać?
• Pierwsze znaki enshittification Ollama
• Ollama do vLLM: Kiedy migrować lokalny serwer LLM

Wydajność i sprzęt

• Jak Ollama obsługuje równoległe żądania
• Jak Ollama wykorzystuje rdzenie wydajnościowe i efektywnościowe CPU Intel
• NVIDIA DGX Spark vs Mac Studio vs RTX-4080: Porównanie wydajności Ollama

Integracja i rozwój

• Używanie API wyszukiwania w sieci Ollama w Python
• Używanie API wyszukiwania w sieci Ollama w Go
• Porównanie asystentów kodowania AI
• Interfejsy UI do czatu z LLM na lokalnych instancjach Ollama
• Ograniczanie LLM za pomocą strukturalnego wyjścia: Ollama, Qwen3 i Python lub Go
• Integrowanie Ollama z Python: Przykłady REST API i klienta Python
• SDK Go dla Ollama - porównanie z przykładami