Jazykové modely v terminálu

Jazykové modely ❤ terminál

Na jazykových modelech mě baví, že jsou koncepčně velmi jednoduché. Dáte do nich textový vstup a vyjde vám z nich textový výstup. Všechny další fígle – oddělování vstupu od uživatele, volání nástrojů, přidávání externích zdrojů, atd. – je potřeba řešit pomocí textu.¹ Toto je zároveň i zdroj bezpečnostních děr. Ale o tom zase někdy jindy.

Podobně jednoduchý je i terminál. Jazykové modely se proto v terminálu cítí jako minimalista na strahovských kolejích:

Jasně, otevřené jazykové modely můžeme rozjet i v grafickém rozhraní podobném tomu, jakému znáte z komerčních modelů. Pokud se vám zachce, nikdo vám nebude bránit si kolem vstupního pole nastavit lehce rozpitý světle modrý gradient (jen ho nezapomeňte řádně A/B otestovat):

U řady dalších AI aplikací se grafické prostředí šikne, například u generátorů obrázků,² Pokud tedy nechcete obrázky renderovat přímo v terminálu – i to je možnost. u jazykových modelů je to ale jen nadstavba.

V tomto článku si tedy povíme, jak spouštět modely v inferenčním módu pomocí terminálových nástrojů – konkrétně dvou velmi rozšířených nástrojů, Ollamy a vLLM.

Jen pro jistotu: tento článek nemá za cíl být definitivní přehled nástrojů ani jejich technická dokumentace. Přehled si v lepší kvalitě dokážete vygenerovat právě některým z modelů, navíc jsou podobných článků na internetu mraky. Teď vás chci spíš inspirovat do začátku a dát k tomu pár pointerů. A abych vás nenudil, dovolím si to opepřit i vlastními zkušenostmi 😎

K čemu je to dobré?

Na začátek je dobré si říct, k čemu je vlastně dobré pouštět modely pro inferenci.

• Asi vás napadne, že můžete s modely interagovat v režimu chatu. To se v terminálu nejvíc hodí pro jednoduché vibe-testy (“Načetl se model správně?”, “Jak rychle běží?”, “Dává ta odpověď aspoň trochu smysl?”). Může se to také hodit, když potřebujete při záoceánském letu odpovědi na zásadní životní otázky a kolega vedle vás zrovna spí.
• Především ale můžete modely napojovat do vaší codebase: zpřístupnit model ve webovém rozhraní, volat ho z jiných nástrojů přes API, napojovat do pipeline na zpracování dat (např. při tvorbě embeddingů, automatické sumarizaci, atd.).
• Také můžete s modely pouštět dávkové experimenty: například pro benchmarkování, automatické testy, optimalizaci promptů. Tedy cokoliv, co chcete jen pustit, odejít si udělat kafe a vrátit se k hotovému výsledku.

Rozjet modely pro inferenci je i základ pro to, abychom mohli lokálně pouštět modely jako agenty, tedy je napojovat do trochu víc těžkotonážních agentních harnesses – ale o tom až někdy příště.

Ollama: Zde začněte doma

Ollama je miláčkem všech tutoriálů na spouštění jazykových modelů lokálně. Nejspíš za to může to, že je uživatelsky přívětivá, což si o terminálovém prostředí celkově nemyslí ani samotné modely:

Jak zjistíme, její jednoduchost může být po chvíli používání trochu na škodu, pro začátek to ale budeme zvesela ignorovat.

Jednoduchost Ollamy dává najevo už úvodní stránka:

Tato stránka se vám snaží vnuknout dojem, že vám na instalaci stačí jediný příkaz – tedy pokud vám nevadí spouštět neznámý kód z internetu.³ Obavy zahání přátelská lama. Nebo že by měla jenom křeč v ruce? Tím nechci naznačovat, že tomu tak není nebo že byste to neměli dělat. Na vlastním počítači vám to zafunguje a je to nejspíš bezpečnější, než spouštět cracky do her.

Už i tady ale ta jednoduchost může trochu klamat. Sám jsem to poprvé naivně zkusil na školním clusteru. Jednak instalace neprošla, a navíc jsem dostal sprda od našeho IT oddělení, kam došla hlášení s pokusy o sudo.

V případech, že nemáte správcovský přístup k počítači, je proto lepší kliknout na malý odkaz “download Ollama” a “Manual install instructions”, který vede na podrobnější instrukce k instalaci a které se dají přizpůsobit pro instalaci do uživatelských složek.⁴ Dneska už bych to nejspíš zadal agentovi s linkem na stránku s instrukcemi, čímž bych to znova převedl zpátky na “pouštíme neznámý kód z internetu”. Asi je nějaký důvod, proč jsem nakonec nešel studovat počítačovou bezpečnost.

Interagujeme s modely

Pokud jste Ollamu nainstalovali skrz zmíněný instalační skript, už vám nejspíš běží jako služba na pozadí. Pokud jste ji ovšem nainstalovali manuálně nebo službu nepovolili, musíte jako první v terminálu spustit:

ollama serve

Tím získáte výpis podobný tomuto:

time=2026-07-07T18:23:35.799+02:00 level=INFO source=routes.go:1332 msg="server config" env="map[CUDA_VISIBLE_DEVICES: GPU_DEVICE_ORDINAL: HIP_VISIBLE_DEVICES: HSA_OVERRIDE_GFX_VERSION: HTTPS_PROXY: HTTP_PROXY: NO_PROXY: OLLAMA_CONTEXT_LENGTH:4096 OLLAMA_DEBUG:INFO OLLAMA_FLASH_ATTENTION:false OLLAMA_GPU_OVERHEAD:0 OLLAMA_HOST:http://0.0.0.0:11434 OLLAMA_INTEL_GPU:false OLLAMA_KEEP_ALIVE:5m0s OLLAMA_KV_CACHE_TYPE: OLLAMA_LLM_LIBRARY: OLLAMA_LOAD_TIMEOUT:5m0s OLLAMA_MAX_LOADED_MODELS:0 OLLAMA_MAX_QUEUE:512 OLLAMA_MODELS:/lnet/work/projects/LLM/ollama OLLAMA_MULTIUSER_CACHE:false OLLAMA_NEW_ENGINE:false OLLAMA_NOHISTORY:false OLLAMA_NOPRUNE:false OLLAMA_NUM_PARALLEL:1 OLLAMA_ORIGINS:[http://localhost https://localhost http://localhost:* https://localhost:* http://127.0.0.1 https://127.0.0.1 http://127.0.0.1:* https://127.0.0.1:* http://0.0.0.0 https://0.0.0.0 http://0.0.0.0:* https://0.0.0.0:* app://* file://* tauri://* vscode-webview://* vscode-file://*] OLLAMA_SCHED_SPREAD:false ROCR_VISIBLE_DEVICES: http_proxy: https_proxy: no_proxy:]"
time=2026-07-07T18:23:35.880+02:00 level=INFO source=images.go:477 msg="total blobs: 148"
time=2026-07-07T18:23:35.918+02:00 level=INFO source=images.go:484 msg="total unused blobs removed: 0"
time=2026-07-07T18:23:35.920+02:00 level=INFO source=routes.go:1385 msg="Listening on [::]:11434 (version 0.11.11)"
time=2026-07-07T18:23:35.920+02:00 level=INFO source=gpu.go:217 msg="looking for compatible GPUs"
time=2026-07-07T18:23:35.976+02:00 level=INFO source=gpu.go:388 msg="no compatible GPUs were discovered"
time=2026-07-07T18:23:35.976+02:00 level=INFO source=types.go:131 msg="inference compute" id=0 library=cpu variant="" compute="" driver=0.0 name="" total="28.3 GiB" available="22.8 GiB"

Ehm, to že má být ta “uživatelská přívětivost”? No, řekněme, že tento log má v zásadě zůstat skrytý lidským očím. Důležité je, že služba běží a terminálové okno můžeme schovat, případně spustit proces/službu na pozadí.

(Pokud se při ollama serve vypsalo Error: listen tcp 127.0.0.1:11434: bind: address already in use, Ollama už na pozadí běží a můžete tento krok přeskočit.)

Teď už ale opravdu přichází ta uživatelsky přívětivá část. Celé rozjetí modelu je totiž otázkou jediného příkazu – Ollama ho při prvním spuštění stáhne a rovnou vás pustí do interaktivní konverzace.

Pro začátek doporučuji spustit nějaký malý, ale aspoň lehce schopný model. Doporučuju například SmolLM2 od Hugging Face (1.8 GB, běžný model) nebo Qwen3.5:0.8b (1 GB, reasoning model).

Nečekejte ale v tuto chvíli žádné zázraky a hlavně, nesnažte se na model mluvit česky:

Už vůbec pak na malý Qwen jako na reasoning model. Občas totiž při čtení thinking trace nevíte, jestli se smát, nebo plakat (ačkoliv možnost číst thinking trace je jinak jedna z velkých výhod lokálně provozovaných modelů):

Takto malé modely jsou dobré především pro rychlou kontrolu, že vše funguje jak má. Taky je super, že i na slabších počítačích běží relativně rychle. Pokud ale nepracujete se specializovaným modelem (finetune na konkrétní problém, embedovací model, apod.), tak z takto malých modelů moc použitelné výstupy nedostanete – a to ani v angličtině.

Pokud chcete stále ještě relativně malý, ale velmi schopný model, můžete zkusit například qwen3.6 nebo gemma4.

Co všechno Ollama umí?

Skvělá věc na Ollamě je dobře vyřešený management modelů.

O tom, které modely máte stažené, se můžete jednoduše ujistit příkazem ollama list:

$ ollama list
NAME              ID              SIZE      MODIFIED     
qwen3.5:0.8b      f3817196d142    1.0 GB    4 hours ago     
smollm2:latest    cef4a1e09247    1.8 GB    4 hours ago     
qwen3.6:35b       07d35212591f    23 GB     6 days ago      
gemma4:latest     c6eb396dbd59    9.6 GB    3 months ago    

Model stáhnete příkazem ollama pull <model_id> a smažete příkazem ollama rm <model_id>.

Id modelů najdete přímo na stránkách Ollamy. Tým Ollamy se stará o repozitáře hlavních modelů, takže například všechny varianty modelu Gemma 4 najdete přehledně na jednom místě.

Hodí se znát také příkaz ollama ps, který ukáže načtené modely a jejich alokaci na CPU/GPU:

$ ollama ps
NAME            ID              SIZE      PROCESSOR    CONTEXT    UNTIL              
qwen3.5:0.8b    f3817196d142    1.1 GB    100% CPU     4096       4 minutes from now 

Obecně se dá říct, že Ollama vyhrává na intuivitě.

Zároveň ale Ollama není jen hračka. Nabízí i API, přes které můžete s modely komunikovat v kódu. Tento formát asi nepřekvapí kohokoliv, kdo už používal přes API například OpenAI modely:

curl http://localhost:11434/api/chat -d '{
  "model": "gemma4",
  "messages": [
    {
      "role": "user",
      "content": "why is the sky blue?"
    }
  ]
}'

Ollama udržuje s OpenAI API částečnou kompatibilitu, stejně tak jako s Anthropic API. Pokud tedy uvažujete o “přesměrování” vašeho komerčního modelu, často opravdu stačí změnit endpoint za lokální.

API od Ollamy je ale o něco mocnější. Poskytne vám například řadu detailů o provozovaném modelu, možnost nastavit řadu generovacích parametrů, dá vám přístup k pravděpodobnostem vygenerovaných tokenů a vrátí vám reasoning trace. Podobně jako komerční poskytovatelé pak poskytuje základní strukturované výstupy pomocí JSON schématu.

Pár věcí ale přesto chybí. Ollama například neumí vrátit seznam nejpravděpodobnějších tokenů nebo aplikovat pokročilejší strukturované výstupy. Pokud tyto věci potřebujete, přeskočte rovnou na vLLM.

Na co si dávat pozor

Kvantizace

Ollama v základu modely kvantizuje. Ačkoliv zde seženete modely i ve standardní kvalitě (bf16 / fp16), musíte je stáhnout explicitně. V základu se vám u většiny modelů stáhne model ve 4- nebo 8-bitové kvantizaci.

To znamená, že modely budou mít 2-4x menší paměťové nároky, ale o něco horší výstupy:

Obzvlášť u malých modelů pozor na to, že jejich kvalita s agresivnější kvantizací degraduje rychleji, než u velkých modelů.

Tato strategie s kvantizováním dává smysl s tím, že Ollama cílí na spouštění modelů na osobních počítačích a low-end hardwaru obecně. Nepočítejte ale s tím, že když zavoláte ollama pull <základní_id_modelu>, že se vám stáhne model v plné kvalitě.

Nereplikovatelnost

S tím souvisí i fakt, že Ollama má svoji vlastní knihovnu modelů. Je proto potřeba dát pozor na to, že zdejší modely nemusejí zcela odpovídat svým ekvivalentům na Hugging Face.

Možná ještě větší vrásky při experimentování může nadělat fakt, že koncept “prostě to funguje” vede k tomu, že některé parametry jsou nastavené “chytře” na pozadí.

Například v základu je délka kontextu – tedy vstupu, který se do modelu vejde – nastavená na 4096 tokenů. To je v dnešní době fakt málo! Ano, ušetří to nějakou paměť a na jednoduché dotazy to stačí, ale pokud třeba model chcete používat jako agenta, tak už jen definice nástrojů většinou zaberou tisíce tokenů samy o sobě. Můžete to přepsat proměnnou prostředí OLLAMA_CONTEXT_LENGTH,případně to může přepsat model samotný ve svém Modelfile souboru, ale je jednoduché na to zapomenout.

Jiný detail, který jsem objevil při pokusu replikovat stejné výstupy modelů v Ollamě a vLLM, je to, že parametr repeat_penalty – jak moc penalizovat model za to, že se začíná opakovat – je nastavený na 1.1 – a ne na 1.0 (tedy bez penalizace), jak by člověk od takovéhoto parametru čekal. To může nenápadně ovlivnit výstup z modelu k lepšímu i horšímu, každopádně může to pěkně zavařit při nejednom debugování.

Agresivní unloading

Ollama také v základu drží model načtený pouze 5 minut. Pokud chcete, aby se model nemusel zbytečně znova načítat poté, co ho jednou načtete, musíte nastavit proměnnou OLLAMA_KEEP_ALIVE (případně odpovídají API parametr) na vyšší hodnotu.

Ollama a llama.cpp

Je dobré zmínit, že Ollama je z velké části wrapper nad knihovnou llama.cpp. Tato knihovna vznikla jako jeden z prvních inferenčních enginů pro lokální provoz otevřených LLM. Dodnes je jedna z nejodladěnějších a stojí na ní i řada dalších LLM frameworků. Jak už název napovídá, je napsaná v C/C++, což umožňuje vysoký výkon během inference. A protože inference je to hlavní, o co nám jde, tato knihovna odmaká většinu práce.

To na internetu budí jisté vášně. Lidem přijde, že Ollama krade slávu této knihovně, na níž odmakali open-source vývojáři velké množství práce. Najdete proto spousty důvodů, proč používat přímo knihovnu llama.cpp místo Ollamy.

Část kritiky je oprávněná. Jak už jsem zmínil, hlavní výhodou Ollamy je jednoduchost použití. Platíte za to občas trochu obskurními rozhodnutími tvůrců, které čas od času vyplavou na povrch. Rád bych se proto v některém z dalších postů pověnoval víc samotné knihovně llama.cpp.

Zároveň ale některé zmiňované problémy už jsou v Ollamě vyřešené. Ollama dává (i když nepříliš nápadně) knihovně llama.cpp kredit, externí modely v ní využívat lze, a jakmile si pohrajete s nastavením parametrů, můžete se dostat na stejný výkon. Management modelů v llama.cpp je pak trochu ošemetný a vyžaduje další knihovny jako llama-swap. Pořád proto platí, že na první vyzkoušení bych doporučil právě Ollamu.

Pokud navíc chcete model nasadit do provozu s velkým množstvím uživatelů, doporučil bych spíš vLLM, ke kterému se dostaneme v následující části.

vLLM: Zde začněte v produkci

Pro vLLM platí: “Tohle doma nezkoušejte.” Zatímco Ollama je knihovna “na takové to domácí žvýkání”, vLLM je dravec, který se snaží z hardwaru vymáčknout maximum.

Jde o knihovnu napsanou v Pythonu. Nenechte se ale mást: samotné výpočty běží přes odpovídající hardwarové knihovny (CUDA, ROCm, Apple Silicon, …).

Hlavní předností této knihovny je efektivní mechanismus na paralelní obsluhování velkého množství uživatelů. Tento mechanismus je postavený na technice PagedAttention, která umí efektivně zacházet s KV cache, tedy mezivýsledky, které si model drží pro už vygenerované tokeny.

Místo alokování monolitických bloků pro každý požadavek vLLM alokuje menší bloky a adresuje je na principu počítačové virtuální paměti:

Nejen, že je to efektivnější z hlediska uspořádání paměti, ale dokonce je i možné paměť sdílet mezi uživateli – například pro stejný systémový prompt.

vLLM je proto tou nejlepší volbou pro rozjíždění lokálních modelů ve chvíli, kdy víte, že k nim bude přistupovat více uživatelů zároveň.

Instalujeme a spouštíme vLLM

Instalace vLLM je překvapivě také jednoduchá.⁵ Jen abychom byli na stejné vlně: vLLM vyžaduje Linux. Beru, že na serverech, kde budete vLLM provozovat, je Linux samozřejmost. Kdyby náhodou to nebyl váš případ, moji ptáčci mi říkali, že už i v Microsoftu chápou, že vývoj na Linuxu jde mnohem líp. Vystačíte si s Pythonem a příkazem:

pip install vllm

Pozor, jednoduchá != rychlá. Počítejte, že závislostí má tento balíček spoustu (mimo jiné torch a transformers), takže i pokud používáte uv (což doporučuji), instalátor se trochu zapotí.

Po instalaci můžete vLLM používat ve dvou režimech: (1) offline a (2) online inference.

Offline inference

Offline inference dává smysl pro dávkové joby. Tento mód chcete využít například ve chvíli, když chcete spustit Python kód, který načte model a provede nad ním sérii experimentů.

Kód využívající vllm může vypadat nějak takto:

from vllm import LLM

def main():
    llm = LLM(model="Qwen/Qwen3.5-0.8B")
    
    conversations = [
        [{"role": "user", "content": "Kolik je 1+1?"}],
        [{"role": "user", "content": "Kolik je 2+2?"}],
    ]
    # vLLM zpracuje celou dávku najednou
    outputs = llm.chat(conversations)
    for output in outputs:
        print(output.outputs[0].text)

if __name__ == "__main__":
    main()

Je to jednoduché a intuitivní, jen počítejte s tím, že skript musí model při každém spuštění znovu načíst.

Online inference

Podobně jako u Ollamy můžete i spustit vLLM v režimu serveru. Protože to už s nasazením myslíme vážně, rozběhneme si na ukázku model GLM-5.2 v plné kvalitě (…pokud nemáte 1.5TB místa na disku, klidně zkuste nějaký menší):

vllm serve zai-org/GLM-5.2

vLLM žádnou vlastní knihovnu modelů nemá, modely pocházejí přímo z Hugging Face Hubu.

Načítání modelu opět nebude zrovna rychlé – počítejte s mnohem delší dobou než u Ollamy. Je to tím, že vLLM provádí řadu optimalizací už při startu– například předpočítává, jak co nejefektivněji obsloužit požadavky v různých velikostech batchí, aby ušetřil operace později za běhu.

To ukazuje celkem jasně filozofii vLLM: je to knihovna, která model načte jednou “pořádně” a pak už může klidně přijít velká nálož.

Dobře je to poznat na parametru gpu_memory_utilization, který je v základu je nastavený na 0.9. To znamená, že nehledě na velikost modelu vLLM využije 90% VRAM vaší GPU na jeho provoz. Když na stejné kartě běží ještě něco jiného (např. chcete rozjet dva modely), musíte s tím počítat.

Celkově má vLLM řadu parametrů, které je potřeba v produkci vyladit. V dokumentaci vLLM naleznete návod na šetření s pamětí, doporučuji projít i kompletní dokumentaci parametrů.

(Pozor na to, že v dokumentaci vLLM je notoricky těžké cokoliv najít. Externí vyhledávače mají zaindexované neaktuální verze, interní vyhledávač pak řadí výsledky prapodivně. Občas se proto budete muset na to správné místo v dokumentaci doklikat.)

Jakmile máte spuštěný server, můžete vLLM používat přes API. Server je kompatibilní s řadou běžně používaných API. Pokud používáte ve vašem kódu komerční modely, může tedy opět stačit vyměnit endpoint.

Pokročilé využití vLLM

Zde je pár tipů na věci, které vLLM umí.

Pravděpodobnosti tokenů

vLLM umí vrátit seznam nejpravděpodobnějších tokenů pro každý vygenerovaný token. Stačí v API requestu zaslat parametr logprobs, ve kterém specifikujete, kolik tokenů vás zajímá.

Tuto funkci jsem využil ve své výukové aplikaci AnimatedLLM, kde ukazuji sedm nejpravděpodobnějších tokenů, které model v každém kroku předpovídá.

Logits processor

Nejenže vLLM umí pravděpodobnosti vrátit, ale umí s nimi i pracovat. Pokud si například chcete napsat vlastní dekódovací algoritmus, můžete vytvořit podtřídu LogitsProcessor, která dostane seznam pravděpodobností a vybere z nich dekódovaný token.

Tuto funkcionalitu využil můj magisterský student, když jsme potřebovali napsat vlastní způsob dekódování strukturovaných výstupů.

Část ukázkového logits processoru může vypadat nějak takto:

class DummyLogitsProcessor(LogitsProcessor):
    """Fake logit processor to support unit testing and examples"""
    (...)
    def apply(self, logits: torch.Tensor) -> torch.Tensor:
        if not self.req_info:
            return logits

        # Save target values before modification
        cols = torch.tensor(
            list(self.req_info.values()), dtype=torch.long, device=logits.device
        )
        rows = torch.tensor(
            list(self.req_info.keys()), dtype=torch.long, device=logits.device
        )
        values_to_keep = logits[rows, cols].clone()

        # Mask all but target tokens
        logits[rows] = float('-inf')
        logits[rows, cols] = values_to_keep

        return logits

Pokročilé strukturované výstupy

Tím se dostáváme ke strukturovaným výstupům obecně. Toto téma si určitě zaslouží článek samo o sobě, ale prozatím zmíním, že vLLM v tomto ohledu poskytuje excelentní podporu.

Možnost omezit výstup na validní JSON už je takový “průmyslový standard” – podporu v tomto ohledu poskytuje i OpenAI, Anthropic a další.

vLLM ale dále umožňuje i omezit výstup na:

• možnost z předdefinovaného seznamu

completion = client.chat.completions.create(
    model=model,
    messages=[
        {"role": "user", "content": "Classify this sentiment: vLLM is wonderful!"}
    ],
    extra_body={"structured_outputs": {"choice": ["positive", "negative"]}},

• regulární výraz

completion = client.chat.completions.create(
    model=model,
    messages=[
        {
            "role": "user",
            "content": "Generate an example email address for Alan Turing, who works in Enigma. End in .com and new line. Example result: alan.turing@enigma.com\n",
        }
    ],
    extra_body={"structured_outputs": {"regex": r"\w+@\w+\.com\n"}, "stop": ["\n"]},
)

• bezkontextovou gramatiku v EBNF formě

simplified_sql_grammar = """
    root ::= select_statement

    select_statement ::= "SELECT " column " from " table " where " condition

    column ::= "col_1 " | "col_2 "

    table ::= "table_1 " | "table_2 "

    condition ::= column "= " number

    number ::= "1 " | "2 "
"""

completion = client.chat.completions.create(
    model=model,
    messages=[
        {
            "role": "user",
            "content": "Generate an SQL query to show the 'username' and 'email' from the 'users' table.",
        }
    ],
    extra_body={"structured_outputs": {"grammar": simplified_sql_grammar}},
)
print(completion.choices[0].message.content)

Podobné možnosti přináší i řada specializovaných knihoven, ale vLLM v tomhle ohledu přichází s “batteries included”.

Anonymní model

Perlička na závěr: vLLM umožňuje specifikovat parametr --served-model-name, který určuje, jak se bude provozovaný model nazývat v API. Můžete si ho tedy pojmenovat například default a díky tomu měnit model, který provozujete, aniž byste museli měnit kód, který model volá.

To může být samozřejmě trochu “dark pattern” – uživatelům měnit modely pod rukama obecně nechceme. Najdou se pro to ale i legitimní využití, zvlášť pokud vLLM používáte nad vlastním kódem. (Já jsem tuto funkcionalitu využil jako zábavný sidequest pro studenty, kdy měli při volání neznámého modelu přes API zjistit jeho identifikátor čistě pomocí promptování 😁)⁶ Zjistili jsme díky tomu, že Qwen modely se rády identifikují jako “ChatGPT”. Náhoda?

Závěrem

Tento článek jistě není vyčerpávající: rád se dozvím nějaké tipy od vás. Dejte vědět na Discordu a třeba se k nim dostaneme někdy příště!