Llama Stack: framework pro tvorbu aplikací s generativní AI

Obsah

1. Llama Stack: framework pro tvorbu aplikací s generativní AI

2. Framework Llama Stack se představuje

3. Příprava projektu pro spuštění a otestování Llama Stacku

4. Přidání všech potřebných závislostí do projektu

5. Kontrola, zda instalace Llama Stacku dopadla úspěšně

6. Nejjednodušší funkční konfigurace Llama Stacku

7. První spuštění Llama Stacku

8. REST API Llama Stacku

9. Přístup ke stacku z aplikací psaných v Pythonu

10. Jednoduchý klient komunikující se stackem

11. Úplný zdrojový kód klienta

12. Spuštění klienta

13. Klient zjišťující, které LLM modely je možné využít

14. Použití Llama Stacku v roli Pythonní knihovny (bez serveru)

15. Úplný zdrojový kód třetí verze klienta

16. Spuštění třetí verze klienta

17. Další možnosti konfigurace stacku

18. Příloha: seznam poskytovatelů (providers)

19. Repositář s demonstračními příklady

20. Odkazy na Internetu

1. Llama Stack: framework pro tvorbu aplikací s generativní AI

Pravděpodobně naprostá většina lidí, kteří se pohybují v oblasti informatiky, zaznamenali revoluci, kterou v posledních dvou či tří letech přinesla generativní umělá inteligence (generative AI). V současnosti se zdá, že prakticky každá nová verze většiny aplikací je vybavena více či méně sofistikovanou umělou inteligencí, což pochopitelně přináší jak klady, tak i zápory (které mnohdy převažují nad klady, což je však téma na samostatný článek). A pochopitelně nastala situace běžná v celém IT: společně s rozvojem generativní AI (nejvíce pak velkých jazykových modelů neboli LLM) vzniklo i velké množství knihoven a frameworků určených pro vývoj aplikací vybavených nějakou formou AI, přičemž mnohdy nejsou tyto knihovny rozšiřitelné, mají mnoho chyb, nepodporují všechny potřebné vlastnosti (z poslední doby agent-to-agent neboli A2A) apod.

Abychom si ukázali, jak je situace okolo generativní AI (a LLM) rozsáhlá a chaotická, podívejme se pouze na oblast velkých jazykových modelů (což je podmnožina generativní AI) a navíc se omezme jen na ekosystém programovacího jazyka Python. Zde se můžeme se setkat s velkou řadou knihoven a frameworků, zejména pak:

1. LangChain
2. langgraph
3. autogen
4. metaGPT
5. phidata
6. CrewAI
7. pydanticAI
8. controlflow
9. langflow
10. LiteLLM
11. Llama Stack

2. Framework Llama Stack se představuje

V seznamu, který byl uveden v předchozí kapitole, nalezneme jak knihovny (příkladem může být LangChain), tak i více či méně sofistikované frameworky. A právě jedním z frameworků určených pro tvorbu aplikací, které v nějaké míře využívají generativní AI, je i framework nazvaný Llama Stack, za jehož vývojem stojí firma Meta společně s dalšími přispěvateli (což jsou jak firmy, tak i jednotlivci). Tento framework je možné využít několika způsoby. Buď je možné celý stack (tj. různé moduly) spustit jako samostatný server, k němuž je možné se připojit vhodně nakonfigurovaným klientem, nebo se Llama Stack použije jako běžná knihovna a výsledkem tak bude aplikace, která bude celý stack obsahovat (ve skutečnosti může být celá konfigurace ještě složitější, k tomuto tématu se ještě později vrátíme).

Samotný Llama Stack je skutečně jen „pouhým“ frameworkem, který je však poměrně jednoduše rozšiřitelný o další pluginy, které se nazývají poskytovatelé neboli anglicky providers. V navazujících kapitolách si ukážeme realizaci jednoduchého chatu (podobného ChatGPT atd.), který vyžaduje konfiguraci minimálně dvou poskytovatelů. V první řadě se jedná o poskytovatele vlastního inference serveru, v našem případě konkrétně OpenAI. A druhým poskytovatelem, kterého nakonfigurujeme, je poskytovatel pro telemetrii, logování a trasování (ten je nutné nakonfigurovat minimálně proto, aby se vypisovaly logovací informace). To znamená, že náš stack může vypadat takto:

providers:
  inference:
    - konfigurace poskytovatele
  telemetry:
    - konfigurace poskytovatele

Konkrétně pro OpenAI a logování:

providers:
  inference:
    - provider_id: openai
      provider_type: remote::openai
      config:
        api_key: ${env.OPENAI_API_KEY}
  telemetry:
    - provider_id: meta-reference
      provider_type: inline::meta-reference
      config:
        sinks: ['console']

3. Příprava projektu pro spuštění a otestování Llama Stacku

Dnešní článek je zaměřen spíše prakticky, což znamená, že se v něm seznámíme se základním způsobem využití Llama Stacku. V prvním kroku si musíme nechat vytvořit kostru projektu, který postupně upravíme do finální podoby. Pro správu projektů využijeme nástroj PDM, který byl popsán v článku PDM: moderní správce balíčků a virtuálních prostředí Pythonu (ovšem stejně dobře můžete použít i klasický pip zkombinovaný s venv nebo virtualenv; velmi dobrou alternativou je pak uv).

Nejprve si nainstalujte samotné PDM:

$ pip install --user pdm

Otestujeme, že je příkaz pdm dostupný:

$ pdm --version
 
PDM, version 2.22.2

Kostra nového projektu se vytvoří příkazem:

$ pdm init

Po zadání tohoto příkazu se systém PDM zeptá na několik otázek. Odpovědi, které musí poskytnou programátor, jsou zvýrazněny tučným písmem:

Creating a pyproject.toml for PDM...
Please enter the Python interpreter to use
 0. cpython@3.12 (/usr/bin/python)
 1. cpython@3.13 (/usr/bin/python3.13)
 2. cpython@3.12 (/usr/bin/python3.12)
 3. cpython@3.11 (/usr/bin/python3.11)
Please select (0): 0
Virtualenv is created successfully at /tmp/ramdisk/llama-stack-demo/.venv
Project name (llama-stack-demo):  [Enter]
Project version (0.1.0):  [Enter]
Do you want to build this project for distribution(such as wheel)?
If yes, it will be installed by default when running `pdm install`. [y/n] (n):  [Enter]
License(SPDX name) (MIT):  [Enter]
Author name (Pavel Tisnovsky):  [Enter]
Author email (tisnik@nowhere.com):  [Enter]
Python requires('*' to allow any) (==3.12.*):  [Enter]
Project is initialized successfully

Výsledkem výše uvedeného kroku by měl být projektový soubor nazvaný pyproject.toml s následujícím obsahem:

[project]
name = "llama-stack-demo"
version = "0.1.0"
description = "Default template for PDM package"
authors = [
    {name = "Pavel Tisnovsky", email = "tisnik@nowhere.com"},
]
dependencies = []
requires-python = "==3.12.*"
readme = "README.md"
license = {text = "MIT"}
 
 
[tool.pdm]
distribution = false

requires-python = ">=3.11.1,<=3.12.10"

4. Přidání všech potřebných závislostí do projektu

V dalším kroku je nutné do projektu přidat další závislosti, mezi které patří samotný Llama stack a taktéž balíčky používané při volání LLM atd. Prozatím použijeme „uzamčenou“ verzi Llama stacku 0.2.8 a teprve později tuto verzi zvýšíme. Llama stack se totiž poměrně bouřlivě vyvíjí a i přechod (například) mezi 0.2.8 a 0.2.10 způsobuje nekompatibility (vítejte ve světě Pythonu+AI).

$ pdm add llama-stack==0.2.8 fastapi opentelemetry-sdk opentelemetry-exporter-otlp opentelemetry-instrumentation aiosqlite litellm uvicorn blobfile

Průběh instalace do virtuálního prostředí Pythonu:

Adding packages to default dependencies: llama-stack==0.2.8, fastapi, opentelemetry-sdk, opentelemetry-exporter-otlp,
opentelemetry-instrumentation, aiosqlite, litellm, uvicorn
  0:01:51 🔒 Lock successful.
Changes are written to pyproject.toml.
Synchronizing working set with resolved packages: 87 to add, 0 to update, 0 to remove
 
  ✔ Install setuptools 80.9.0 successful
  ✔ Install annotated-types 0.7.0 successful
  ✔ Install distro 1.9.0 successful
  ✔ Install click 8.2.1 successful
  ✔ Install h11 0.16.0 successful
  ...
  ...
  ...
  ✔ Install multidict 6.4.4 successful
  ✔ Install tokenizers 0.21.1 successful
  ✔ Install pillow 11.2.1 successful
  ✔ Install numpy 2.2.6 successful
  ✔ Install rpds-py 0.25.1 successful
  ✔ Install yarl 1.20.0 successful
  ✔ Install regex 2024.11.6 successful
  ✔ Install grpcio 1.72.1 successful
  ✔ Install pydantic-core 2.33.2 successful
  ✔ Install aiohttp 3.12.9 successful
 
  0:01:29 🎉 All complete! 87/87

Nyní by měl projektový soubor pyproject.toml vypadat následovně:

[project]
name = "llama-stack-demo"
version = "0.1.0"
description = "Default template for PDM package"
authors = [
    {name = "Pavel Tisnovsky", email = "tisnik@nowhere.com"},
]
dependencies = [
    "llama-stack==0.2.8",
    "fastapi>=0.115.12",
    "opentelemetry-sdk>=1.34.0",
    "opentelemetry-exporter-otlp>=1.34.0",
    "opentelemetry-instrumentation>=0.55b0",
    "aiosqlite>=0.21.0",
    "litellm>=1.72.1",
    "uvicorn>=0.34.3",
    "blobfile>=3.0.0"]
requires-python = "==3.12.*"
readme = "README.md"
license = {text = "MIT"}
 
 
[tool.pdm]
distribution = false

5. Kontrola, zda instalace Llama Stacku dopadla úspěšně

V dalším kroku si ověříme, že je možné spustit nástroj nazvaný llama. Ten byl nainstalován do virtuálního prostředí Pythonu a proto ho musíme spouštět přes pdm run:

$ pdm run llama

Pokud instalace proběhla úspěšně, měly by se na terminál vypsat následující zprávy:

usage: llama [-h] {model,stack,download,verify-download} ...
 
Welcome to the Llama CLI
 
options:
  -h, --help            show this help message and exit
 
subcommands:
  {model,stack,download,verify-download}
 
  model                 Work with llama models
  stack                 Operations for the Llama Stack / Distributions
  download              Download a model from llama.meta.com or Hugging Face Hub
  verify-download       Verify integrity of downloaded model files

6. Nejjednodušší funkční konfigurace Llama Stacku

V případě, že se pokusíme spustit Llama Stack bez jeho konfigurace, vypíše se pouze informace o výjimce (což tedy není příliš uživatelsky příjemné):

$ pdm run llama stack run
 
INFO     2025-06-27 14:36:57,618 llama_stack.cli.stack.run:146 server: No image type or image name provided. Assuming
         environment packages.
Traceback (most recent call last):
  File "/tmp/ramdisk/llama-stack-demo/demo1/.venv/bin/llama", line 10, in <module>
    sys.exit(main())
             ^^^^^^
  File "/tmp/ramdisk/llama-stack-demo/demo1/.venv/lib/python3.12/site-packages/llama_stack/cli/llama.py", line 53, in main
    parser.run(args)
  File "/tmp/ramdisk/llama-stack-demo/demo1/.venv/lib/python3.12/site-packages/llama_stack/cli/llama.py", line 47, in run
    args.func(args)
  File "/tmp/ramdisk/llama-stack-demo/demo1/.venv/lib/python3.12/site-packages/llama_stack/cli/stack/run.py", line 160, in _run_stack_run_cmd
    server_main(server_args)
  File "/tmp/ramdisk/llama-stack-demo/demo1/.venv/lib/python3.12/site-packages/llama_stack/distribution/server/server.py", line 399, in main
    elif args.template:
         ^^^^^^^^^^^^^
AttributeError: 'Namespace' object has no attribute 'template'

Aby bylo možné Llama Stack skutečně spustit a provozovat, musíme si náš „stack“ vhodným způsobem nakonfigurovat. Prozatím si vystačíme s velmi jednoduchou konfigurací, která bude mít specifikované pouze dva poskytovatele (providers), konkrétně poskytovatele, který bude na konzoli vypisovat telemetrické informace a dále poskytovatele s LLM, konkrétně s rozhraním pro OpenAI (ale můžeme použít i další poskytovatele LLM, například Azure Open AI, Gemini, WatsonX, lokálně běžící LLM atd. atd.). Povšimněte si, že je v konfiguračním souboru možné specifikovat i to, že některá volba (zde konkrétně přístupový klíč k OpenAI) bude načtena z proměnné prostředí:

version: '2'
image_name: simplest-llama-stack-configuration
container_image: null
 
distribution_spec:
  local:
    services:
      - inference
      - telemetry
 
apis:
  - inference
  - telemetry
 
providers:
  inference:
    - provider_id: openai
      provider_type: remote::openai
      config:
        api_key: ${env.OPENAI_API_KEY}
  telemetry:
    - provider_id: meta-reference
      provider_type: inline::meta-reference
      config:
        sinks: ['console']
 
models:
  - model_id: gpt-4-turbo
    provider_id: openai
    model_type: llm
    provider_model_id: gpt-4-turbo
 
server:
  port: 8321

Tato konfigurace předpokládá, že ještě před vlastním spuštěním serveru dojde k nastavení klíče pro OpenAI do proměnné prostředí nazvané OPENAI_API_KEY. Toto nastavení bude vypadat následovně:

$ export OPENAI_API_KEY="sk-xyzzy1234567890xyzzy1234567890xyzzy1234567890..."

7. První spuštění Llama Stacku

Nyní, když již máme připraven konfigurační soubor pro náš stack, je možné spustit server s tímto stackem. Pro tento účel použijeme příkaz:

$ pdm run llama stack run run.yaml

Konfigurace je korektní (nebo by alespoň měla být korektní), takže by se nejprve měly vypsat informace o načítání konfiguračního souboru a následně i aktuální konfigurace celého serveru:

INFO     2025-06-06 10:51:57,634 llama_stack.cli.stack.run:125 server: Using run configuration: run.yaml
INFO     2025-06-06 10:51:57,640 llama_stack.cli.stack.run:146 server: No image type or image name provided. Assuming
         environment packages.
INFO     2025-06-06 10:51:58,282 llama_stack.distribution.server.server:422 server: Using config file: run.yaml
INFO     2025-06-06 10:51:58,285 llama_stack.distribution.server.server:424 server: Run configuration:
INFO     2025-06-06 10:51:58,290 llama_stack.distribution.server.server:426 server: apis:
         - inference
         - telemetry
         benchmarks: []
         container_image: null
         datasets: []
         external_providers_dir: null
         image_name: simplest-llama-stack-configuration
         inference_store: null
         logging: null
         metadata_store: null
         models:
         - metadata: {}
           model_id: gpt-4-turbo
           model_type: !!python/object/apply:llama_stack.apis.models.models.ModelType
           - llm
           provider_id: openai
           provider_model_id: gpt-4-turbo
         providers:
           inference:
           - config:
               api_key: '********'
             provider_id: openai
             provider_type: remote::openai
           telemetry:
           - config:
               sinks:
               - console
             provider_id: meta-reference
             provider_type: inline::meta-reference
         scoring_fns: []
         server:
           auth: null
           host: null
           port: 8321
           quota: null
           tls_cafile: null
           tls_certfile: null
           tls_keyfile: null
         shields: []
         tool_groups: []
         vector_dbs: []
         version: '2'
 
INFO     2025-06-06 10:52:00,166 llama_stack.distribution.server.server:564 server: Listening on ['::', '0.0.0.0']:8321
INFO     2025-06-06 10:52:00,176 llama_stack.distribution.server.server:156 server: Starting up
INFO:     ::1:57018 - "GET /v1/models HTTP/1.1" 200 OK

8. REST API Llama Stacku

Server naslouchá na portu 8321. K dispozici je popis REST API dostupný ve formě OpenAPI (endpoint /openapi.json), ovšem využít lze i další endpointy. Například endpoint /v1/models vrací seznam AI modelů, včetně námi nakonfigurovaného LLM modelu OpenAI:

$ curl localhost:8321/v1/models
 
{"data":[{"identifier":"gpt-4-turbo","provider_resource_id":"gpt-4-turbo","provider_id":"openai","type":"model","metadata":{},"model_type":"llm"}]}

Podrobnější informace modelech, ale v čitelné podobně:

$ curl localhost:8321/v1/models | jq .
 
{
  "data": [
    {
      "identifier": "gpt-4-turbo",
      "provider_resource_id": "gpt-4-turbo",
      "provider_id": "openai",
      "type": "model",
      "metadata": {},
      "model_type": "llm"
    }
  ]
}

Informace o OpenAI modelech. My máme nakonfigurován pouze model gpt-4-turbo, takže se vrátí pole s jediným prvkem:

$ curl localhost:8321/v1/openai/v1/models | jq .
 
{
  "data": [
    {
      "id": "gpt-4-turbo",
      "object": "model",
      "created": 1751115324,
      "owned_by": "llama_stack"
    }
  ]
}

Získání informace o verzi samotného Llama Stacku:

$ curl localhost:8321/v1/version | jq .
 
{
  "version": "0.2.8"
}

Popř. se selektorem:

$ curl localhost:8321/v1/version | jq .version
 
"0.2.8"

V posledním příkladu zjistíme, zda je vše v pořádku:

$ curl localhost:8321/v1/health | jq .
 
{
  "status": "OK"
}

9. Přístup ke stacku z aplikací psaných v Pythonu

Teoreticky je možné spustit stack způsobem naznačeným výše a přistupovat k němu přes REST API. Ovšem namísto přímé komunikace přes REST API (a formát JSON) existuje ještě lepší alternativa. Ta je založena na takzvaném Llama Stack Clientovi. Jedná se o knihovnu dostupnou pro Python, Swift, Node.js nebo Kotlin (mimochodem: zajímavý výběr jazyků), která REST API stacku vhodným způsobem „obaluje“, což je pro mnoho aplikací jednodušší. V navazujících kapitolách si ukážeme, jak může takový klient vypadat. Uvidíme, že se nejedná o nijak komplikovanou technologii, spíš naopak.

Všechny ukázky budou naprogramovány v Pythonu, ovšem jejich přepis do ostatních zmíněných jazyků není příliš komplikovaný, protože jména tříd a jejich metod jsou podobná či dokonce stejná.

10. Jednoduchý klient komunikující se stackem

Podívejme se nyní na způsob realizace velmi jednoduchého klienta naprogramovaného v Pythonu. Nejprve musíme pochopitelně naimportovat modul, který zprostředkovává spojení se stackem. Tento modul se jmenuje LlamaStackClient:

from llama_stack_client import LlamaStackClient

Dále se pokusíme o připojení k běžícímu stacku. Víme, že je dostupný na portu 8321, takže spojení realizujeme snadno:

client = LlamaStackClient(base_url="http://localhost:8321")

V této chvíli je již možné se stackem komunikovat a například zjistit verzi frameworku Llama Stack:

print(f"Using Llama Stack version {client._version}")

Ovšem užitečnější je navázání (nepřímé) komunikace se zvoleným LLM modelem, poslání otázky do modelu a přečtení jeho odpovědi. V následujícím kódu se do LLM pošle tento text:

PROMPT = "Say Hello"

V kódu vybereme první (a jediný nakonfigurovaný) model a pošleme dotaz:

response = client.inference.chat_completion(
    messages=[{"role": "user", "content": PROMPT}],
    model_id=client.models.list()[0].identifier,
)

Odpověď je uložena v proměnné response. Kromě metadat zde nalezneme i vlastní odpověď LLM modelu, kterou můžeme vypsat či jinak zpracovat:

text = response.completion_message.content
print(f"LLM response: {text}")

11. Úplný zdrojový kód klienta

Úplný zdrojový kód klienta popsaného v předchozí kapitole vypadá následovně:

from llama_stack_client import LlamaStackClient
 
PROMPT = "Say Hello"
 
client = LlamaStackClient(base_url="http://localhost:8321")
 
print(f"Using Llama Stack version {client._version}")
 
response = client.inference.chat_completion(
    messages=[{"role": "user", "content": PROMPT}],
    model_id=client.models.list()[0].identifier,
)
 
text = response.completion_message.content
print(f"LLM response: {text}")

12. Spuštění klienta

Předpokládejme, že náš stack již běží a je dostupný na portu 8321. V této situaci můžeme spustit klienta, který bude s tímto stackem komunikovat – pošle otázku do LLM a zobrazí obdrženou odpověď. Klienta budeme muset spustit ve virtuálním prostředí Pythonu; konkrétně použijeme (opět) správce projektů PDM:

$ pdm run client1.py

Na terminálu by se měly postupně objevit čtyři informace:

1. Verze Llama stacku
2. Logovací informace o tom, že se přes REST API zjistil seznam dostupných modelů
3. Logovací informace o tom, že se prvnímu vybranému modelu poslal dotaz
4. Odpověď LLM serveru

Konkrétně bude terminál obsahovat tyto čtyři řádky:

Using Llama Stack version 0.2.10
INFO:httpx:HTTP Request: GET http://localhost:8321/v1/models "HTTP/1.1 200 OK"
INFO:httpx:HTTP Request: POST http://localhost:8321/v1/inference/chat-completion "HTTP/1.1 200 OK"
LLM response: Hello! How can I assist you today?

Na straně stacku se taktéž objeví množství logovacích informací:

INFO     2025-06-06 10:52:24,555 LiteLLM:3043 uncategorized:
         LiteLLM completion() model= gpt-4-turbo; provider = openai
INFO     2025-06-06 10:52:26,027 LiteLLM:1215 uncategorized: Wrapper: Completed Call, calling success_handler
INFO     2025-06-06 10:52:26,030 LiteLLM:655 uncategorized: selected model name for cost calculation:
         openai/gpt-4-turbo-2024-04-09
INFO     2025-06-06 10:52:26,033 LiteLLM:655 uncategorized: selected model name for cost calculation:
         openai/gpt-4-turbo-2024-04-09
INFO     2025-06-06 10:52:26,037 LiteLLM:655 uncategorized: selected model name for cost calculation:
         openai/gpt-4-turbo-2024-04-09
INFO:     ::1:57018 - "POST /v1/inference/chat-completion HTTP/1.1" 200 OK
[2m08:52:26.046[0m [35m[END][0m [2m/v1/inference/chat-completion[0m[0m [StatusCode.OK][0m (1501.47ms)
INFO     2025-06-06 10:52:40,419 llama_stack.distribution.server.server:158 server: Shutting down
INFO     2025-06-06 10:52:40,422 llama_stack.distribution.server.server:142 server: Shutting down TelemetryAdapter
INFO     2025-06-06 10:52:40,423 llama_stack.distribution.server.server:142 server: Shutting down ModelsRoutingTable
INFO     2025-06-06 10:52:40,425 llama_stack.distribution.server.server:142 server: Shutting down InferenceRouter
INFO     2025-06-06 10:52:40,427 llama_stack.distribution.server.server:142 server: Shutting down
         DistributionInspectImpl
INFO     2025-06-06 10:52:40,428 llama_stack.distribution.server.server:142 server: Shutting down ProviderImpl

13. Klient zjišťující, které LLM modely je možné využít

Druhý klient, který komunikuje se stackem, zjišťuje všechny LLM modely, které je možné využít pro inferenci (zjednodušeně řečeno: dotazy a odpovědi). Ve skutečnosti se vypíšou všechny dostupné modely, nejenom LLM

from llama_stack_client import LlamaStackClient
 
client = LlamaStackClient(base_url="http://localhost:8321")
 
print(f"Using Llama Stack version {client._version}")
 
models = client.models.list()
 
for model in models:
    print(model)

Výsledek by měl vypadat zhruba následovně (pouze jsem ho naformátoval pro větší čitelnost):

Model(
    identifier='gpt-4-turbo',
    metadata={},
    api_model_type='llm',
    provider_id='openai',
    type='model',
    provider_resource_id='gpt-4-turbo',
    model_type='llm'
)

14. Použití Llama Stacku v roli Pythonní knihovny (bez serveru)

V předchozích kapitolách jsme si ukázali, jakým způsobem je možné komunikovat se stackem, který běží v samostatném procesu. Ovšem existují situace, v nichž není vhodné spouštět dva procesory (jeden se stackem, druhý s klientem). V těchto případech je možné stack spustit přímo v rámci klientské aplikace. Namísto třídy LlamaStackClient se v tomto případě musí použít třída LlamaStackAsLibraryClient a vlastní inicializace je tedy pochopitelně odlišná – nemusí se zadávat host a port, ale naopak cesta ke konfiguračnímu souboru:

class LlamaStackAsLibraryClient(llama_stack_client.LlamaStackClient)
 |  LlamaStackAsLibraryClient(config_path_or_template_name: str, skip_logger_removal: bool = False, custom_provider_registry: dict[llama_stack.apis.datatypes.Api, dict[str, llama_stack.providers.datatypes.ProviderSpec]] | None = None, provider_data: dict[str, typing.Any] | None = None)
 |
 |  Method resolution order:
 |      LlamaStackAsLibraryClient
 |      llama_stack_client.LlamaStackClient
 |      llama_stack_client._base_client.SyncAPIClient
 |      llama_stack_client._base_client.BaseClient
 |      typing.Generic
 |      builtins.object

Ukázka bude uvedena v navazující kapitole.

15. Úplný zdrojový kód třetí verze klienta

Realizace klienta, který pro svůj běh nebude potřebovat samostatně běžící stack, ale naopak vše bude realizovat v rámci jediného procesu, vypadá následovně. Povšimněte si, že namísto připojení ke stacku musíme pouze zkonstruovat instanci třídy LlamaStackAsLibraryClient s předáním konfiguračního souboru a následně pouze provést inicializaci. Další práce se stackem je již totožná s konfigurací, kdy stack běžel jako samostatný server:

from llama_stack.distribution.library_client import LlamaStackAsLibraryClient
from llama_stack_client import LlamaStackClient
 
client = LlamaStackAsLibraryClient("run.yaml")
client.initialize()
 
print(f"Using Llama Stack version {client._version}")
 
models = client.models.list()
 
for model in models:
    print(model)

16. Spuštění třetí verze klienta

Klienta, jehož zdrojový kód byl ukázán v předchozí kapitole, spustíme příkazem:

$ pdm run client3.py

Nejprve by se měla vypsat konfigurace stacku, která byla načtena z konfiguračního souboru:

Using config run.yaml:
apis:
- inference
- telemetry
benchmarks: []
container_image: null
datasets: []
external_providers_dir: null
image_name: simplest-llama-stack-configuration
inference_store: null
logging: null
metadata_store: null
models:
- metadata: {}
  model_id: gpt-4-turbo
  model_type: !!python/object/apply:llama_stack.apis.models.models.ModelType
  - llm
  provider_id: openai
  provider_model_id: gpt-4-turbo
providers:
  inference:
  - config:
      api_key: '********'
    provider_id: openai
    provider_type: remote::openai
  telemetry:
  - config:
      sinks:
      - console
    provider_id: meta-reference
    provider_type: inline::meta-reference
scoring_fns: []
server:
  auth: null
  host: null
  port: 8321
  quota: null
  tls_cafile: null
  tls_certfile: null
  tls_keyfile: null
shields: []
tool_groups: []
vector_dbs: []
version: '2'

Následně se provede kód klienta, tedy výpis verze Llama Stacku a seznam dostupných modelů:

Using Llama Stack version 0.2.10
Model(identifier='gpt-4-turbo', metadata={}, api_model_type='llm', provider_id='openai', type='model', provider_resource_id='gpt-4-turbo', model_type='llm')

17. Další možnosti konfigurace stacku

Konfigurace stacku může být i poměrně komplikovaná. V navazujícím článku si například popíšeme následující konfiguraci, která je mj. použitá v reálně nasaditelné službě:

version: '2'
image_name: simplest-llamastack-app
 
apis:
  - agents
  - datasetio
  - eval
  - inference
  - post_training
  - safety
  - scoring
  - telemetry
  - tool_runtime
  - vector_io
benchmarks: []
container_image: null
datasets: []
external_providers_dir: null
inference_store:
  db_path: /home/ptisnovs/.llama/distributions/ollama/inference_store.db
  type: sqlite
logging: null
metadata_store:
  db_path: /home/ptisnovs/.llama/distributions/ollama/registry.db
  namespace: null
  type: sqlite
providers:
  agents:
  - config:
      persistence_store:
        db_path: /home/ptisnovs/.llama/distributions/ollama/agents_store.db
        namespace: null
        type: sqlite
      responses_store:
        db_path: /home/ptisnovs/.llama/distributions/ollama/responses_store.db
        type: sqlite
    provider_id: meta-reference
    provider_type: inline::meta-reference
  datasetio:
  - config:
      kvstore:
        db_path: /home/ptisnovs/.llama/distributions/ollama/huggingface_datasetio.db
        namespace: null
        type: sqlite
    provider_id: huggingface
    provider_type: remote::huggingface
  - config:
      kvstore:
        db_path: /home/ptisnovs/.llama/distributions/ollama/localfs_datasetio.db
        namespace: null
        type: sqlite
    provider_id: localfs
    provider_type: inline::localfs
  eval:
  - config:
      kvstore:
        db_path: /home/ptisnovs/.llama/distributions/ollama/meta_reference_eval.db
        namespace: null
        type: sqlite
    provider_id: meta-reference
    provider_type: inline::meta-reference
  inference:
    - provider_id: openai
      provider_type: remote::openai
      config:
        api_key: ${env.OPENAI_API_KEY}
  post_training:
  - config:
      checkpoint_format: huggingface
      device: cpu
      distributed_backend: null
    provider_id: huggingface
    provider_type: inline::huggingface
  safety:
  - config:
      excluded_categories: []
    provider_id: llama-guard
    provider_type: inline::llama-guard
  scoring:
  - config: {}
    provider_id: basic
    provider_type: inline::basic
  - config: {}
    provider_id: llm-as-judge
    provider_type: inline::llm-as-judge
  - config:
      openai_api_key: '********'
    provider_id: braintrust
    provider_type: inline::braintrust
  telemetry:

18. Příloha: seznam poskytovatelů (providers)

V této příloze je uveden seznam oficiálně podporovaných poskytovatelů (providers):

19. Repositář s demonstračními příklady

Projekty popsané v předchozích kapitolách je možné nalézt v repositáři https://github.com/tisnik/most-popular-python-libs. Následují odkazy na jednotlivé soubory s jejich stručným popisem:

První projekt: volání LLM modelu přes stack

Druhý projekt: výpis všech dostupných modelů

Třetí projekt: využití Llama Stacku jako Pythonní knihovny

20. Odkazy na Internetu

1. llama-stack na GitHubu
   https://github.com/meta-llama/llama-stack
2. llama-stack na PyPi
   https://pypi.org/project/llama-stack/
3. Configuring a „Stack“
   https://llama-stack.readthedocs.io/en/la­test/distributions/configu­ration.html#
4. Generativní umělá inteligence
   https://cs.wikipedia.org/wi­ki/Generativn%C3%AD_um%C4%9Bl%C3%A1_­inteligence
5. Generative artificial intelligence
   https://en.wikipedia.org/wi­ki/Generative_artificial_in­telligence
6. Generativní AI a LLM: ®evoluce v umělé inteligenci?
   https://www.itbiz.cz/clan­ky/generativni-ai-a-llm-revoluce-v-umele-inteligenci/
7. langchain
   https://python.langchain.com/doc­s/introduction/
8. langgraph
   https://github.com/langchain-ai/langgraph
9. autogen
   https://github.com/microsoft/autogen
10. metaGPT
    https://github.com/geekan/MetaGPT
11. phidata
    https://github.com/phidatahq/phidata
12. CrewAI
    https://github.com/crewAIInc/crewAI
13. pydanticAI
    https://github.com/pydantic/pydantic-ai
14. controlflow
    https://github.com/Prefec­tHQ/ControlFlow
15. langflow
    https://github.com/langflow-ai/langflow
16. LiteLLM
    https://github.com/BerriAI/litellm
17. Llama Stack
    https://github.com/meta-llama/llama-stack
18. uv
    https://docs.astral.sh/uv/
19. Python na Root.cz
    https://www.root.cz/n/python/
20. PDM: moderní správce balíčků a virtuálních prostředí Pythonu
    https://www.root.cz/clanky/pdm-moderni-spravce-balicku-a-virtualnich-prostredi-pythonu/
21. YAML
    https://en.wikipedia.org/wiki/YAML
22. Top 11 LLM API Providers in 2025
    https://www.helicone.ai/blog/llm-api-providers
23. Zpracování dat reprezentovaných ve formátu JSON nástrojem jq
    https://www.root.cz/clanky/zpracovani-dat-reprezentovanych-ve-formatu-json-nastrojem-jq/
24. LLama Stack SDK pro jazyk Python
    https://github.com/meta-llama/llama-stack-client-python
25. LLama Stack SDK pro jazyk Swift
    https://github.com/meta-llama/llama-stack-client-swift/tree/latest-release
26. LLama Stack SDK pro ekosystém Node.js
    https://github.com/meta-llama/llama-stack-client-node
27. LLama Stack SDK pro jazyk Kotlin
    https://github.com/meta-llama/llama-stack-client-kotlin/tree/latest-release