Tutorial Lengkap Llama Stack: Framework Resmi Meta untuk Membangun Aplikasi AI dengan Model Llama

Llama Stack adalah framework open-source resmi dari Meta yang menyediakan API standar untuk membangun aplikasi AI menggunakan model Llama. Framework ini menyatukan berbagai komponen penting seperti inference, safety, memory, dan agentic workflows dalam satu ekosistem yang terintegrasi. Dalam tutorial ini, kita akan mempelajari cara menginstal, mengkonfigurasi, dan menggunakan Llama Stack untuk membangun aplikasi AI yang production-ready.

Apa Itu Llama Stack?

Llama Stack adalah spesifikasi API dan implementasi referensi yang dikembangkan oleh Meta untuk menstandardisasi cara developer berinteraksi dengan model Llama. Berbeda dengan menggunakan model Llama secara langsung melalui berbagai library yang berbeda-beda, Llama Stack menyediakan satu antarmuka yang konsisten untuk semua kebutuhan pengembangan AI.

Komponen utama Llama Stack meliputi:

• Inference API: Menjalankan model Llama untuk text generation, chat completion, dan structured output
• Safety API: Menerapkan content filtering dan guardrails pada input/output model
• Memory API: Menyimpan dan mengambil konteks percakapan serta dokumen untuk RAG
• Agents API: Membangun AI agents yang bisa menggunakan tools dan menyelesaikan tugas kompleks
• Evaluation API: Mengevaluasi performa model pada berbagai benchmark

Keunggulan utama Llama Stack adalah portabilitasnya. Kode yang Anda tulis bisa berjalan di berbagai provider tanpa perubahan signifikan, baik itu lokal menggunakan Ollama, di cloud menggunakan AWS Bedrock atau Together AI, maupun di infrastruktur on-premise.

Instalasi dan Setup

Prasyarat

Pastikan Anda memiliki Python 3.10 atau lebih baru terinstal di sistem Anda.

python --version
Python 3.10+ required

Menginstal Llama Stack

Instal package utama Llama Stack beserta client library-nya:

pip install llama-stack llama-stack-client

Untuk menggunakan provider tertentu, instal dependensi tambahan sesuai kebutuhan:

# Untuk Ollama (local inference)
pip install llama-stack[ollama]

Untuk Together AI (cloud inference)
pip install llama-stack[together]

Untuk Meta Reference (implementasi referensi Meta)
pip install llama-stack[meta-reference]

Mengkonfigurasi Llama Stack Server

Llama Stack bekerja dengan arsitektur client-server. Pertama, kita perlu menjalankan server yang akan melayani API requests.

Cara tercepat untuk memulai adalah menggunakan template bawaan:

# Melihat daftar template yang tersedia
llama stack list-templates

Menggunakan template Ollama (untuk local development)
llama stack build --template ollama --image-type venv

Menjalankan server
llama stack run ollama --port 8321

Jika Anda menggunakan Docker, prosesnya lebih sederhana:

# Menjalankan Llama Stack dengan Ollama via Docker
docker run -p 8321:8321 \
  -v ~/.llama:/root/.llama \
  llamastack/distribution-ollama \
  --port 8321

Pastikan Ollama sudah terinstal dan model Llama sudah di-download:

# Instal Ollama (jika belum)
curl -fsSL https://ollama.ai/install.sh | sh

Download model Llama
ollama pull llama3.2:3b
ollama pull llama3.1:8b

Verifikasi Instalasi

Setelah server berjalan, verifikasi dengan mengakses endpoint health check:

curl http://localhost:8321/v1/health
Response: {"status": "ok"}

Melihat model yang tersedia
curl http://localhost:8321/v1/models

Basic Usage

Inisialisasi Client

Buat file Python baru dan inisialisasi client Llama Stack:

from llamastackclient import LlamaStackClient

Koneksi ke Llama Stack server
client = LlamaStackClient(baseurl="http://localhost:8321")


Verifikasi koneksi dengan melihat model yang tersedia
models = client.models.list()
for model in models:
    print(f"Model: {model.identifier}, Provider: {model.providerid}")

Chat Completion Dasar

Berikut cara melakukan chat completion sederhana:

from llamastackclient import LlamaStackClient

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


response = client.inference.chatcompletion(
    modelid="llama3.1-8b",

    messages=[
        {"role": "system", "content": "Kamu adalah asisten AI yang membantu dan ramah."},
        {"role": "user", "content": "Jelaskan apa itu machine learning dalam 3 kalimat."}
    ],
    temperature=0.7,
    maxtokens=512
)

print(response.completionmessage.content)

from llamastackclient import LlamaStackClient

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

stream = client.inference.chatcompletion(

    modelid="llama3.1-8b",
    messages=[
        {"role": "user", "content": "Tulis puisi pendek tentang teknologi AI."}
    ],
    stream=True
)

for chunk in stream:
    if hasattr(chunk, 'event') and chunk.event.delta:
        print(chunk.event.delta, end="", flush=True)

print()  # newline setelah streaming selesai

Structured Output

Llama Stack mendukung structured output menggunakan JSON schema:

from llamastackclient import LlamaStackClient
import json

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


response = client.inference.chatcompletion(
    modelid="llama3.1-8b",

    messages=[
        {
            "role": "user",
            "content": "Berikan informasi tentang 3 bahasa pemrograman populer untuk AI."
        }
    ],
    responseformat={
        "type": "jsonschema",

        "jsonschema": {
            "name": "programminglanguages",

            "schema": {
                "type": "object",
                "properties": {
                    "languages": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {"type": "string"},
                                "usecase": {"type": "string"},
                                "popularityrank": {"type": "integer"}

                            },
                            "required": ["name", "usecase", "popularityrank"]

                        }
                    }
                },
                "required": ["languages"]
            }
        }
    }
)

result = json.loads(response.completionmessage.content)
print(json.dumps(result, indent=2))

Advanced Usage

Membangun RAG dengan Memory API

Salah satu fitur paling powerful dari Llama Stack adalah Memory API yang memungkinkan Retrieval-Augmented Generation (RAG). Berikut contoh implementasinya:

from llamastackclient import LlamaStackClient

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


Membuat memory bank untuk menyimpan dokumen
bankid = "knowledge-base-01"
client.memorybanks.register(

    memorybankid=bankid,
    params={
        "memorybanktype": "vector",
        "embeddingmodel": "all-MiniLM-L6-v2",

        "chunksizeintokens": 512,
        "overlapsizeintokens": 64

    }
)

Memasukkan dokumen ke memory bank
documents = [
    {
        "documentid": "doc-1",
        "content": """
        Llama 3.1 adalah model bahasa besar dari Meta yang tersedia dalam ukuran
        8B, 70B, dan 405B parameter. Model ini mendukung context window hingga
        128K token dan telah dilatih pada data multilingual.
        """,
        "metadata": {"source": "meta-docs", "topic": "llama-models"}
    },
    {
        "documentid": "doc-2",

        "content": """
        Llama Stack menyediakan API standar untuk inference, safety, memory,
        dan agents. Framework ini mendukung berbagai provider termasuk Ollama,
        Together AI, AWS Bedrock, dan Fireworks AI.
        """,
        "metadata": {"source": "meta-docs", "topic": "llama-stack"}
    }
]

client.memory.insert(
    bankid=bankid,

    documents=documents
)

Query dengan RAG
query = "Berapa ukuran parameter yang tersedia untuk Llama 3.1?"

Cari dokumen relevan
results = client.memory.query(
    bankid=bankid,

    query=query,
    params={"maxchunks": 3}
)

Bangun konteks dari hasil pencarian
context = "\n".join([chunk.content for chunk in results.chunks])

Generate jawaban dengan konteks
response = client.inference.chatcompletion(

    modelid="llama3.1-8b",
    messages=[
        {
            "role": "system",
            "content": f"Jawab pertanyaan berdasarkan konteks berikut:\n\n{context}"
        },
        {"role": "user", "content": query}
    ]
)

print(response.completionmessage.content)

from llamastackclient import LlamaStackClient
from llamastackclient.types.agentcreateparams import AgentConfig


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

Definisikan custom tool
searchtool = {

    "type": "function",
    "function": {
        "name": "searchdatabase",
        "description": "Mencari informasi produk dalam database",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "Kata kunci pencarian"
                },
                "category": {
                    "type": "string",
                    "enum": ["electronics", "clothing", "food"],
                    "description": "Kategori produk"
                }
            },
            "required": ["query"]
        }
    }
}

Buat agent configuration
agentconfig = AgentConfig(

    model="llama3.1-8b",
    instructions="""Kamu adalah asisten belanja yang membantu pelanggan mencari produk.
    Gunakan tool searchdatabase untuk mencari informasi produk yang relevan.
    Berikan rekomendasi yang jelas dan informatif.""",
    tools=[searchtool],

    enablesessionpersistence=True,

    maxinferiters=5

)

Buat agent
agent = client.agents.create(agentconfig=agentconfig)

agentid = agent.agentid


Buat session baru
session = client.agents.session.create(
    agentid=agentid,

    sessionname="shopping-session-01"
)
sessionid = session.sessionid

Kirim pesan ke agent
response = client.agents.turn.create(
    agentid=agentid,
    sessionid=sessionid,
    messages=[
        {"role": "user", "content": "Carikan laptop gaming dengan budget 15 juta"}
    ],
    stream=False
)

Proses response dan tool calls
for step in response.steps:
    if step.steptype == "inference":

        print(f"Agent: {step.completionmessage.content}")
    elif step.steptype == "toolexecution":
        print(f"Tool called: {step.toolcalls}")

from llamastackclient import LlamaStackClient

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

Mendaftarkan safety shield
client.shields.register(
    shieldid="content-filter",

    providershieldid="llama-guard"

)

Menjalankan safety check pada input
inputcheck = client.safety.runshield(

    shieldid="content-filter",
    messages=[
        {"role": "user", "content": "Bagaimana cara membuat aplikasi web dengan Python?"}
    ]
)

if inputcheck.violation:

    print(f"Input ditolak: {inputcheck.violation.usermessage}")

else:
    print("Input aman, melanjutkan inference...")

    response = client.inference.chatcompletion(
        modelid="llama3.1-8b",

        messages=[
            {"role": "user", "content": "Bagaimana cara membuat aplikasi web dengan Python?"}
        ]
    )

    # Safety check pada output
    outputcheck = client.safety.runshield(

        shieldid="content-filter",
        messages=[
            {"role": "assistant", "content": response.completionmessage.content}

        ]
    )

    if outputcheck.violation:
        print("Output difilter karena melanggar kebijakan safety.")
    else:
        print(response.completionmessage.content)

# config.yaml
apis:
inference
safety
memory
agents

providers:
  inference:
providerid: ollama-local
      providertype: remote::ollama

      config:
        url: http://localhost:11434
providerid: together-cloud
      providertype: remote::together

      config:
        apikey: ${TOGETHERAPIKEY}

  safety:
providerid: llama-guard

      providertype: inline::llama-guard

      config:
        model: llama-guard-3-1b

  memory:
providerid: faiss-local

      providertype: inline::faiss

      config:
        kvstore:
          type: sqlite
          dbpath: ~/.llama/memory.db


  agents:
providerid: meta-reference
      providertype: inline::meta-reference

      config: {}

models:
metadata: {}
    modelid: llama3.2-3b

    providerid: ollama-local

    providermodelid: llama3.2:3b

metadata: {}
    modelid: llama3.1-70b

    providerid: together-cloud

    providermodelid: meta-llama/Llama-3.1-70B-Instruct-Turbo

llama stack run config.yaml --port 8321

from llamastackclient import LlamaStackClient

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

Mendaftarkan benchmark dataset
client.datasets.register(
    datasetid="qa-benchmark",

    datasetschema={
        "type": "map",
        "key": {"type": "string"},
        "value": {
            "type": "object",
            "properties": {
                "question": {"type": "string"},
                "expectedanswer": {"type": "string"}

            }
        }
    },
    url="file:///path/to/benchmark.jsonl"
)

Menjalankan evaluasi
evaljob = client.eval.runeval(

    taskid="qa-evaluation",
    taskconfig={

        "type": "benchmark",
        "evalcandidate": {
            "type": "model",
            "model": "llama3.1-8b",
            "samplingparams": {

                "temperature": 0.1,
                "maxtokens": 256
            }
        },
        "scoringfunctions": ["accuracy", "rougel", "bleu"]
    }
)

Mendapatkan hasil evaluasi
results = client.eval.jobresult(

    taskid="qa-evaluation",
    jobid=evaljob.jobid

)

for metric, score in results.scores.items():
    print(f"{metric}: {score:.4f}")

# docker-compose.yml
version: '3.8'

services:
  llama-stack:
    image: llamastack/distribution-ollama
    ports:
"8321:8321"
    volumes:

llama-data:/root/.llama
./config.yaml:/app/config.yaml
    environment:

TOGETHERAPIKEY=${TOGETHERAPIKEY}

    command: ["--config", "/app/config.yaml", "--port", "8321"]

    dependson:
ollama
    restart: unless-stopped


  ollama:
    image: ollama/ollama
    ports:
"11434:11434"
    volumes:

ollama-data:/root/.ollama
    deploy:

      resources:
        reservations:
          devices:
driver: nvidia
              count: 1

              capabilities: [gpu]
    restart: unless-stopped

volumes:
  llama-data:
  ollama-data:

Monitoring dan Logging

Untuk production, tambahkan telemetry configuration:

from llamastackclient import LlamaStackClient

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


Mengaktifkan telemetry
client.telemetry.logevent(
    event={
        "type": "structuredlog",

        "payload": {
            "message": "Inference request completed",
            "model": "llama3.1-8b",
            "latencyms": 1250,
            "tokensgenerated": 128

        }
    }
)

Query telemetry data
spans = client.telemetry.queryspans(
    attributefilters=[

        {"key": "model", "value": "llama3.1-8b"}
    ],
    limit=100
)

for span in spans:
    print(f"Span: {span.spanid}, Duration: {span.durationms}ms")

response = client.inference.chatcompletion(
    modelid="llama3.1-8b",

    messages=messages,
    # Aktifkan caching untuk mengurangi latency pada prompt yang berulang
    samplingparams={
        "temperature": 0.7,
        "maxtokens": 1024,

    }
)

from llamastackclient import LlamaStackClient
from llamastackclient.lib.agents.agent import Agent


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

try:
    response = client.inference.chatcompletion(

        modelid="llama3.1-8b",
        messages=[{"role": "user", "content": "Hello"}]
    )
    print(response.completion_message.content)
except ConnectionError:
    print("Tidak dapat terhubung ke Llama Stack server.")
except Exception as e:
    print(f"Error: {e}")

4. Gunakan Safety Shields di Production

Selalu aktifkan safety shields di lingkungan production untuk mencegah output yang tidak diinginkan. Konfigurasikan Llama Guard sebagai default shield pada konfigurasi server.

5. Optimalkan Memory Bank

Untuk RAG yang efisien:

• Atur chunk size sesuai dengan jenis dokumen (512 token untuk artikel, 256 untuk FAQ)
• Gunakan overlap yang cukup (10-15% dari chunk size) untuk menjaga konteks
• Bersihkan memory bank secara berkala untuk menghapus dokumen yang sudah tidak relevan

6. Monitor Penggunaan Resource

Pantau penggunaan GPU, RAM, dan CPU saat menjalankan model secara lokal. Model 8B membutuhkan minimal 8GB VRAM, sedangkan model 70B membutuhkan minimal 40GB VRAM atau bisa menggunakan quantisasi untuk mengurangi kebutuhan memori.

Perbandingan dengan Framework Lain

| Aspek | Llama Stack | LangChain | LlamaIndex |

|-------|------------|-----------|------------|

| Fokus | Ekosistem Llama end-to-end | Orchestrasi LLM umum | RAG dan data indexing |

| Model Support | Llama-first, extensible | Multi-model | Multi-model |

| Safety | Built-in Llama Guard | Perlu integrasi | Perlu integrasi |

| Agents | Native support | Comprehensive | Dasar |

| Memory | Built-in vector store | Perlu integrasi | Built-in |

| Deployment | Server-based | Library | Library |

Kesimpulan

Llama Stack adalah framework yang powerful dan terstruktur untuk membangun aplikasi AI menggunakan model Llama. Dengan API yang konsisten, dukungan multi-provider, dan fitur built-in untuk safety, memory, dan agents, Llama Stack mempermudah pengembangan aplikasi AI dari prototipe hingga production.

Poin-poin penting yang perlu diingat:

Mulailah dengan instalasi lokal menggunakan Ollama, eksplorasi fitur-fitur yang tersedia, dan secara bertahap tingkatkan ke deployment production seiring pemahaman Anda bertambah.