3.2 Text Generation dengan Python (OpenAI SDK)

Karena NIM kompatibel dengan OpenAI API, Anda bisa langsung menggunakan library openai di Python:

3.4 Vision Model (Multimodal)

NIM mendukung model vision yang bisa memproses gambar bersamaan dengan teks. Ini sangat berguna untuk analisis gambar, OCR, dan visual question answering:

import os
import base64
from openai import OpenAI

client = OpenAI(
    baseurl="https://integrate.api.nvidia.com/v1",

    apikey=os.environ.get("NVIDIAAPIKEY")
)

Encode gambar lokal ke base64
def encodeimage(imagepath):
    with open(imagepath, "rb") as f:

        return base64.b64encode(f.read()).decode("utf-8")

Contoh 1: Analisis gambar dari URL
response = client.chat.completions.create(
    model="meta/llama-3.2-90b-vision-instruct",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Jelaskan apa yang ada di gambar ini dalam Bahasa Indonesia."
                },
                {
                    "type": "imageurl",
                    "imageurl": {

                        "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"
                    }
                }
            ]
        }
    ],
    maxtokens=512
)

print("Deskripsi gambar:")
print(response.choices[0].message.content)

Contoh 2: Analisis gambar dari file lokal
imagebase64 = encodeimage("screenshot.png")
response = client.chat.completions.create(
model="meta/llama-3.2-90b-vision-instruct",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "Apa yang tertulis di gambar ini?"},
{
"type": "imageurl",

"imageurl": {
"url": f"data:image/png;base64,{imagebase64}"

}
}
]
}
],
maxtokens=512
)

3.5 Format Request dan Response

NIM mengikuti format OpenAI API secara ketat. Berikut struktur lengkap request dan response:

{
  "model": "meta/llama-3.1-8b-instruct",
  "messages": [
    {"role": "system", "content": "System prompt di sini"},
    {"role": "user", "content": "Pertanyaan user"},
    {"role": "assistant", "content": "Jawaban sebelumnya (untuk multi-turn)"},
    {"role": "user", "content": "Pertanyaan lanjutan"}
  ],
  "temperature": 0.7,
  "maxtokens": 1024,

  "topp": 0.9,
  "stream": false,
  "stop": ["\n\n"],
  "frequencypenalty": 0.0,

  "presencepenalty": 0.0
}

{
  "id": "chatcmpl-xxxxxxxx",
  "object": "chat.completion",
  "created": 1727388000,
  "model": "meta/llama-3.1-8b-instruct",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Jawaban dari model..."
      },
      "finishreason": "stop"

    }
  ],
  "usage": {
    "prompttokens": 45,
    "completiontokens": 128,

    "totaltokens": 173
  }
}

4. Penggunaan Lanjutan: Self-Hosted dengan Docker

Untuk penggunaan produksi dengan volume tinggi, kontrol penuh atas data, atau kebutuhan latensi rendah, Anda bisa men-deploy NIM container di infrastruktur sendiri.

4.1 Prasyarat Self-Hosted

Sebelum memulai deployment self-hosted, pastikan Anda memiliki:

• GPU NVIDIA: Minimal GPU dengan VRAM yang cukup untuk model yang dipilih (misalnya, Llama 3.1 8B membutuhkan minimal 1x GPU 24GB seperti RTX 4090 atau A10G)
• NVIDIA Driver: Versi 535.129.03 atau lebih baru
• Docker: Versi 24.0 atau lebih baru
• NVIDIA Container Toolkit: Untuk mengaktifkan akses GPU di dalam container Docker
• NGC API Key: Untuk mengunduh container dari NGC registry

4.2 Instalasi NVIDIA Container Toolkit

# Tambahkan repository NVIDIA Container Toolkit
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
  sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Instalasi toolkit
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit

Konfigurasi Docker runtime
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

Verifikasi instalasi
docker run --rm --gpus all nvidia/cuda:12.3.1-base-ubuntu22.04 nvidia-smi

4.3 Login ke NGC Registry

# Login ke NGC container registry
echo "$NGCAPIKEY" | docker login nvcr.io --username '$oauthtoken' --password-stdin

4.4 Deploy NIM Container

Berikut cara men-deploy NIM container untuk model Llama 3.1 8B Instruct:

# Set environment variables
export NGCAPIKEY="nvapi-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
export LOCALNIMCACHE="$HOME/.cache/nim"
mkdir -p "$LOCALNIMCACHE"

Deploy NIM container untuk Llama 3.1 8B Instruct
docker run -d \
  --name nim-llama31-8b \
  --gpus all \
  --shm-size=16g \
  -e NGCAPIKEY="$NGCAPIKEY" \
  -v "$LOCALNIMCACHE:/opt/nim/.cache" \
  -p 8000:8000 \
  nvcr.io/nim/meta/llama-3.1-8b-instruct:latest

Tunggu container siap (biasanya 2-5 menit untuk download dan load model)
Cek status container
docker logs -f nim-llama31-8b

4.5 Verifikasi Deployment

Setelah container berjalan, verifikasi bahwa NIM endpoint sudah siap:

# Health check
curl -s http://localhost:8000/v1/health/ready

Lihat model yang tersedia
curl -s http://localhost:8000/v1/models | python3 -m json.tool

Test inferensi
curl -s http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta/llama-3.1-8b-instruct",
    "messages": [
      {"role": "user", "content": "Halo! Siapa kamu?"}
    ],
    "maxtokens": 256

  }'

# Deploy dengan GPU tertentu (misalnya hanya GPU 0 dan 1)
docker run -d \
  --name nim-llama31-70b \
  --gpus '"device=0,1"' \
  --shm-size=32g \
  -e NGCAPIKEY="$NGCAPIKEY" \

  -e NIMMAXMODELLEN=8192 \
  -e NIMTENSORPARALLELSIZE=2 \

  -v "$LOCALNIMCACHE:/opt/nim/.cache" \

  -p 8000:8000 \
  nvcr.io/nim/meta/llama-3.1-70b-instruct:latest

| NIMMAXMODELLEN | Panjang konteks maksimal | Model default |

| NIMTENSORPARALLELSIZE | Jumlah GPU untuk tensor parallelism | 1 |

| NIMMAXBATCHSIZE | Ukuran batch maksimal | Auto |

| NIMGPUMEMORYUTILIZATION | Persentase VRAM yang digunakan | 0.9 |

| NIMLOGLEVEL | Level logging (DEBUG, INFO, WARNING) | INFO |

# docker-compose.yml
version: '3.8'

services:
  nim-llama-8b:
    image: nvcr.io/nim/meta/llama-3.1-8b-instruct:latest
    containername: nim-llama-8b
    runtime: nvidia
    environment:
NGCAPIKEY=${NGCAPIKEY}
NIMMAXMODELLEN=4096

NVIDIAVISIBLEDEVICES=0

    volumes:

nim-cache:/opt/nim/.cache
    ports:

"8001:8000"
    shmsize: '16g'

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

              capabilities: [gpu]

  nim-embedding:
    image: nvcr.io/nim/nvidia/nv-embedqa-e5-v5:latest
    containername: nim-embedding

    runtime: nvidia
    environment:
NGCAPIKEY=${NGCAPIKEY}

NVIDIAVISIBLEDEVICES=1

    volumes:

nim-cache:/opt/nim/.cache
    ports:

"8002:8000"
    shmsize: '8g'

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

              capabilities: [gpu]

  nginx-lb:
    image: nginx:alpine
    containername: nim-loadbalancer

    ports:
"80:80"
    volumes:

./nginx.conf:/etc/nginx/nginx.conf:ro
    dependson:

nim-llama-8b
nim-embedding

volumes:
  nim-cache:

4.8 Monitoring dan Health Checks

NIM menyediakan endpoint monitoring built-in yang bisa diintegrasikan dengan Prometheus dan Grafana:

# Health check endpoint
curl http://localhost:8000/v1/health/ready
Response: {"status": "ready"}

Metrics endpoint (format Prometheus)
curl http://localhost:8000/metrics

Contoh script monitoring sederhana
#!/bin/bash
while true; do
    STATUS=$(curl -s -o /dev/null -w "%{httpcode}" http://localhost:8000/v1/health/ready)

    if [ "$STATUS" != "200" ]; then
        echo "[$(date)] WARNING: NIM tidak merespons (HTTP $STATUS)"
        # Kirim notifikasi ke Telegram atau Slack
    else
        echo "[$(date)] OK: NIM berjalan normal"
    fi
    sleep 30
done

import os
from openai import OpenAI

Untuk cloud API (build.nvidia.com)
cloudclient = OpenAI(
    baseurl="https://integrate.api.nvidia.com/v1",

    apikey=os.environ.get("NVIDIAAPIKEY")
)

Untuk self-hosted NIM
localclient = OpenAI(

    baseurl="http://localhost:8000/v1",
    apikey="not-used"  # Self-hosted tidak memerlukan API key

)

def chatwithnim(client, usermessage, systemprompt=None):

    """Fungsi helper untuk chat dengan NIM."""
    messages = []
    if systemprompt:
        messages.append({"role": "system", "content": systemprompt})

    messages.append({"role": "user", "content": usermessage})

    response = client.chat.completions.create(
        model="meta/llama-3.1-8b-instruct",
        messages=messages,
        temperature=0.7,
        maxtokens=1024

    )
    return response.choices[0].message.content

Contoh penggunaan: Chatbot customer service Bahasa Indonesia
systemprompt = """Kamu adalah asisten customer service untuk toko online Indonesia.
Jawab pertanyaan pelanggan dengan sopan, ramah, dan profesional dalam Bahasa Indonesia.
Jika ditanya tentang status pesanan, minta nomor pesanan mereka."""

jawaban = chatwithnim(
    cloudclient,

    "Saya mau tanya, pesanan saya sudah sampai mana ya?",
    systemprompt
)
print(jawaban)

5.2 Streaming Responses

Untuk pengalaman pengguna yang lebih baik, gunakan streaming agar response ditampilkan secara bertahap:

import os
from openai import OpenAI

client = OpenAI(
    baseurl="https://integrate.api.nvidia.com/v1",

    apikey=os.environ.get("NVIDIAAPIKEY")
)

def streamchat(usermessage):
    """Stream response dari NIM untuk UX yang lebih responsif."""
    stream = client.chat.completions.create(
        model="meta/llama-3.1-8b-instruct",
        messages=[
            {
                "role": "system",
                "content": "Kamu adalah penulis teknis yang ahli dalam teknologi AI."
            },
            {"role": "user", "content": usermessage}

        ],
        temperature=0.7,
        maxtokens=2048,
        stream=True  # Aktifkan streaming
    )

    fullresponse = ""

    for chunk in stream:
        if chunk.choices[0].delta.content is not None:
            content = chunk.choices[0].delta.content
            print(content, end="", flush=True)
            fullresponse += content

    print()  # Newline setelah streaming selesai
    return fullresponse


Contoh: Generate artikel teknis
response = streamchat(
    "Tulis penjelasan singkat tentang bagaimana transformer bekerja "
    "untuk audience developer Indonesia yang baru belajar AI."
)

5.3 Menggunakan LangChain NVIDIA AI Endpoints

Jika Anda sudah menggunakan LangChain, ada integrasi khusus untuk NVIDIA NIM:

import os
from langchainnvidiaaiendpoints import ChatNVIDIA, NVIDIAEmbeddings

from langchaincore.messages import HumanMessage, SystemMessage

Inisialisasi chat model
llm = ChatNVIDIA(
    model="meta/llama-3.1-8b-instruct",
    nvidiaapikey=os.environ.get("NVIDIAAPIKEY"),
    temperature=0.7,
    maxtokens=1024

)

Chat sederhana
messages = [
    SystemMessage(content="Kamu adalah asisten coding untuk developer Indonesia."),
    HumanMessage(content="Buatkan contoh fungsi Python untuk validasi NIK (KTP).")
]

response = llm.invoke(messages)
print(response.content)

Inisialisasi embedding model
embeddings = NVIDIAEmbeddings(
    model="nvidia/nv-embedqa-e5-v5",
    nvidiaapikey=os.environ.get("NVIDIAAPIKEY")

)

Generate embeddings
texts = [
    "Panduan penggunaan e-commerce di Indonesia",
    "Tutorial membuat website dengan Django",
    "Resep masakan tradisional Nusantara"
]
vectors = embeddings.embeddocuments(texts)
print(f"Jumlah vectors: {len(vectors)}")
print(f"Dimensi per vector: {len(vectors[0])}")

Contoh: RAG pipeline sederhana dengan NVIDIA NIM
from langchaincore.prompts import ChatPromptTemplate

from langchaincore.outputparsers import StrOutputParser


Template prompt untuk RAG
ragprompt = ChatPromptTemplate.frommessages([

    ("system", """Kamu adalah asisten yang menjawab pertanyaan berdasarkan konteks yang diberikan.
Jawab HANYA berdasarkan informasi dalam konteks. Jika konteks tidak memuat jawaban, katakan 'Maaf, informasi tidak tersedia.'

Konteks:
{context}"""),
    ("user", "{question}")
])

Chain
chain = ragprompt | llm | StrOutputParser()

Jalankan chain
result = chain.invoke({
    "context": "PT RUBYTHALIB DATA KONSULTA adalah perusahaan konsultan AI yang berlokasi di SCBD, Jakarta Selatan. Perusahaan ini menyediakan layanan konsultasi AI, pelatihan, dan pengembangan solusi AI custom.",
    "question": "Di mana lokasi PT RUBYTHALIB DATA KONSULTA?"
})
print(result)

5.4 Function Calling / Tool Use

NIM mendukung function calling yang memungkinkan model memanggil fungsi eksternal:

import os
import json
from openai import OpenAI

client = OpenAI(
    baseurl="https://integrate.api.nvidia.com/v1",

    apikey=os.environ.get("NVIDIAAPIKEY")
)

Definisikan tools/functions
tools = [
    {
        "type": "function",
        "function": {
            "name": "cekcuaca",

            "description": "Mengecek kondisi cuaca di suatu kota di Indonesia",
            "parameters": {
                "type": "object",
                "properties": {
                    "kota": {
                        "type": "string",
                        "description": "Nama kota, misalnya Jakarta, Surabaya, Bandung"
                    },
                    "satuan": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Satuan suhu"
                    }
                },
                "required": ["kota"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "konversimatauang",

            "description": "Konversi mata uang dari IDR ke mata uang lain",
            "parameters": {
                "type": "object",
                "properties": {
                    "jumlah": {
                        "type": "number",
                        "description": "Jumlah uang dalam Rupiah (IDR)"
                    },
                    "matauangtujuan": {

                        "type": "string",
                        "description": "Kode mata uang tujuan (USD, EUR, SGD, dll)"
                    }
                },
                "required": ["jumlah", "matauangtujuan"]

            }
        }
    }
]

Simulasi fungsi
def cekcuaca(kota, satuan="celsius"):
    # Dalam produksi, ini akan memanggil API cuaca sungguhan
    datacuaca = {

        "Jakarta": {"suhu": 32, "kondisi": "Cerah berawan"},
        "Bandung": {"suhu": 24, "kondisi": "Hujan ringan"},
        "Surabaya": {"suhu": 34, "kondisi": "Cerah"},
    }
    return json.dumps(datacuaca.get(kota, {"suhu": 28, "kondisi": "Data tidak tersedia"}))

def konversimatauang(jumlah, matauangtujuan):
    kurs = {"USD": 15500, "EUR": 17000, "SGD": 11500}
    rate = kurs.get(matauangtujuan, 15000)
    hasil = jumlah / rate
    return json.dumps({"hasil": round(hasil, 2), "matauang": matauangtujuan})


Kirim request dengan tools
response = client.chat.completions.create(
    model="meta/llama-3.1-8b-instruct",
    messages=[
        {"role": "user", "content": "Berapa cuaca di Jakarta hari ini?"}
    ],
    tools=tools,
    toolchoice="auto"
)

Proses tool calls
message = response.choices[0].message
if message.toolcalls:

    for toolcall in message.toolcalls:

        functionname = toolcall.function.name

        arguments = json.loads(toolcall.function.arguments)

        # Eksekusi fungsi yang diminta
        if functionname == "cekcuaca":
            result = cekcuaca(arguments)

        elif functionname == "konversimatauang":
            result = konversimatauang(arguments)

        print(f"Function: {functionname}")

        print(f"Arguments: {arguments}")
        print(f"Result: {result}")

6. Best Practices

6.1 Pemilihan Model yang Tepat

Memilih model yang sesuai dengan kebutuhan sangat penting untuk mengoptimalkan biaya dan performa:

| Use Case | Model Rekomendasi | Alasan |

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

| Chatbot umum | Llama 3.1 8B Instruct | Cepat, ringan, cukup untuk percakapan umum |

| Analisis dokumen kompleks | Llama 3.1 70B Instruct | Pemahaman konteks lebih baik |

| Code generation | Llama 3.1 8B/70B Instruct | Baik untuk coding tasks |

| Embedding / Search | NV-EmbedQA-E5-v5 | Dioptimasi untuk retrieval |

| Analisis gambar | Llama 3.2 90B Vision | Multimodal capabilities |

| Task sederhana (klasifikasi, ekstraksi) | Llama 3.1 8B | Hemat resource |

6.2 Optimasi Latency dan Throughput

6.3 Caching Strategies

Implementasikan caching untuk mengurangi panggilan API yang redundan:

6.4 Error Handling dan Retry

Implementasi error handling yang robust untuk aplikasi produksi: