API Grok 4: Panduan Langkah demi Langkah dengan Contoh

Mulai Menggunakan API Grok 4

Sebelum membuat permintaan pengguna pertama, kita memerlukan kunci API dan lingkungan Python yang dapat terhubung ke API Grok.

Membuat kunci API Anda

Untuk membuat kunci API yang dapat digunakan untuk mengautentikasi klien dengan API, Anda dapat mengikuti langkah-langkah berikut:

1. Kunjungi situs dokumentasi resmi xAI.
2. Masuk menggunakan akun X, xAI, atau Google. Jika Anda belum memiliki akun, Anda dapat mendaftar akun xAI baru.
3. Temukan opsi “Create an API key”. Masukkan nama untuk kunci Anda dan klik “save”.
4. Setelah kunci Anda muncul, salin segera. Anda tidak akan dapat melihatnya lagi nanti, namun Anda selalu bisa membuat yang baru jika diperlukan.
5. Di direktori proyek Anda, buat file bernama .env. Tempelkan kunci API Anda di dalamnya, gunakan format berikut:

XAI_API_KEY=<your_api_key_here>Didukung oleh

Harga API Grok 4

Meski menggunakan API bisa lebih terjangkau daripada memilih langganan premium, ini tidak gratis. Berbeda dengan paket SuperGrok, yang dimulai dari $30 per bulan dengan langganan tetap, biaya API sepenuhnya didasarkan pada tingkat penggunaan layanan. Namun, jika Anda ingin mengakses Grok 4 Heavy, polanya berbeda: Anda memerlukan langganan SuperGrok Heavy aktif ($300 per bulan), bahkan saat menggunakan API.

Untuk rincian biaya yang lebih lengkap, lihat halaman harga di xAI.

Sumber: xAI

Penetapan harga untuk API Grok berbasis penggunaan, diukur per satu juta token. Sebagai referensi, satu juta token kira-kira setara dengan 750.000 kata bahasa Inggris, baik sebagai input maupun output. Meskipun ukuran jendela konteksnya hampir dua kali lipat dibanding pendahulunya, Grok 4 dihargai persis sama dengan model Grok 3 standar. Anda akan membayar $3 untuk setiap satu juta token input dan $15 untuk setiap satu juta token output.

Untuk mengakses API, Anda perlu membeli kredit. Saat memulai, bijak untuk menggunakan kredit prabayar alih-alih penagihan otomatis—ini membantu menghindari tagihan tak terduga. Anda dapat membeli token dan melacak penggunaan di konsol xAI, di Invoices > Credits.

Menyiapkan lingkungan Python

Setelah Anda menyiapkan kunci API dan kredit, langkah berikutnya adalah menyiapkan lingkungan Python. Anda memerlukan dua paket untuk integrasi API yang lancar:

• python-dotenv untuk memuat kunci API Anda dari file .env sebagai variabel lingkungan.
• Klien openai untuk berinteraksi dengan API Grok 4.

Agar dependensi proyek tetap bersih, sebaiknya gunakan Anaconda. Setelah memasang Anaconda, buat lingkungan baru bernama grok4 dengan Python 3.10 dengan menjalankan:

conda create -n grok4 python=3.10
conda activate grok4Didukung oleh

Dengan lingkungan aktif, pasang paket yang diperlukan:

pip install python-dotenv openaiDidukung oleh

Persiapan akhir

Mari mulai dengan menulis skrip pertama kita. Mulai dengan mengimpor fungsi yang diperlukan dari paket yang telah Anda pasang, bersama os untuk mengakses kunci API Anda:

import os
from dotenv import load_dotenv
from openai import OpenAIDidukung oleh

Selanjutnya, gunakan load_dotenv() dari paket dotenv untuk memuat variabel lingkungan Anda, sehingga kunci API tersedia bagi skrip:

# Load environment variables
load_dotenv()Didukung oleh

Sekarang, inisialisasi klien API dengan meneruskan kunci API Anda (dari file .env) dan URL server Grok ke kelas OpenAI (kita akan menggunakan SDK OpenAI di tutorial ini, tetapi Grok 4 juga memiliki SDK Python xAI native, dan juga kompatibel dengan SDK Antrhopic). Tetapkan ke variabel client:

client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
)Didukung oleh

Dengan langkah-langkah ini, skrip Anda siap mengirim permintaan ke Grok 4.

Pengenalan Gambar dengan Grok 4

Sekarang setelah semuanya siap, mari uji pengenalan gambar, salah satu fitur baru Grok 4. Kita akan mendemonstrasikannya dengan mengunggah foto lasagna vegetarian di bawah ini dan meminta Grok mengidentifikasi bahan-bahan yang terlihat.

Untuk menganalisis gambar dengan API Grok 4, kita perlu mengirim permintaan yang mencakup gambar dan prompt. Cara yang direkomendasikan adalah menggunakan klien Python yang kompatibel dengan OpenAI, menentukan model sebagai grok-4 serta menyertakan URL gambar dan pertanyaan Anda dalam array messages. API akan mengembalikan respons terperinci yang mendeskripsikan konten gambar, yang dapat diakses di objek respons.

Sebelum mengirim permintaan, kita harus memastikan gambar memenuhi persyaratan API. Hanya format JPEG dan PNG yang didukung, dan ukuran file tidak boleh melebihi 20 MB. Gambar harus dapat diakses melalui tautan langsung, dan server harus mengirim header Content-Type yang benar (baik image/jpeg atau image/png).

Setelah mengimpor paket yang diperlukan, memuat variabel lingkungan, dan menyiapkan klien, kita dapat mengirim kueri seperti ini:

# Sending the query
response = client.chat.completions.create(
    model="grok-4",
    messages=[
    {
      "role": "user",
      "content": [
        {
          "type": "image_url",
          "image_url": {
            "url": "https://shorturl.at/mVDEh",
            "detail": "high"
          }
        },
        {
          "type": "text",
          "text": "Which ingredients do you notice on the picture?"
        }
      ]
    }
  ],
    max_tokens=2000,
    temperature=0.2,  # lower temperature for more deterministic answers
)

# Print the response
print(response.choices[0].message.content)Didukung oleh

Based on the picture, it looks like a delicious slice of vegetarian lasagna! Here's what I can clearly see in terms of ingredients (I'm basing this purely on visual cues, so it's not a full recipe—just what's noticeable):
### Main Visible Ingredients:
- **Pasta sheets/lasagna noodles**: The flat, layered pasta that's the base structure of the dish.
- **Tomato sauce**: A red, chunky sauce (likely marinara or similar) that's spread between layers and on top.
- **Cheese**:
  - Melted, bubbly cheese on top (probably mozzarella or Parmesan, given the golden-brown spots).
  - White, creamy cheese in the filling layers (looks like ricotta or cottage cheese).
- **Spinach (or similar greens)**: Dark green leaves mixed into the layers, giving it a veggie-packed look (this seems like a spinach lasagna variant).
- **Basil leaf**: A fresh green leaf garnishing the top for decoration and flavor.
It doesn't appear to have any meat (like ground beef or sausage), so it's likely a vegetarian version. If this is from a specific recipe or if you have more context, I could refine my observations! What do you think it is? 😊Didukung oleh

Dalam kasus ini, Grok bahkan mengenali bahwa ini versi vegetarian hanya dari gambar—cukup mengesankan!

Penalaran dengan Grok 4

Grok 4 dirancang untuk penalaran tingkat lanjut dan dapat menyelesaikan masalah kompleks selangkah demi selangkah. Namun, berbeda dengan beberapa model sebelumnya, Grok 4 tidak menampilkan jejak penalaran internalnya, sehingga Anda tidak dapat mengekstrak “proses berpikir” terperinci atau chain-of-thought sebagai bidang terpisah dari respons API. Output yang Anda terima adalah jawaban final, bukan langkah perantara atau konten penalaran mentah model.

Selain itu, Grok 4 tidak mendukung parameter reasoning_effort yang digunakan, misalnya, pada Grok 3 mini (untuk mempelajari cara menggunakan parameter tersebut, lihat tutorial API Grok 3). Ini berarti Anda tidak dapat menyesuaikan seberapa banyak “berpikir” yang dilakukan model sebelum mencapai kesimpulan akhir. Oleh karena itu, kueri penalaran apa pun disusun persis seperti kueri biasa.

Mari uji Grok dengan tugas penalaran lain terkait lasagna dan memintanya menampilkan penalaran dalam output.

# Send a basic reasoning query
response = client.chat.completions.create(
    model="grok-4",
    messages=[
        {"role": "user", "content": (
            "You want to cook lasagna for a dinner party, but several guests have dietary restrictions. One is vegetarian, one is lactose-intolerant, and another cannot eat gluten. You have six different lasagna recipes (classic, vegetarian, vegan, gluten-free, cheese-heavy, and meat-based). Which recipe or combination of recipes would best satisfy everyone, and what specific ingredient substitutions would you need to make? Explain your reasoning step by step."
        )}
    ],
    max_tokens=5000,
    temperature=0.2,  # lower randomness
)
# Print the final answer
print(response.choices[0].message.content)Didukung oleh

Below, I'll explain my reasoning step by step for selecting the best recipe (or combination of recipes) to satisfy all guests at your dinner party, including the vegetarian, the lactose-intolerant person, the gluten-intolerant person, and everyone else (who presumably have no restrictions). I'll base this on logical inferences about what each recipe likely contains, since the problem doesn't provide exact ingredient lists. Then, I'll recommend specific ingredient substitutions and why this approach works.
(...)
### Step 3: Selecting the Best Recipe or Combination
- **Recommended approach**: Use a **combination of the vegan and gluten-free recipes** to create a single modified lasagna that everyone can eat. Start with the vegan recipe as your base (it already handles no meat and no lactose/dairy), then incorporate elements from the gluten-free recipe (e.g., ingredient swaps to eliminate gluten). This results in a **vegan, gluten-free lasagna**.
  - Why not multiple lasagnas? Preparing separate dishes (e.g., one vegetarian, one gluten-free) could work but might not fully satisfy everyone in a shared meal—e.g., the lactose-intolerant guest couldn't eat a dairy-based vegetarian version. A single inclusive dish promotes unity at the party and simplifies cooking/serving. If you have time and oven space, you could make a small "classic" version on the side for unrestricted guests who prefer meat and cheese, but the modified vegan/gluten-free one would still be the core option.
  - Why this combination over others? Vegan + gluten-free covers all restrictions without needing to add meat or dairy (which would violate rules). Starting with gluten-free and making it vegan would require more substitutions (e.g., removing meat and cheese), while vegan is already "80% there." Other combos (e.g., vegetarian + gluten-free) would still need dairy removals for lactose intolerance, making them less efficient.
This approach ensures:
- The vegetarian can eat it (no meat).
- The lactose-intolerant can eat it (no dairy/lactose).
- The gluten-intolerant can eat it (no gluten).
- Others can eat it (it's still a flavorful lasagna, though it won't have "real" meat or cheese—unrestricted guests might find it less indulgent, but it's a fair compromise).
(...)Didukung oleh

Saya memotong respons Grok untuk menyorot poin-poin utama, tetapi bahkan dalam versi yang lebih singkat ini, jelas model menjalankan tugasnya dengan baik. Grok berjalan selangkah demi selangkah untuk

• Memahami pembatasan diet
• Mengevaluasi resep yang tersedia
• Memilih kombinasi resep terbaik
• Menyarankan penggantian bahan spesifik
• Memberikan kerangka resep yang telah dimodifikasi
• Kembali menjelaskan mengapa itu memuaskan semua orang
• Membahas potensi kekurangan dan alternatif

Pemanggilan Fungsi dengan Grok 4

Seperti pendahulunya, Grok 4 mendukung pemanggilan fungsi. Ini memungkinkan model berinteraksi langsung dengan alat dan layanan eksternal. Artinya Grok tidak terbatas pada pembuatan teks—ia juga dapat melakukan tindakan seperti mengambil pembaruan cuaca, memeriksa waktu acara, menganalisis catatan basis data, atau bahkan mengoperasikan perangkat rumah pintar.

Saat Anda mengirim permintaan, Grok dapat menentukan apakah ia memerlukan data tambahan dan akan meminta fungsi tertentu dipanggil dengan parameter yang tepat. Klien Python menangani eksekusi fungsi ini secara lokal, meneruskan hasilnya kembali ke Grok, lalu Anda menerima jawaban lengkap yang beralasan baik.

Persiapan

Untuk bekerja dengan pemanggilan fungsi, kita perlu mengimpor paket json, yang memungkinkan kita mengakses struktur argumen dari fungsi mana pun yang dipanggil Grok. Selanjutnya, kita mendefinisikan fungsi callback yang akan dipanggil Grok saat ia meminta data tertentu.

Untuk contoh ini, fungsi suggest_lasagna_recipe adalah fungsi Python sederhana yang mengembalikan saran resep tetap. Pendekatan hard-coded ini membuat demonstrasi tetap sederhana dan menghindari ketergantungan pada layanan eksternal.

import json

# Define the callback function
def suggest_lasagna_recipe(ingredients: list) -> dict:
    # Very simplified logic for demo purposes
    if "zucchini" in ingredients:
        return {"recipe": "Vegetarian Zucchini Lasagna"}
    if "beef" in ingredients:
        return {"recipe": "Classic Beef Lasagna"}
    if "tofu" in ingredients:
        return {"recipe": "Vegan Tofu Lasagna"}
    return {"recipe": "Basic Cheese Lasagna"}Didukung oleh

Kita juga perlu mendefinisikan alat yang dapat dipanggil Grok. Ini melibatkan penentuan nama alat, tujuan, dan parameter yang diperlukan dalam skema JSON. Skema ini dikirim ke Grok bersama permintaan, memberi tahu bahwa ia dapat memanggil alat ini kapan pun membutuhkan informasi tambahan untuk mendukung penalarannya.

# Define the JSON schema for the tool
tools = [
    {
        "type": "function",
        "function": {
            "name": "suggest_lasagna_recipe",
            "description": "Suggests a lasagna recipe based on available ingredients.",
            "parameters": {
                "type": "object",
                "properties": {
                    "ingredients": {
                        "type": "array",
                        "items": {"type": "string"},
                        "description": "List of available ingredients"
                    }
                },
                "required": ["ingredients"]
            }
        }
    }
]Didukung oleh

Terakhir, kamus tools_map menghubungkan nama fungsi yang digunakan Grok ke fungsi Python sebenarnya dalam kode Anda. Pemetaan ini memungkinkan klien mengeksekusi panggilan fungsi yang diminta secara benar.

# link the function names to the functions
tools_map = {
    "suggest_lasagna_recipe": suggest_lasagna_recipe
}Didukung oleh

Walau mendefinisikan skema alat secara manual bekerja baik untuk proyek sederhana, menggunakan pustaka validasi data seperti Pydantic sangat direkomendasikan seiring pertumbuhan proyek Anda. Pydantic menyediakan validasi otomatis input fungsi, penanganan error yang lebih baik, dan menghasilkan kode yang lebih bersih serta mudah dirawat.

Eksekusi

Mari lihat apakah Grok menggunakan fungsi kita saat diminta resep lasagna. Berikut alur kerja pemanggilan fungsinya:

1. Pertama, kita mengirim pertanyaan pengguna—“Lasagna apa yang bisa saya buat, dengan bahan yang saya punya?”—ke Grok, bersama dengan tools yang tersedia. 
2. Grok lalu meninjau permintaan dan, jika menentukan bahwa pemanggilan fungsi diperlukan, ia meminta resep dengan memicu fungsi lokal kita. Jika tidak ada pemanggilan alat, kita cukup menggunakan jawaban awal Grok.
3. Saat pemanggilan alat diminta, kita menjalankan fungsi lokal yang sesuai dan menambahkan hasilnya ke riwayat pesan yang sedang berlangsung.
4. Riwayat yang diperbarui ini kemudian dikirim kembali ke Grok, memungkinkannya menyelesaikan penalaran dan memberikan jawaban akhir yang kontekstual.

# Step 1: Send the initial user request
messages = [
    {"role": "user", "content": "I have beef, ricotta, and tomato sauce. Which lasagna can I make?"}
]

response = client.chat.completions.create(
    model="grok-4",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

# Step 2: Check if a tool call was requested
tool_calls = getattr(response.choices[0].message, "tool_calls", [])


if tool_calls:
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        print(f"{function_name} successfully called")
        function_args = json.loads(tool_call.function.arguments)

        # Find and call the matching local function
        if function_name in tools_map:
            function_result = tools_map[function_name](**function_args)

            # Step 3: Add the function result back to the message history
            messages.append(response.choices[0].message)  # Assistant's tool call message
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(function_result)
            })

            # Step 4: Send a new request including the tool response
            final_response = client.chat.completions.create(
                model="grok-4",
                messages=messages,
                tools=tools,
                tool_choice="auto"
            )

            # Print the final answer
            print("\nFinal Answer:")
            print(final_response.choices[0].message.content)
   
else:
    # No tool call: respond directly
    print("\nNo tool call was requested. Final Answer:")
    print(response.choices[0].message.content)Didukung oleh

suggest_lasagna_recipe successfully called

Final Answer:
Based on your available ingredients (beef, ricotta, and tomato sauce), you can make a **Classic Beef Lasagna**! (...)Didukung oleh

Seperti yang kita lihat, Grok memanggil fungsi kita dan menyarankan resep yang sesuai.

Anda mungkin juga memperhatikan argumen tool_choice pada permintaan awal. Secara default, “auto” membiarkan Grok memutuskan apakah dan fungsi mana yang akan dipanggil. Jika Anda menginginkan kontrol lebih, Anda dapat memaksa pemanggilan fungsi tertentu, menentukan fungsi mana yang digunakan, atau mematikan pemanggilan fungsi sepenuhnya dengan mengubah parameter ini.

Output Terstruktur dengan Grok 4

Mirip dengan pemanggilan fungsi, output terstruktur adalah fitur yang diperkenalkan dengan Grok 3. Fitur ini memungkinkan Grok memberikan jawaban dalam format ketat seperti JSON alih-alih teks biasa. Pendekatan ini membuat parsing, validasi, dan penggunaan respons model dalam aplikasi atau alur kerja Anda menjadi jauh lebih mudah.

Dengan menyiapkan skema terlebih dahulu, Anda dapat memastikan output Grok selalu konsisten, dapat dibaca mesin, dan siap untuk diproses lebih lanjut. Ini sangat berguna saat Anda perlu mengekstrak data terstruktur dari dokumen atau mengirim konten yang dihasilkan AI langsung ke basis data, dasbor, atau alat otomatisasi, tanpa khawatir tentang parsing teks yang tidak andal.

Untuk mendefinisikan skema output, kita menggunakan Pydantic, yang membuat penyusunan data kompleks menjadi lebih sederhana dan mudah dibaca (tutorial Pydantic ini akan membantu Anda mempelajari lebih lanjut). Untuk ini, Anda perlu mengimpor BaseModel dan Field dari pydantic. Karena output kita berisi daftar bahan, kita juga mengimpor List dari modul typing Python untuk memperjelas tipe setiap elemen daftar.

Walau kita bisa menyiapkan skema menggunakan JSON biasa, terkadang Grok mengembalikan output yang tidak persis cocok dengan struktur yang diharapkan. Maknanya mungkin sama, tetapi skemanya bisa berbeda, yang dapat menimbulkan masalah jika aplikasi Anda membutuhkan format tertentu. Ini terutama berlaku untuk elemen bersarang seperti daftar. Itulah mengapa saya merekomendasikan menggunakan Pydantic—ini membantu memastikan output terstruktur divalidasi dan di-parse secara andal setiap saat.

Dalam contoh kita, skema—bernama Recipe—mencakup namanya, jumlah porsi, dan daftar bahan. Setiap Ingredient didefinisikan oleh namanya, jumlah yang dibutuhkan untuk resep, ketersediaannya, harga per kilogram, serta informasi apakah bahan tersebut vegetarian, vegan, atau bebas gluten. Ada baiknya menetapkan nilai default di skema itu sendiri, seperti yang kita lakukan untuk jumlah porsi.

# import additionally needed packages
from pydantic import BaseModel, Field
from typing import List

# Define the schema for the structured output
class Ingredient(BaseModel):
    name: str = Field(description="Name of the ingredient")
    amount: int = Field(description="Amount in g needed for recipe")
    is_at_home: bool = Field(description="Is the item already at home?")
    price: float = Field(description="Price of the ingredient in USD per kg")
    is_vegetarian: bool = Field(description="Is the ingredient vegetarian?")
    is_vegan: bool = Field(description="Is the ingredient vegan?")
    is_gluten_free: bool = Field(description="Is the ingredient gluten-free?")

class Recipe(BaseModel):
    name: str = Field(description="The name of the recipe")
    portions: int = Field(default=4, description="Amount of portions")
    ingredients: List[Ingredient] = Field(description="List of ingredients for the recipe")Didukung oleh

Ada beberapa detail yang perlu diingat saat membuat permintaan. Alih-alih menggunakan client.chat.completions.create(), kita ingin memanggil client.beta.chat.completions.parse(). Ini memberi sinyal kepada Grok bahwa kita mengharapkan output dalam format tertentu, dan skema Recipe kita diteruskan sebagai argumen response_format.

Akan sangat membantu untuk menempatkan semua instruksi kunci tugas di sistem prompt. Ini membuat Grok 4 tetap fokus dan konsisten sepanjang percakapan. Karena skema didefinisikan terpisah, prompt pengguna dapat berfokus pada tugas itu sendiri, tanpa perlu mencantumkan bidang yang diperlukan untuk output JSON.

Misalnya, Anda bisa mengatur Grok untuk berperan sebagai koki Italia, memastikan semua resep yang dihasilkannya autentik Italia, sehingga Anda tidak akan menemukan nanas menyelinap ke pizza Anda!

# Send a prompt and request structured output
completion = client.beta.chat.completions.parse(
    model="grok-4",
    messages=[
        {"role": "system", "content": (
        "You are a master chef specialized in italian cuisine."
        "When asked about recipes, return the output in structured JSON format following the provided schema, without any extra text."
        )},
        {"role": "user", "content": (
        "I have beef, ricotta, and tomato sauce, and want to cook for 4 persons. Which lasagna can I make?"
        )}
    ],
    response_format=Recipe,
)Didukung oleh

Setelah kita mengurai output terstruktur Grok 4, manfaatnya dibanding teks biasa menjadi jelas. Kita dapat dengan mudah menata ulang dan menyesuaikan informasi sesuai kebutuhan, atau bahkan mengirim titik data tertentu langsung ke alur kerja otomatis. Dalam contoh kita, ini berarti kita dapat dengan cepat mengalikan harga bahan per kilogram dengan jumlah yang dibutuhkan, menjumlahkan biaya berdasarkan apa yang sudah ada di dapur, dan menghitung harga akhir per porsi hanya dalam beberapa langkah.

# Access the parsed result
recipe = completion.choices[0].message.parsed


price = 0 # initialize price variable
print(f"Recipe: {recipe.name}")
print("Ingredients:")
for i in recipe.ingredients:
    print("- " + i.name + " " + str(i.amount) + " g")
    if not i.is_at_home:
        price += (i.price * i.amount / 1000)
print(f"Price per portion: USD {round((price/recipe.portions), 2)}")Didukung oleh

Recipe: Classic Beef Lasagna
Ingredients:
- Ground beef 500 g
- Ricotta cheese 400 g
- Tomato sauce 800 g
- Lasagna noodles 300 g
- Mozzarella cheese 300 g
- Parmesan cheese 100 g
- Onion 200 g
- Garlic 20 g
- Olive oil 30 g
- Egg 50 g
Price per portion: USD 1.7625Didukung oleh

Kesimpulan

Grok 4 menghadirkan fitur baru seperti jendela konteks yang lebih besar dan kemampuan penalaran yang lebih baik. Pengenalan gambar dan pemanggilan fungsinya membuka kemungkinan menarik untuk memadukan AI dengan data dan tindakan dunia nyata, sementara output terstruktur memastikan respons yang andal dan dapat dibaca mesin. Penyiapan API-nya sederhana, memungkinkan integrasi cepat ke proyek Python Anda hanya dengan beberapa dependensi.

Dan jika semua contoh lasagna membuat Anda lapar, Anda tidak sendirian—saya juga mungkin harus mengambil sepotong!