<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>Ollama — Inferownia</title><link>https://inferownia.pl/tags/ollama/</link><description>Inferownia — polski hub wiedzy o lokalnym AI: uruchamianie modeli językowych na własnym sprzęcie, kwantyzacja, inferencja, małe modele, fine-tuning i RAG.</description><language>pl-PL</language><copyright>&#169; 2026 Inferownia</copyright><lastBuildDate>Sat, 04 Jul 2026 00:00:00 +0200</lastBuildDate><atom:link href="https://inferownia.pl/tags/ollama/index.xml" rel="self" type="application/rss+xml"/><item><title>Ollama, llama.cpp, LM Studio: co siedzi pod maską</title><link>https://inferownia.pl/poradniki/ollama-llama-cpp-lm-studio/</link><pubDate>Sat, 04 Jul 2026 00:00:00 +0200</pubDate><category>inferencja</category><guid>https://inferownia.pl/poradniki/ollama-llama-cpp-lm-studio/</guid><description>Instalujesz Ollamę, model gada od strzału i myślisz: magia. A pod tym ładnym `ollama run` siedzi ten sam silnik, co pod resztą. Rozbieramy, kto tu jest maszyną, a kto tylko obudową.</description><content:encoded><![CDATA[<p>Jedna linijka — <code>ollama run llama3</code> — enter, kilkanaście sekund mielenia i nagle coś
w terminalu zaczyna z tobą gadać. Bez kompilowania, bez flag, bez wgryzania się w sto
stron README: jedna komenda i masz lokalny model pod ręką. Człowiek wtedy myśli,
że Ollama to jakiś osobny, samowystarczalny cud techniki. A potem na jakimś forum
trafiasz na komentarz, gdzie ktoś na dzień dobry rzuca: „przecież to i tak leci na llama.cpp pod
spodem&quot;. I nagle cały ten ekosystem — Ollama, LM Studio, KoboldCpp — zaczyna wyglądać jak
scena, na której jest o wiele więcej podwójnych ról, niż się wydawało.</p>
<p>Bo lokalny LLM to nie jedno pudełko. To silnik i obudowa. I zanim wybierzesz, w czym
odpalać modele, warto wiedzieć, kto tu jest maszyną, a kto tylko ładnie polakierowanym
panelem z pokrętłami. Nie po to, żeby wybierać strony w kolejnej wojnie plemiennej — po to,
żeby wiedzieć, kiedy nakładka ci wystarczy, a kiedy trzeba zejść piętro niżej.</p>
<h2 id="silnik-którego-nie-widać-llamacpp-i-ggml">Silnik, którego nie widać: llama.cpp i ggml</h2>
<p>Zacznijmy od dna, bo tam mieszka bohater tej historii. <code>llama.cpp</code> (repo
<code>ggml-org/llama.cpp</code>) to biblioteka i silnik inferencji LLM napisane w czystym C/C++,
z minimalnymi zależnościami, na licencji MIT.<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> Nie ma ładnego okienka. Nie ma
listy modeli do kliknięcia. To surowy kod, który bierze wagi modelu i liczy — a liczy na
bibliotece tensorowej niższego poziomu o nazwie <strong>ggml</strong>, i to ona jest właściwym mięśniem,
który mnoży macierze pod całą tą konstrukcją.</p>
<p>To właśnie tu żyją rzeczy, które w codziennym „odpal i gadaj&quot; są niewidzialne. Kwantyzacja
po treningu (<em>post-training quantization</em> — ściskanie gotowych wag, nie trenowanie modelu
od zera w niskiej precyzji, bo to dwie różne bajki) w formacie GGUF, z poziomami od
1.5-bitowego po 8-bitowy.<sup id="fnref1:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> Akceleracja na Metal (Apple Silicon), CUDA (NVIDIA),
HIP (AMD), Vulkan, SYCL (Intel), plus optymalizacje CPU (AVX/AVX2/AVX512).<sup id="fnref2:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup>
Zestaw narzędzi z linii komend: <code>llama-cli</code> do rozmowy, <code>llama-server</code> z API,
<code>llama-bench</code> do mierzenia wydajności, <code>llama-quantize</code> do ściskania modeli.<sup id="fnref3:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup>
Rozbieraliśmy te flagi na czynniki pierwsze <a href="/poradniki/flagi-llama-cpp/">tutaj</a>, a nazwy
kwantyzacji GGUF (<code>Q4_K_M</code> i cała ta rodzina) <a href="/poradniki/nazwy-kwantyzacji-gguf/">tutaj</a>.</p>
<p>Zapamiętaj jedno: kiedy Ollama, LM Studio albo KoboldCpp „uruchamia model&quot;, to w
przytłaczającej większości przypadków pod spodem kręci się właśnie ten silnik. Reszta to
obudowa. Świetna, wygodna, oszczędzająca ci godzin — ale obudowa.</p>
<h2 id="ollama-nakładka-która-po-cichu-wyhodowała-własny-silnik">Ollama: nakładka, która po cichu wyhodowała własny silnik</h2>
<p>Ollama to najpopularniejszy sposób, w jaki ludzie wchodzą w lokalne LLM-y, i przez długi
czas najkrótszy opis brzmiał: „llama.cpp z ładnym zarządzaniem modelami&quot;. Sama dokumentacja
projektu mówi, że Ollama jest oparta na <code>llama.cpp</code> założonym przez Georgiego Gerganova i
historycznie korzystała z niego jako silnika wykonawczego pod spodem; licencja MIT.<sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup></p>
<p>Do tego dokłada rzeczy, których gołe <code>llama.cpp</code> ci nie da od strzału. <strong>Modelfile</strong> —
format konfiguracyjny w duchu Dockerfile, który opisuje parametry, prompt systemowy i wagi,
żeby zbudować z tego gotowy „obraz&quot; modelu.<sup id="fnref1:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup> Rejestr <code>ollama.com/library</code>, z którego
ściągasz modele jednym <code>ollama pull</code>, jak obrazy z Docker Huba. I własne REST API na porcie
<code>11434</code> (<code>http://localhost:11434/api/</code>), odrębne od tego, co wystawia <code>llama-server</code>.<sup id="fnref2:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup>
To jest właśnie ta wygoda, za którą się Ollamę kocha: nie myślisz o plikach GGUF, o ścieżkach,
o flagach. Wpisujesz nazwę i działa.</p>
<p>Ale tu jest zwrot akcji, o którym połowa internetu wciąż nie wie. Od maja 2025, wraz z
ogłoszeniem „Ollama&rsquo;s new engine for multimodal models&quot;, Ollama dla części modeli — między
innymi Meta Llama 4, Google Gemma 3, Qwen 2.5 VL czy Mistral Small 3.1 — przeszła na własny
silnik napisany w Go, który korzysta bezpośrednio z biblioteki ggml, z pominięciem
<code>llama.cpp</code>.<sup id="fnref:3"><a href="#fn:3" class="footnote-ref" role="doc-noteref">3</a></sup> <code>llama.cpp</code> i ggml zostają dla wstecznej kompatybilności na CPU i
dla pozostałych modeli, ale samo hasło „Ollama to po prostu llama.cpp w ładnym opakowaniu&quot;
zrobiło się nieaktualne. Ciekawostka, ale ważna: nawet gdy nakładka odcina się od
<code>llama.cpp</code>, i tak stoi na tym samym fundamencie — ggml. Mięsień został ten sam, zmieniło się
tylko, kto go obsługuje.</p>
<h2 id="lm-studio-okno-dwa-silniki-i-zamknięte-drzwi">LM Studio: okno, dwa silniki i zamknięte drzwi</h2>
<p>A co, jeśli w ogóle nie chcesz terminala? Wtedy wchodzi LM Studio — aplikacja desktopowa na
Windows, Linux i macOS, z prawdziwym GUI: przeglądasz modele, klikasz, pobierasz, gadasz.
Pod spodem uruchamia modele przez <code>llama.cpp</code> w formacie GGUF, a na Apple Silicon dorzuca
dodatkowo silnik <strong>MLX</strong> — inferencyjny framework Apple — jako alternatywę dla
<code>llama.cpp</code>.<sup id="fnref:4"><a href="#fn:4" class="footnote-ref" role="doc-noteref">4</a></sup> Czyli znów: ten sam silnik u podstaw, tylko schowany za oknem, w
które można klikać.</p>
<p>Dla programisty LM Studio wystawia dwie rzeczy naraz: <strong>OpenAI Compatibility API</strong> (żeby
podpiąć się jak do OpenAI, tylko lokalnie) oraz własne <strong>LM Studio REST API</strong> (w wersji
beta), a do tego CLI o nazwie <code>lms</code> do zarządzania modelami, serwerem i pobieraniem.<sup id="fnref1:4"><a href="#fn:4" class="footnote-ref" role="doc-noteref">4</a></sup>
Wygodne? Bardzo. Jest jednak jeden haczyk, który łatwo przeoczyć: to, że LM Studio stoi na
otwartoźródłowych silnikach (<code>llama.cpp</code>, MLX), <strong>nie</strong> czyni z niego projektu open source.
Sama aplikacja jest zamkniętym oprogramowaniem. Silnik w środku możesz obejrzeć do ostatniej
linijki; obudowę wokół niego — już nie.</p>
<h2 id="koboldcpp-nie-osobny-silnik-tylko-llamacpp-w-jednym-pliku">KoboldCpp: nie osobny silnik, tylko llama.cpp w jednym pliku</h2>
<p>Na koniec przypadek, który najłatwiej źle zaszufladkować. KoboldCpp (<code>LostRuins/koboldcpp</code>)
wygląda jak osobne narzędzie — jeden plik wykonywalny, który odpalasz i masz gotowy interfejs.
Ale to nie konkurencyjny silnik wobec <code>llama.cpp</code>. To fork i nakładka bazująca bezpośrednio
na jego kodzie, spakowana w pojedynczą binarkę i rozszerzona o dodatkowe funkcje. Sam
KoboldCpp jest na licencji AGPL v3.0, przy czym zależność <code>llama.cpp</code> w środku pozostaje na
MIT.<sup id="fnref:5"><a href="#fn:5" class="footnote-ref" role="doc-noteref">5</a></sup></p>
<p>Obsługuje modele GGUF (z kompatybilnością wsteczną dla starszego GGML — o czym za chwilę) i
wystawia równolegle dwa API: własne KoboldAI/KoboldCpp oraz endpoint kompatybilny z OpenAI
pod ścieżką <code>/v1</code>. Do tego dorzuca interfejs KoboldAI Lite z trybami chat, adventure, instruct
i storywriter.<sup id="fnref1:5"><a href="#fn:5" class="footnote-ref" role="doc-noteref">5</a></sup> Innymi słowy: bierze ten sam silnik, co reszta, i buduje wokół niego
inny zestaw wygód — mocno wychylony w stronę pisania i grania. Nazwanie tego „rywalem
llama.cpp&quot; to jak nazwanie karoserii rywalem silnika.</p>
<div class="callout">
  <span class="callout__label">Dlaczego to ważne dla lokalnego LLM</span>
<p>Przy okazji rozprawmy się z pułapką, na której potyka się pół forum: <strong>GGML to nie GGUF</strong>.
GGML to starszy, dziś przestarzały format plików; GGUF to jego następca — i to właśnie jego
używają dziś <code>llama.cpp</code>, Ollama, LM Studio i KoboldCpp. Jeśli natrafisz w sieci na model
„w GGML&quot;, patrzysz na zabytek. Bierz GGUF. Cały obecny ekosystem stoi na tym drugim —
rozgryzaliśmy go bliżej <a href="/aktualnosci/ekosystem-gguf/">tutaj</a>.</p>
</div>
<h2 id="to-którego-w-końcu-wziąć">To którego w końcu wziąć?</h2>
<p>Teraz konkret, bo o to naprawdę chodzi. Nie o to, który silnik „lepszy&quot; — bo silnik u
podstaw (ggml) jest w dużej mierze wspólny — tylko o to, ile wygody wymieniasz za ile
kontroli.</p>
<table>
	<thead>
			<tr>
					<th>Narzędzie</th>
					<th>Czym jest</th>
					<th>Silnik pod spodem</th>
					<th>API</th>
					<th>Otwarte źródło</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td><strong>llama.cpp</strong></td>
					<td>silnik + CLI</td>
					<td>ggml (bezpośrednio)</td>
					<td><code>llama-server</code>, OpenAI-compat</td>
					<td>tak (MIT)</td>
			</tr>
			<tr>
					<td><strong>Ollama</strong></td>
					<td>nakładka + zarządzanie modelami</td>
					<td>llama.cpp/ggml, częściowo własny silnik w Go</td>
					<td>własne REST (port 11434)</td>
					<td>tak (MIT)</td>
			</tr>
			<tr>
					<td><strong>LM Studio</strong></td>
					<td>aplikacja desktopowa (GUI)</td>
					<td>llama.cpp, MLX na Apple Silicon</td>
					<td>OpenAI-compat + LM Studio REST</td>
					<td>nie (zamknięta)</td>
			</tr>
			<tr>
					<td><strong>KoboldCpp</strong></td>
					<td>fork/nakładka w jednym pliku</td>
					<td>llama.cpp</td>
					<td>KoboldAI + OpenAI-compat <code>/v1</code></td>
					<td>tak (AGPL v3.0)</td>
			</tr>
	</tbody>
</table>
<p>Nakładka wystarczy — i to z nawiązką — kiedy chcesz po prostu ściągać modele jednym
poleceniem, przełączać się między nimi bez myślenia o ścieżkach i mieć endpoint, do którego
podepniesz swój kod. To codzienność dziewięciu na dziesięciu lokalnych LLM-owców. Ollama do
szybkiego <code>pull</code> i <code>run</code>, LM Studio jak wolisz klikać w okno, KoboldCpp jak siedzisz w
pisaniu i przygodówkach.</p>
<p>Do gołego <code>llama.cpp</code> schodzisz, gdy zaczyna ci brakować pokręteł. Chcesz wycisnąć konkretny
offload warstw na kartę, ustawić dokładny typ kwantyzacji KV-cache, złapać najświeższą flagę,
która w repo pojawiła się wczoraj, a do nakładki dojdzie za dwa wydania. Albo chcesz
<code>llama-server</code> z równoległym dekodowaniem (<em>parallel decoding</em>), serwujący do tego modele
embeddingowe i rerankingowe pod twojego RAG-a.<sup id="fnref4:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup>
Wtedy obudowa zaczyna przeszkadzać, a ty otwierasz maskę i grzebiesz przy silniku sam.</p>
<h2 id="zrób-to-sam-zejdź-o-piętro">Zrób to sam: zejdź o piętro</h2>
<p>Chcesz na własne oczy zobaczyć, że pod spodem siedzi jeden i ten sam mechanizm? Weź dowolny
model GGUF, którego już używasz w Ollamie, i odpal go bezpośrednio w <code>llama.cpp</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">git clone https://github.com/ggml-org/llama.cpp
</span></span><span class="line"><span class="cl"><span class="nb">cd</span> llama.cpp
</span></span><span class="line"><span class="cl"><span class="c1"># zbuduj wg instrukcji z README pod swój backend (Metal/CUDA/Vulkan/CPU)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">llama-server -m twoj-model-q4_k_m.gguf -c <span class="m">8192</span> -fa on
</span></span></code></pre></div><p>Wchodzisz na <code>http://localhost:8080</code>, dostajesz web UI i OpenAI-kompatybilne API — to samo,
co daje ci nakładka, tylko bez pośrednika i z pełnym dostępem do każdej flagi. Kod, aktualne
narzędzia i instrukcje budowania są w repo:
<a href="https://github.com/ggml-org/llama.cpp">github.com/ggml-org/llama.cpp</a>. Jak zechcesz wrócić
do wygody — Ollama, LM Studio i KoboldCpp czekają tam, gdzie je zostawiłeś. Nic nie tracisz,
bo pliki GGUF działają wszędzie tak samo.</p>
<p>Bo cała ta scena — Ollama, LM Studio, KoboldCpp — to w gruncie rzeczy różne obudowy
przykręcone do wspólnego silnika. Jedni lubią jeździć autem, nie otwierając nigdy maski, i
to jest w porządku — dojedziesz, gdzie chcesz. Inni muszą wiedzieć, co tam warczy, i co
jakiś czas zaglądają, czy wszystko na swoim miejscu. Lokalne AI ma miejsce dla obu. Ważne
tylko, żeby wiedzieć, że pod każdą z tych błyszczących karoserii bije mniej więcej to samo
serce — i że w każdej chwili możesz podnieść klapę i mu się przyjrzeć.</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p><code>ggml-org/llama.cpp</code> — README (silnik C/C++ na ggml, kwantyzacja GGUF 1.5–8 bit, narzędzia <code>llama-cli</code>/<code>llama-server</code>/<code>llama-bench</code>/<code>llama-quantize</code>, backendy Metal/CUDA/HIP/Vulkan/SYCL/CPU, parallel decoding, embeddingi i reranking, licencja MIT): <a href="https://github.com/ggml-org/llama.cpp">github.com/ggml-org/llama.cpp</a>.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a>&#160;<a href="#fnref1:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a>&#160;<a href="#fnref2:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a>&#160;<a href="#fnref3:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a>&#160;<a href="#fnref4:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p><code>ollama/ollama</code> — README (Ollama oparta na <code>llama.cpp</code> założonym przez Georgiego Gerganova, Modelfile, rejestr <code>ollama.com/library</code>, REST API na porcie 11434, licencja MIT): <a href="https://github.com/ollama/ollama">github.com/ollama/ollama</a>.&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a>&#160;<a href="#fnref1:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a>&#160;<a href="#fnref2:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:3">
<p>„Ollama&rsquo;s new engine for multimodal models&quot; — blog Ollamy (przejście części modeli, m.in. Llama 4, Gemma 3, Qwen 2.5 VL, Mistral Small 3.1, na własny silnik w Go korzystający bezpośrednio z ggml): <a href="https://ollama.com/blog/multimodal-models">ollama.com/blog/multimodal-models</a>.&#160;<a href="#fnref:3" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:4">
<p>LM Studio — dokumentacja (aplikacja desktopowa uruchamiająca modele przez <code>llama.cpp</code>/GGUF, MLX na Apple Silicon, OpenAI Compatibility API i LM Studio REST API, CLI <code>lms</code>): <a href="https://lmstudio.ai/docs">lmstudio.ai/docs</a>.&#160;<a href="#fnref:4" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a>&#160;<a href="#fnref1:4" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:5">
<p><code>LostRuins/koboldcpp</code> — README (fork/nakładka na <code>llama.cpp</code> w jednym pliku wykonywalnym, obsługa GGUF, API KoboldAI oraz OpenAI-compat <code>/v1</code>, UI KoboldAI Lite, licencja AGPL v3.0): <a href="https://github.com/LostRuins/koboldcpp">github.com/LostRuins/koboldcpp</a>.&#160;<a href="#fnref:5" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a>&#160;<a href="#fnref1:5" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></content:encoded></item></channel></rss>