API Grok 4.6: Dari Panggilan Pertama hingga Agen Pengguna Alat

Bagaimana Cara Menyiapkan API Grok 4.6 di Python?

Untuk memulai, Anda memerlukan kunci API SpaceXAI dan menginstal xai-sdk.

Mendapatkan kunci API dari console.x.ai

Untuk membuat kunci API Grok 4.6, kita masuk ke halaman pembuatan kunci API konsol SpaceX AI. Selanjutnya, klik tombol Create API Key di pojok kanan atas.

Formulir pembuatan kunci API cukup sederhana. Beri nama kunci agar kita tahu kunci tersebut milik proyek yang mana. Saya juga menyarankan selalu menetapkan tanggal kedaluwarsa untuk kunci API sebagai pengaman jika kunci tersebut sampai disalahgunakan.

Setelah kunci dibuat, kita menyalinnya dan menempelkannya ke file bernama .env yang kita buat di folder yang sama tempat kita akan menulis skrip Python. Dengan begitu, kita mudah memuat kunci di skrip tanpa harus menyimpannya di berkas kode, yang berisiko membuat kita tanpa sengaja mengekspos kunci saat membagikan atau mengunggah kode ke cloud.

File .env harus berisi konten berikut:

XAI_API_KEY=replace_with_the_api_key

Menginstal xai-sdk dan memuat kunci API SpaceXAI

Untuk terhubung ke SpaceXAI dengan kunci API, kita menggunakan paket xai-sdk. Praktik yang baik adalah membuat lingkungan terpisah untuk setiap proyek guna mencegah paket Python bertabrakan dengan paket dari proyek lain yang mungkin kita miliki. Untuk itu, kita akan menggunakan Anaconda dengan perintah berikut:

conda create -yn grok-46 python=3.10
``` 
This creates an environment named grok-46 that we can activate using:
```bash
conda activate grok-46

Setelah aktif, kita bisa menginstal paket yang diinginkan. Untuk sekarang, mari mulai dengan:

• xai-sdk: Paket resmi SpaceXAI yang digunakan untuk membuat permintaan ke API mereka.

• python-dotenv: Paket utilitas yang memudahkan pemuatan kunci API dari file .env.

Untuk menginstalnya, gunakan perintah:

pip install xai-sdk python-dotenv

Berikut cara memuat kunci API dan membuat SpaceXAI Client di Python:

from dotenv import load_dotenv
from xai_sdk import Client

load_dotenv()

client = Client()

Perhatikan bahwa kode ini belum membuat permintaan. Kita akan mempelajari cara melakukannya selanjutnya.

Membeli kredit API SpaceXAI

Untuk menggunakan API Grok 4.6, kita juga perlu membeli kredit di platform API mereka. Tanpa kredit, permintaan API akan ditolak. Caranya, buka menu Credits di bagian bawah bilah samping, klik Add credits, lalu tambahkan jumlah yang Anda inginkan.

Seberapa Mahal Grok 4.6 lewat API?

Permintaan ke Grok 4.6 ditagihkan per token. Harga dasar adalah $2 per satu juta token input dan $6 per satu juta token output.

Penting untuk dicatat bahwa Grok 4.6 adalah model penalaran. Penalaran dilakukan sebagai dialog internal dan juga mengonsumsi token, yang ditagihkan sebagai token output. Kita akan mempelajari nanti cara mengontrol jumlah penalaran yang dilakukan model untuk suatu permintaan.

Token yang di-cache jauh lebih murah, hanya $0,5 per satu juta token.

Seperti yang akan kita pelajari, Grok memiliki tiga alat bawaan yang ditagihkan terpisah dari token: pencarian web, X search, dan eksekusi kode. Semuanya dihargai $5,00 per 1.000 panggilan.

Untuk konteks panjang, perlu dicatat bahwa semua token dalam prompt yang melebihi ambang 200K ditagihkan dengan tarif dua kali lipat.

Bagaimana Cara Melakukan Panggilan API Grok 4.6 Pertama Anda?

Mari kita bangun dari kode sebelumnya untuk menggunakan klien SpaceXAI mengirim permintaan ke Grok 4.6.

Untuk mengirim permintaan ke Grok 4.6, kita menginisialisasi sesi chat yang menargetkan grok-4.6 dengan client.chat.create() dan menambahkan prompt kita ke riwayat percakapan menggunakan chat.append(user()).

Terakhir, pemanggilan chat.sample() mengirim percakapan ke model untuk menghasilkan respons, yang kita tampilkan dengan mencetak response.content.

from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import user

load_dotenv()

client = Client()

chat = client.chat.create(model="grok-4.6")
chat.append(user("Explain how the Transformer attention mechanism works using a simple analogy."))

response = chat.sample()
print(response.content)

Saat menggunakan Grok seperti ini, kita menerima respons sekaligus, jadi kita perlu menunggu sampai Grok selesai menghasilkan seluruh jawaban sebelum mendapatkan apa pun. Kita dapat memperoleh balasan kata demi kata menggunakan streaming. 

Streaming respons

Alih-alih menunggu respons lengkap dengan chat.sample(), kita dapat menggunakan chat.stream() untuk menerima output model secara real time.

# … Same code as before

chat.append(user("Explain how the Transformer attention mechanism works using a simple analogy."))

for response, chunk in chat.stream():
    print(chunk.content, end="", flush=True)

print()

Kode ini melakukan iterasi atas stream, menghasilkan objek potongan secara bertahap dan mencetak setiap bagian teks baru (chunk.content) ke konsol segera setelah tiba, menciptakan pengalaman streaming token demi token yang responsif.

Saat menjalankan kode ini, kita perhatikan bahwa model tetap membutuhkan waktu sebelum mulai menghasilkan token. Alasannya adalah Grok 4.6 merupakan model penalaran. Secara default, sebelum menghasilkan kata pertama yang terlihat dari jawaban akhir, model menjalani fase penalaran "chain-of-thought" internal.

Kita dapat memperbarui kode di atas untuk juga menampilkan proses penalaran model, seperti ini:

# … Same code as before

chat.append(user("Explain how the Transformer attention mechanism works using a simple analogy."))

print("--- Reasoning ---")
is_first_content = True

for response, chunk in chat.stream():
    if chunk.reasoning_content:
        print(chunk.reasoning_content, end="", flush=True)
    if chunk.content:
        if is_first_content:
            print("\n\n--- Response ---")
            is_first_content = False
        print(chunk.content, end="", flush=True)

print()

Stream Grok 4.6 setelah cuplikan ini menyertakan dua jenis token:

• Token chain-of-thought internal model
• Jawaban akhir

Skrip ini membedakan keduanya dengan memeriksa chunk.reasoning_content untuk melakukan streaming proses berpikir langkah demi langkah Grok terlebih dahulu, lalu mencetak chunk.content saat respons akhir dimulai.

Bagaimana Cara Mengatur Upaya Penalaran di Grok 4.6?

Seperti yang kita lihat di atas, seperti model AI frontier lainnya, Grok 4.6 mengandalkan chain of thought tersembunyi. Sebelum menghasilkan satu kata pun dari jawaban akhirnya, model ini menghasilkan ribuan token penalaran untuk mengeksplorasi solusi, memeriksa ulang logika, dan memperbaiki kesalahannya sendiri.

Parameter reasoning_effort memungkinkan kita mengontrol seberapa besar upaya yang dicurahkan model dalam proses penalaran ini. Karena kita juga membayar token penalaran, bukan hanya jawaban akhir, ini adalah parameter penting untuk dikelola jika ingin menekan biaya.

Grok 3 mini sudah memungkinkan pengembang menyetel reasoning_effort, namun Grok 4 menghapus kontrol itu. Penalarannya selalu aktif dan tidak bisa disesuaikan. SpaceXAI menghadirkan kembali kontrol ini di lini Grok 4.x (4.3 dan 4.5), dan Grok 4.6 juga mendukungnya, dengan low, medium, high (default), dan xhigh.

Untuk mengatur upaya penalaran, kita menggunakan parameter reasoning_effort saat menginisialisasi chat dengan client.chat.create(). Nilainya berupa string dengan tingkat upaya yang kita inginkan. Nilai default adalah "high". Berikut contoh cara menyetelnya ke "low":

chat = client.chat.create(
    model="grok-4.6",
    reasoning_effort="low"
)

Membandingkan low vs high pada prompt yang sama

Saya telah mencoba banyak tugas menggunakan low dan high, seperti membangun permainan kecil, membuat skrip untuk menganalisis data penggajian dengan berbagai format mata uang yang buruk, serta menyelesaikan teka-teki logika.

Dalam semua kasus ini, model mampu memberikan solusi serupa dengan penalaran rendah maupun tinggi.

Untuk melihat perbedaannya, kita butuh tugas yang gagal jika berhenti di tengah penalaran. Jadi saya beralih ke teka-teki dengan banyak solusi. Ini prompt yang saya gunakan:

Solve the following alphametic puzzle, in which each letter represents a unique digit from 0 to 9. The leading digits cannot be zero.

GROK + DATA = CAMP

Provide a list of all solutions. For each solution, show a single line with the final addition to prove it works.

Pada kedua tingkat penalaran, Grok 4.6 menemukan solusi yang benar. Namun, saat disetel ke low, anggaran penalarannya habis sebelum dapat menyelesaikan tugas. Akibatnya, ia merespons dengan solusi yang tidak lengkap. Dengan tingkat penalaran tinggi, Grok 4.6 menemukan semua 264 solusi.

Sebagai perbandingan, dengan penalaran low, ia menggunakan 16.422 token penalaran, sementara dengan high ia menggunakan 56.455.

Kapan xhigh sepadan dengan tambahan token?

Jika pengaturan high saja dapat menuntaskan teka-teki logika kompleks dan skrip pemrosesan data, mengapa ada yang mau membayar konsumsi token masif dari xhigh?

Saya percaya untuk 99% tugas pemrograman dan data science harian, xhigh berlebihan dan hanya akan menguras anggaran API Anda.

Namun, xhigh menjadi sangat penting saat Anda beralih dari meminta model bertindak sebagai asisten koding menjadi bertindak sebagai agen otonom. Pada dasarnya Anda membayar agar model secara agresif meninjau pekerjaannya sendiri, menemui jalan buntu, dan menulis ulang logikanya sebelum menampilkan output akhir kepada Anda.

Saran saya adalah mulai dari low dan hanya meningkatkannya jika model secara sistematis gagal pada suatu tugas. Memang benar dalam beberapa kasus ini berarti kita membayar berkali-kali untuk masalah yang sama, tetapi sebagian besar waktu kita akan mendapatkan solusi yang baik dengan biaya jauh lebih kecil.

Bagaimana Cara Mengirim Gambar ke API Grok 4.6?

Grok 4.6 bersifat multimodal dan karena itu dapat menangani data gambar. 

Mengirim gambar melalui URL

Cara termudah untuk memberikan gambar ke model adalah menggunakan URL. Kita dapat menyediakannya sebagai argumen kedua untuk pesan pengguna:

from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import image, user

load_dotenv()
client = Client()

chat = client.chat.create(model="grok-4.6")

image_url = "https://images.pexels.com/photos/25810993/pexels-photo-25810993.jpeg"

chat.append(
    user(
        "Describe what you see in this image in detail.",
        image(image_url=image_url),
    )
)

for response, chunk in chat.stream():
    print(chunk.content, end="", flush=True)

print()

Mengirim gambar melalui unggahan file

Sering kali, kita ingin menggunakan gambar lokal alih-alih URL. Ini bisa dilakukan dengan memuat gambar sebagai string base64. Fungsi encode_image() dapat melakukannya untuk kita:

import base64
import mimetypes

def encode_image(image_path: str) -> str:
    mime_type, _ = mimetypes.guess_type(image_path)
    if not mime_type:
        mime_type = "image/jpeg"
    with open(image_path, "rb") as image_file:
        encoded_string = base64.b64encode(image_file.read()).decode("utf-8")
    return f"data:{mime_type};base64,{encoded_string}"

Setelah gambar dikodekan, kita menyediakannya ke model dengan cara yang sama:

chat.append(
    user(
        "Describe what you see in this image in detail.",
        image(image_url=encode_image("image.png")),
    )
)

Meskipun mendukung input gambar, Grok 4.6 hanya menghasilkan teks. Jika Anda ingin mempelajari lebih lanjut tentang pembuatan gambar SpaceXAI, saya merekomendasikan membaca tutorial Grok Imagine API kami.

Bagaimana Cara Mengaktifkan Alat pada Agen Grok 4.6?

Grok 4.6 menyediakan akses ke tiga alat sisi server yang berguna dan menawarkan kemungkinan membuat alat kustom.

Memanggil alat sisi server (pencarian web, X search, eksekusi kode)

Grok 4.6 dilengkapi tiga alat server:

• Pencarian web: Memungkinkan agen melakukan pencarian web untuk memperkuat jawabannya.
• X search: Mengkueri data platform real-time dari X.
• Eksekusi kode: Mengeksekusi kode di sandbox untuk membantu menjawab kueri.

Alat-alat ini berjalan di server SpaceXAI, dan setiap pemanggilan alat ditagihkan terpisah dari token.

Untuk mengaktifkannya, kita perlu mengimpornya dan menyediakannya saat menginisialisasi chat dengan client.chat.create():

from xai_sdk.tools import code_execution, web_search, x_search
chat = client.chat.create(
    model="grok-4.6",
    tools=[web_search(), x_search(), code_execution()],
)

Saat melakukan streaming respons, kita dapat mengetahui apakah agen menggunakan alat dengan memeriksa flag chunk.tool_calls.

Berikut cuplikan cara memproses respons streaming dengan menampilkan kepada pengguna saat agen menggunakan alat:

for response, chunk in chat.stream():
    for tool_call in chunk.tool_calls:
        print(f"\n--> Agent is calling tool: {tool_call.function.name}\n", flush=True)
    if chunk.content:
        print(chunk.content, end="", flush=True)

Contoh skrip lengkap dengan alat sisi server dapat ditemukan di repositori GitHub pendamping saya.

Mengimplementasikan alat lokal kustom

Di atas alat sisi server tersebut, kita juga dapat melengkapi agen Grok 4.6 dengan alat kustom. Mari lihat cara mengimplementasikan alat yang memungkinkan agen membaca dan menulis file lokal.

Untuk mengimplementasikan alat kustom, kita membutuhkan dua hal:

1. Spesifikasi alat menggunakan objek resmi tool() dari SDK SpaceXAI.

2. Implementasi Python untuk alat tersebut, yaitu kode yang ingin kita jalankan saat alat dipanggil.

Spesifikasi alat terdiri dari:

• Nama fungsi Python yang akan dipanggil.
• Deskripsi yang menjelaskan apa yang dilakukan alat. Ini krusial karena menentukan kapan agen memanggil alat.
• Spesifikasi parameter fungsi.

Di bawah ini adalah fungsi yang dapat kita gunakan untuk mengimplementasikan alat pembaca file lokal:

def execute_read_file(file_path: str) -> str:
    print(f"\n🔒 [Permission Request] Grok wants to read local file: '{file_path}'")
    confirm = input("Allow access? [y/N]: ").strip().lower()
    if confirm not in ("y", "yes"):
        print(f"❌ Denied access to '{file_path}'")
        return f"Permission denied by user. Access to file '{file_path}' was not granted."

    if not os.path.exists(file_path):
        return f"Error: File '{file_path}' does not exist."

    try:
        with open(file_path, "r", encoding="utf-8") as f:
            content = f.read()
        print(f"✅ Read {len(content)} characters from '{file_path}'\n")
        return content
    except Exception as e:
        return f"Error reading file '{file_path}': {e}"

Demi alasan keamanan, kita mengimplementasikan alat agar selalu meminta izin pengguna sebelum membaca file. Ini mencegah kita tanpa sengaja memberikan data pribadi ke agen.

Berikut spesifikasi alat untuk fungsi ini:

from xai_sdk.chat import tool
read_file_tool = tool(
    name="read_local_file",
    description="Reads the text contents of a local file given its relative or absolute path. Use this whenever the user asks to inspect, summarize, or analyze a local file.",
    parameters={
        "type": "object",
        "properties": {
            "file_path": {
                "type": "string",
                "description": "The path to the local file to read.",
            }
        },
        "required": ["file_path"],
    },
)

Kode untuk menulis ke file serupa dan dapat ditemukan di berkas tools.py pada repositori.

Bagaimana Cara Menjalankan Loop Agen Pengguna Alat dengan Grok 4.6?

Pada bagian ini, kita menggabungkan semua yang telah dipelajari untuk membangun loop agenik Grok 4.6 di mana kita bisa berbicara dengan agen yang mampu melakukan pekerjaan nyata dengan bertindak pada file lokal sambil memperkuat jawaban dengan data daring melalui pencarian.

Agen akan bekerja seperti terlihat pada diagram di bawah. Pengguna mengirim prompt, lalu agen membalas dengan menggunakan alat jika perlu. Kemudian jawaban dikirim kembali ke pengguna, dan pengguna dapat terus berinteraksi dengan agen. 

Agen melacak seluruh percakapan dengan menggunakan fungsi chat.append() untuk menambahkan prompt pengguna, respons, dan hasil alat. Hasil alat harus dibungkus dalam instance tool_result().

Berikut implementasi agen lengkapnya:

import json
from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import tool_result, user
from xai_sdk.tools import code_execution, web_search, x_search
from tools import (
    execute_read_file,
    execute_write_file,
    read_file_tool,
    write_file_tool,
)

load_dotenv()

# 1. Initialize the chat client with both server-side and client-side tools
client = Client()
chat = client.chat.create(
    model="grok-4.6",
    tools=[web_search(), x_search(), code_execution(), read_file_tool, write_file_tool],
)

# 2. Interactive chat loop
while True:
    try:
        prompt = input("> ")
    except (EOFError, KeyboardInterrupt):
        print()
        break

    if not prompt.strip():
        continue
    if prompt.strip().lower() in ("exit", "quit"):
        break

    # Append the user prompt to the conversation
    chat.append(user(prompt))

    # Agent loop: keeps running until Grok finishes (no further client tool calls)
    print("How can I help you?\n")
    while True:
        response = None
        announced_tools = set()
        started_content = False

        for response, chunk in chat.stream():
            # Announce tool calls
            if chunk.tool_calls:
                for tc in chunk.tool_calls:
                    name = getattr(tc.function, "name", "")
                    tc_id = getattr(tc, "id", None) or name
                    if tc_id and tc_id not in announced_tools:
                        announced_tools.add(tc_id)
                        display_name = name or "tool"
                        print(f"\n⚙️  [Agent Tool] Calling: {display_name}...", flush=True)

            # Stream generated content
            if chunk.content:
                if not started_content:
                    print("\nGrok > ", end="", flush=True)
                    started_content = True
                print(chunk.content, end="", flush=True)

        if response:
            chat.append(response)

        # Check if Grok triggered client-side tools
        client_tool_executed = False
        if response and response.tool_calls:
            for tool_call in response.tool_calls:
                fn_name = tool_call.function.name
                if fn_name == "read_local_file":
                    client_tool_executed = True
                    try:
                        args = json.loads(tool_call.function.arguments)
                        file_path = args.get("file_path", "")
                    except Exception:
                        file_path = tool_call.function.arguments or ""
                    
                    result = execute_read_file(file_path)
                    chat.append(tool_result(result, tool_call_id=tool_call.id))

                elif fn_name == "write_local_file":
                    client_tool_executed = True
                    try:
                        args = json.loads(tool_call.function.arguments)
                        file_path = args.get("file_path", "")
                        content = args.get("content", "")
                    except Exception:
                        file_path = ""
                        content = ""
                    
                    result = execute_write_file(file_path, content)
                    chat.append(tool_result(result, tool_call_id=tool_call.id))

        # If Grok called a client-side tool, re-enter the loop so Grok processes the tool result
        if client_tool_executed:
            continue
        
        break

    print("\n")

Menguji agen Grok 4.6 untuk melakukan analisis portofolio saham

Untuk menguji agen, saya membuat file CSV portofolio saham contoh. File ini cukup sederhana dan mencantumkan saham, khususnya tanggal pembelian dan harga beli. 

Idenya adalah meminta agen untuk:

1. Memuat file CSV.
2. Melakukan pencarian web untuk mendapatkan harga terkini masing-masing saham.
3. Memperbarui CSV dengan menambahkan kolom baru berisi harga terkini.
4. Meminta agen membuat laporan portofolio yang menampilkan perkembangan terbaru di sektor kita.

Di bawah ini adalah tangkapan layar interaksi dengan Agen untuk langkah 1 hingga 3.

Kita melihat bahwa agen menggunakan pencarian web, eksekusi kode, dan alat kustom yang kita buat untuk membaca dan menulis file lokal. Pada akhirnya, ia memperbarui file CSV dengan menambahkan kolom baru berisi harga saham terkini.

Karena agen berjalan dalam loop, kita dapat melanjutkan percakapan. Pada interaksi berikutnya, saya memintanya mencari berita terkait saham-saham ini, menganalisis keragaman portofolio, dan membuat laporan markdown.

Jika Anda penasaran dengan laporan yang dibuatnya, laporan tersebut ada di repositori GitHub.

Menguji agen pada tugas dunia nyata seperti menganalisis portofolio saham benar-benar menunjukkan kemampuan Grok 4.6. Dengan melakukan pencarian web, menjalankan kode, dan memanfaatkan alat lokal secara mandiri, model ini dengan mudah menangani permintaan yang rumit.

Caching prompt dan jurang harga 200k

Saat mengimplementasikan agen multi-giliran, kita harus memastikan percakapan di-cache agar model tidak perlu memroses ulang seluruh riwayat pada setiap interaksi. Jika tidak dilakukan, biayanya bisa sangat besar.

Caching terjadi secara otomatis, tetapi entri cache disimpan per server, dan secara default, permintaan dapat dialihkan ke server yang berbeda dan melewatkan cache. Untuk memaksimalkan hit cache, kita menyediakan pengenal percakapan yang stabil sehingga semua permintaan dalam satu percakapan mencapai server yang sama. Cara memberikannya bergantung pada API:

• xai-sdk (gRPC): x-grok-conv-id, diberikan sebagai metadata gRPC saat klien diinisialisasi

• OpenAI Responses API: prompt_cache_key, diatur di body permintaan

Cuplikan berikut menunjukkan caranya:

import uuid
from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import tool_result, user

load_dotenv()

# 1. Generate a unique ID for the conversation loop
conv_id = str(uuid.uuid4()) 

# 2. Pass the ID when initializing the Client
client = Client(
    metadata=(("x-grok-conv-id", conv_id),)
)

# ... [the rest of the code remains the same]

Satu pertimbangan penting adalah bahwa penalti finansial menjadi sangat berat untuk percakapan yang ekstensif. Setelah total panjang prompt Anda mencapai atau melampaui 200 ribu token, API menerapkan pengali 2x, menagihkan seluruh permintaan dua kali lipat dari tarif standar.

Untuk mencegah loop multi-giliran melewati ambang 200 ribu ini, sangat disarankan menerapkan pemadatan konteks. Ini dilakukan dengan merangkum giliran percakapan yang lebih lama secara berkala atau menggeser jendela konteks. Strategi ini memastikan Anda terus mendapatkan manfaat dari hit cache murah pada instruksi inti sambil menghindari penalti finansial berat dari jendela konteks yang terus membesar.

Kesimpulan

Dalam tutorial ini, kita mempelajari cara menggunakan API SpaceXAI dengan Python untuk berinteraksi dengan Grok 4.6. Kita mempelajari dasar-dasar cara mengirim prompt teks dan gambar serta cara menangani output agar pengguna tahu apa yang sedang dikerjakan model. 

Dengan mempelajari cara menyediakan alat untuk model AI, kita kemudian dapat menggabungkan semuanya dan membangun agen AI yang mampu menggunakan Grok 4.6 untuk menyelesaikan tugas dunia nyata seperti menganalisis portofolio pasar saham. Terakhir, kita mempelajari bahwa menjalankan tugas dengan konteks panjang bisa sangat mahal, terutama jika kita tidak menggunakan caching.

Sebagai latihan untuk menguji apa yang Anda pelajari di sini, saya sarankan Anda mengimplementasikan caching di agen dan memperbarui output untuk menampilkan token penalaran juga. 

Jika Anda ingin memperdalam pengetahuan tentang membangun agen AI dengan API, saya merekomendasikan kursus Working with the OpenAI API. Tempat terbaik untuk mendalami agen AI adalah jalur keterampilan AI Agent Fundamentals.