Fireworks AI: Platform Inference Super Cepat buat Open LLM dan Model Multimodal

Halo temen-temen, di tutorial kali ini aku mau ngajak kalian kenalan sama salah satu platform yang lagi naik daun banget di dunia LLM, namanya Fireworks AI. Kalau kalian selama ini terbiasa manggil model closed-source dan mulai mikir "kok latency-nya lama ya" atau "kok biayanya makin bengkak", nah Fireworks AI ini bisa jadi jawaban yang aku pengen kalian coba.

Aku sendiri suka banget sama platform yang fokusnya di kecepatan, karena buat aplikasi produksi, latency itu bukan cuma soal enak dilihat, tapi bener-bener ngaruh ke pengalaman user dan biaya. Fireworks AI ini menjual dirinya sebagai platform inference yang low-latency, high-throughput, dan bisa jalanin banyak model open-source populer kayak Llama, Qwen, DeepSeek, Mixtral, sampai model multimodal buat vision. Di tutorial ini kita bakal bahas dari awal banget, mulai dari cara ambil API key, instalasi, chat completions, streaming, structured output alias JSON mode, function calling, vision model, embeddings, sampai dasar-dasar fine-tuning. Semua aku kasih contoh Python yang bisa langsung kalian jalanin.

Introduction

Sebelum kita masuk ke kode, aku pengen kalian paham dulu Fireworks AI itu sebenernya apa dan kenapa dia menarik. Jadi gini, Fireworks AI itu platform inference. Artinya mereka nyediain infrastruktur buat ngejalanin model AI, terutama open-source LLM, dengan performa yang udah dioptimasi habis-habisan. Kalian nggak perlu pusing mikirin GPU, deployment, scaling, atau optimasi engine inference. Kalian tinggal panggil API, dan model langsung ngasih respons dengan cepat.

Yang bikin aku tertarik sama Fireworks itu beberapa hal. Pertama, soal kecepatan. Mereka pakai engine inference sendiri yang namanya FireAttention, yang dioptimasi buat throughput tinggi dan latency rendah. Buat aplikasi yang butuh respons real-time kayak chatbot, coding assistant, atau agent, ini penting banget. Kedua, soal fleksibilitas model. Kalian bisa pilih dari puluhan model open-source yang udah di-host, atau bahkan deploy model kalian sendiri lewat fitur dedicated deployment. Ketiga, soal kompatibilitas. Fireworks AI ini API-nya kompatibel sama format OpenAI, jadi kalau kalian udah punya kode yang pakai library OpenAI, migrasinya gampang banget, tinggal ganti base URL sama API key.

Buat kalian yang belum kebayang use case-nya, Fireworks AI cocok banget buat bangun chatbot pintar, sistem RAG (Retrieval Augmented Generation), coding assistant, aplikasi yang butuh analisis gambar, atau pipeline yang butuh structured output buat diproses lebih lanjut. Karena modelnya open-source dan biayanya per-token dengan harga yang kompetitif, ini juga jadi pilihan hemat dibanding beberapa provider closed-source.

Satu hal yang aku suka tekankan ke temen-temen, Fireworks AI ini punya dua mode deployment utama. Yang pertama serverless, di mana kalian bayar per token dan modelnya di-share sama banyak user. Ini cocok buat prototyping dan traffic yang nggak terlalu masif. Yang kedua on-demand atau dedicated deployment, di mana kalian dapet GPU khusus buat model kalian, latency-nya lebih konsisten, dan cocok buat produksi dengan traffic tinggi. Kita bakal singgung dua-duanya nanti.

Instalasi

Oke, sekarang kita masuk ke bagian teknis. Sebelum instalasi, hal pertama yang harus kalian lakuin adalah bikin akun dan ambil API key.

Ambil API Key

Langkah-langkahnya gampang kok. Kalian tinggal buka fireworks.ai, terus daftar akun. Setelah masuk ke dashboard, cari menu API Keys. Di situ kalian bisa generate API key baru. Simpen baik-baik ya, jangan sampai ke-commit ke Git atau ke-share ke orang lain. API key ini yang bakal kita pakai buat autentikasi semua request.

Saran aku, simpen API key ini di environment variable biar aman. Jangan pernah hard-code langsung di kode, apalagi kalau repo kalian public. Caranya gini di terminal:

export FIREWORKSAPIKEY="fwxxxxxxxxxxxxxxxxxxxx"

pip install fireworks-ai

pip install python-dotenv

pip install openai

import os
from fireworks.client import Fireworks

client = Fireworks(apikey=os.environ.get("FIREWORKSAPIKEY"))

response = client.chat.completions.create(
    model="accounts/fireworks/models/llama-v3p1-8b-instruct",
    messages=[{"role": "user", "content": "Halo, kamu model apa?"}],
)

print(response.choices[0].message.content)

Kalau kalian dapet respons dari model, berarti instalasi dan API key kalian udah bener. Perhatiin nama model-nya ya, format Fireworks itu selalu pakai path lengkap accounts/fireworks/models/. Ini beda sama OpenAI yang cuma pakai nama pendek kayak gpt-4. Jadi jangan bingung kalau kelihatan panjang, itu memang formatnya.

Basic Usage

Sekarang kita masuk ke penggunaan dasar. Di bagian ini aku bakal jelasin chat completions, cara pakai lewat OpenAI-compatible, dan streaming. Ini fondasi yang harus kalian kuasai dulu sebelum masuk ke fitur yang lebih canggih.

Chat Completions

Chat completions adalah cara paling umum buat berinteraksi sama LLM. Kalian kirim daftar pesan, dan model ngebalas. Struktur pesannya sama kayak yang biasa kalian temuin, ada role system, user, dan assistant.

import os
from fireworks.client import Fireworks

client = Fireworks(apikey=os.environ.get("FIREWORKSAPIKEY"))


response = client.chat.completions.create(
    model="accounts/fireworks/models/llama-v3p1-70b-instruct",
    messages=[
        {"role": "system", "content": "Kamu adalah asisten yang ramah dan menjawab dalam Bahasa Indonesia."},
        {"role": "user", "content": "Jelaskan apa itu inference latency dalam satu paragraf singkat."},
    ],
    temperature=0.6,
    maxtokens=512,
)

print(response.choices[0].message.content)

Beberapa parameter penting yang perlu kalian tahu. temperature ngatur seberapa kreatif atau acak jawaban model, nilai rendah kayak 0.2 bikin jawaban lebih deterministik, nilai tinggi kayak 0.9 bikin lebih variatif. maxtokens batesin panjang output. Ada juga topp buat nucleus sampling. Aku sarankan buat aplikasi yang butuh konsistensi, pakai temperature rendah aja.

Pakai Lewat OpenAI-Compatible

Nah ini yang aku bilang tadi enak banget. Kalau kalian udah familiar sama OpenAI SDK, kalian tinggal ganti baseurl dan apikey. Semua kode yang lain nyaris nggak berubah.

import os
from openai import OpenAI

client = OpenAI(
    baseurl="https://api.fireworks.ai/inference/v1",

    apikey=os.environ.get("FIREWORKSAPIKEY"),
)

response = client.chat.completions.create(
    model="accounts/fireworks/models/llama-v3p1-70b-instruct",
    messages=[
        {"role": "user", "content": "Sebutkan 3 keuntungan pakai open-source LLM."},
    ],
)

print(response.choices[0].message.content)

Lihat kan, cuma beda di baseurl. Ini yang aku suka banget dari Fireworks, karena migrasi dari OpenAI ke Fireworks jadi gampang banget. Kalau kalian pengen coba-coba hemat biaya atau pengen pakai model open-source tapi males refactor kode, cara ini paling praktis.

import os
from fireworks.client import Fireworks

client = Fireworks(apikey=os.environ.get("FIREWORKSAPIKEY"))

stream = client.chat.completions.create(
    model="accounts/fireworks/models/llama-v3p1-70b-instruct",
    messages=[
        {"role": "user", "content": "Tuliskan cerita pendek tentang robot yang belajar memasak."},
    ],
    stream=True,
)

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

Perhatiin stream=True dan cara kita iterasi tiap chunk. Tiap chunk berisi potongan teks di delta.content. Kita cetak langsung tanpa newline biar kelihatan mengalir. Buat kalian yang bangun aplikasi web, chunk-chunk ini biasanya kalian teruskan ke frontend lewat Server-Sent Events atau WebSocket. Ini yang bikin pengalaman chatbot terasa hidup dan responsif.

Kalau kalian pakai OpenAI-compatible, cara streaming-nya sama persis, tinggal tambahin stream=True dan iterasi chunk-nya.

Advanced Usage

Oke temen-temen, sekarang kita masuk ke bagian yang lebih seru. Di sini kita bakal bahas structured output alias JSON mode, function calling, vision model, embeddings, dan dasar-dasar fine-tuning. Bagian ini yang bikin Fireworks AI beneran powerful buat aplikasi produksi.

Structured Output dan JSON Mode

Sering banget kan kita butuh output dari LLM dalam format terstruktur biar gampang diproses program. Misalnya kita mau ekstrak data dari teks dan hasilnya harus JSON yang valid. Fireworks AI dukung JSON mode dan bahkan structured output dengan schema, jadi kalian bisa maksa model ngeluarin output sesuai bentuk yang kalian mau.

Cara paling dasar, kalian bisa pakai responseformat dengan tipe jsonobject:

import os
import json
from fireworks.client import Fireworks

client = Fireworks(apikey=os.environ.get("FIREWORKSAPIKEY"))


response = client.chat.completions.create(
    model="accounts/fireworks/models/llama-v3p1-70b-instruct",
    messages=[
        {"role": "system", "content": "Ekstrak informasi dan balas dalam JSON."},
        {"role": "user", "content": "Budi berumur 28 tahun, bekerja sebagai data scientist di Jakarta."},
    ],
    responseformat={"type": "jsonobject"},

)

data = json.loads(response.choices[0].message.content)
print(data)

import os
import json
from pydantic import BaseModel
from fireworks.client import Fireworks

client = Fireworks(apikey=os.environ.get("FIREWORKSAPIKEY"))

class Person(BaseModel):
    name: str
    age: int
    job: str
    city: str

response = client.chat.completions.create(
    model="accounts/fireworks/models/llama-v3p1-70b-instruct",
    messages=[
        {"role": "user", "content": "Budi, 28 tahun, data scientist di Jakarta."},
    ],
    responseformat={

        "type": "jsonobject",
        "schema": Person.modeljsonschema(),
    },
)

person = Person.modelvalidatejson(response.choices[0].message.content)
print(person)

Dengan cara ini, kalian nggak perlu deg-degan output-nya bakal rusak atau nggak sesuai. Model bakal ngikutin schema Person. Ini penting banget buat aplikasi produksi di mana output LLM langsung masuk ke database atau diproses program lain.

Function Calling

Function calling, atau kadang disebut tool calling, itu fitur yang bikin LLM bisa "manggil" fungsi yang kalian sediakan. Jadi bukannya model cuma jawab teks, dia bisa memutuskan buat manggil tool tertentu dengan argumen yang sesuai. Ini fondasi buat bikin AI agent yang bisa berinteraksi sama sistem eksternal, kayak cek cuaca, query database, atau panggil API lain.

import os
import json
from fireworks.client import Fireworks

client = Fireworks(apikey=os.environ.get("FIREWORKSAPIKEY"))


tools = [
    {
        "type": "function",
        "function": {
            "name": "getweather",
            "description": "Ambil info cuaca terkini untuk sebuah kota",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Nama kota"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
                },
                "required": ["city"],
            },
        },
    }
]

response = client.chat.completions.create(
    model="accounts/fireworks/models/llama-v3p1-70b-instruct",
    messages=[{"role": "user", "content": "Gimana cuaca di Bandung hari ini?"}],
    tools=tools,
    toolchoice="auto",

)

message = response.choices[0].message
if message.toolcalls:
    call = message.toolcalls[0]

    print("Model mau panggil:", call.function.name)
    print("Argumen:", json.loads(call.function.arguments))

Alur lengkapnya gini. Model ngeliat pertanyaan user, memutuskan bahwa dia butuh manggil getweather, terus ngasih argumen city dan unit. Tugas kalian di kode adalah nangkep panggilan itu, jalanin fungsi getweather beneran, terus kirim hasilnya balik ke model dengan role tool. Model bakal olah hasilnya jadi jawaban natural. Ini polanya sama kayak OpenAI, jadi kalau kalian udah pernah bikin agent, konsepnya identik.

def getweather(city, unit="celsius"):
    return {"city": city, "temp": 27, "unit": unit, "condition": "cerah berawan"}

messages = [{"role": "user", "content": "Gimana cuaca di Bandung hari ini?"}]

response = client.chat.completions.create(
    model="accounts/fireworks/models/llama-v3p1-70b-instruct",
    messages=messages,
    tools=tools,
    toolchoice="auto",

)

msg = response.choices[0].message
if msg.toolcalls:
    call = msg.toolcalls[0]

    args = json.loads(call.function.arguments)
    result = getweather(args)


    messages.append(msg)
    messages.append({
        "role": "tool",
        "toolcallid": call.id,
        "content": json.dumps(result),
    })

    final = client.chat.completions.create(
        model="accounts/fireworks/models/llama-v3p1-70b-instruct",
        messages=messages,
    )
    print(final.choices[0].message.content)

import os
from fireworks.client import Fireworks

client = Fireworks(apikey=os.environ.get("FIREWORKSAPIKEY"))


response = client.chat.completions.create(
    model="accounts/fireworks/models/llama-v3p2-11b-vision-instruct",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Apa yang ada di gambar ini? Jelaskan detail."},
                {
                    "type": "imageurl",
                    "imageurl": {"url": "https://images.unsplash.com/photo-1518791841217-8f162f1e1131"},

                },
            ],
        }
    ],
)

print(response.choices[0].message.content)

import base64

def encodeimage(path):
    with open(path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

b64 = encodeimage("kucing.jpg")


response = client.chat.completions.create(
    model="accounts/fireworks/models/llama-v3p2-11b-vision-instruct",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Deskripsikan gambar ini."},
                {
                    "type": "imageurl",
                    "imageurl": {"url": f"data:image/jpeg;base64,{b64}"},

                },
            ],
        }
    ],
)

print(response.choices[0].message.content)

import os
from fireworks.client import Fireworks

client = Fireworks(apikey=os.environ.get("FIREWORKSAPIKEY"))

response = client.embeddings.create(
    model="nomic-ai/nomic-embed-text-v1.5",
    input=["Fireworks AI itu cepat", "Platform inference untuk open LLM"],
)

for item in response.data:
    print(len(item.embedding), item.embedding[:5])

import json

examples = [
    {"messages": [
        {"role": "user", "content": "Apa itu latency?"},
        {"role": "assistant", "content": "Latency adalah waktu tunda antara permintaan dan respons."},
    ]},
    {"messages": [
        {"role": "user", "content": "Apa itu throughput?"},
        {"role": "assistant", "content": "Throughput adalah jumlah permintaan yang bisa diproses per satuan waktu."},
    ]},
]

with open("dataset.jsonl", "w", encoding="utf-8") as f:
    for ex in examples:
        f.write(json.dumps(ex, ensureascii=False) + "\n")

# Login ke Fireworks
firectl signin

Upload dataset
firectl create dataset my-dataset dataset.jsonl

Mulai fine-tuning job dengan LoRA
firectl create fine-tuning-job \
  --base-model accounts/fireworks/models/llama-v3p1-8b-instruct \
  --dataset my-dataset \
  --output-model my-tuned-model

import time
from fireworks.client import Fireworks

client = Fireworks(apikey=os.environ.get("FIREWORKSAPIKEY"))


def chatwithretry(messages, model, maxretries=3):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(model=model, messages=messages)
        except Exception as e:
            wait = 2  attempt
            print(f"Error: {e}. Retry dalam {wait} detik...")
            time.sleep(wait)
    raise RuntimeError("Gagal setelah beberapa percobaan")

Keenam, pertimbangkan deployment option sesuai skala. Kalau traffic kalian masih kecil atau lagi prototyping, pakai serverless aja, bayar per token, praktis. Tapi kalau udah masuk produksi dengan traffic tinggi dan butuh latency yang konsisten, mending upgrade ke on-demand deployment biar dapet GPU khusus. Latency-nya lebih stabil dan kalian nggak kena antrian sama user lain.

Ketujuh, pakai temperature rendah buat task yang butuh konsistensi. Kalau kalian bikin sistem yang butuh output deterministik kayak ekstraksi data atau structured output, set temperature ke 0 atau mendekati 0. Kalau butuh kreativitas kayak nulis cerita, baru naikin.

Kedelapan, monitor penggunaan dan biaya. Fireworks dashboard nyediain info penggunaan token. Rajin cek biar nggak kaget di akhir bulan. Kalau perlu, set budget alert.

Conclusion

Oke temen-temen, itu dia tutorial lengkap tentang Fireworks AI. Kita udah bahas dari nol banget, mulai dari ambil API key, instalasi lewat pip install fireworks-ai maupun pakai OpenAI-compatible, terus chat completions, streaming, structured output dengan JSON mode, function calling buat bikin agent, vision model buat analisis gambar, embeddings buat RAG, sampai dasar-dasar fine-tuning pakai LoRA.

Yang aku pengen kalian ambil dari tutorial ini adalah, Fireworks AI itu pilihan yang solid banget kalau kalian butuh inference yang cepat, murah, dan fleksibel buat model open-source. Kompatibilitas sama format OpenAI bikin migrasinya gampang, dan fokus mereka di low-latency bikin platform ini cocok banget buat aplikasi produksi yang butuh respons kilat. Ditambah lagi opsi deployment dari serverless sampai dedicated, kalian bisa mulai kecil dan scale up seiring pertumbuhan aplikasi kalian.

Saran aku, mulai aja dulu dari yang simpel. Coba chat completions, terus eksplor streaming, baru masuk ke fitur canggih kayak function calling atau vision sesuai kebutuhan aplikasi kalian. Jangan lupa selalu perhatiin best practices soal keamanan, pemilihan model, dan manajemen biaya. Selamat ngoprek temen-temen, semoga tutorial ini bermanfaat dan bikin kalian makin pede bangun aplikasi AI kalian sendiri. Sampai ketemu di tutorial berikutnya!