Grok 3 API: Panduan Langkah demi Langkah Disertai Contoh

Apa Itu Grok 3?

Grok 3 adalah model bahasa besar terbaru dari xAI, dibuat khusus untuk penalaran langkah demi langkah, konsistensi logis, dan keluaran terstruktur. Berbeda dengan model chat pada umumnya yang memprioritaskan alur percakapan, Grok 3 berpikir sebelum menjawab, sehingga ideal untuk tugas yang memerlukan logika mendalam, seperti pengambilan keputusan kompleks, penalaran matematika, dan analisis kuantitatif.

Grok 3 hadir dalam dua varian: model reguler dan model mini. Sementara model mini sepenuhnya berfokus pada aspek penalaran dan memungkinkan akses ke jejak penalarannya, model reguler diklaim memiliki pengetahuan domain yang signifikan di bidang seperti keuangan, kesehatan, hukum, dan sains.

Kedua versi model mendukung kemampuan lanjutan seperti pemanggilan fungsi native dan pembuatan respons terstruktur, membantu pengembang membangun alur kerja AI yang andal dan dapat diprediksi dengan mudah.

Jika Anda ingin mengetahui lebih banyak tentang arsitektur dan performa Grok 3, pastikan untuk melihat ikhtisar Grok 3 ini.

Persiapan: Mendapatkan Akses ke Grok 3 API

Di bagian ini, saya akan menjelaskan cara membuat kunci API, menyiapkan lingkungan Python untuk terhubung ke Grok API, dan membuat permintaan pengguna pertama Anda.

Membuat kunci API

Untuk mengautentikasi klien Python dengan API, kita perlu membuat kunci API. Prosesnya seperti ini:

1. Buka halaman dokumentasi xAI.
2. Masuk dengan akun X, xAI, atau Google Anda—atau buat akun xAI.
3. Klik “Create an API key”, beri nama, lalu klik “save”.
4. Saat kunci terlihat, salinlah. Anda tidak akan bisa melihatnya lagi nanti, tetapi Anda selalu dapat membuat yang baru jika kehilangannya.
5. Buat file bernama .env di direktori proyek Anda dan tempelkan kuncinya dengan format berikut:

XAI_API_KEY=<your_api_key>Didukung oleh

Harga Grok 3 API

Meskipun penggunaan API sering dikaitkan dengan biaya yang lebih rendah daripada langganan premium, API tidak gratis. Alih-alih biaya tetap per bulan, yang dimulai dari $30 untuk langganan SuperGrok, biayanya sepenuhnya bergantung pada jumlah penggunaan. Untuk mendapatkan gambaran biaya potensial, kunjungi halaman harga xAI.

Harga yang tertera adalah per satu juta token, yang, menurut aturan praktis berkisar sekitar 750.000 kata masukan atau keluaran dalam bahasa Inggris.

Model mini jauh lebih murah daripada model reguler. Versi cepat dari Grok 3 dan Grok 3 mini menggunakan model dasar yang sama persis, tetapi disajikan pada infrastruktur yang lebih cepat, sehingga waktu respons meningkat.

Untuk menggunakan API, kita perlu membeli kredit. Menggunakan kredit prabayar alih-alih penagihan faktur otomatis direkomendasikan pada awalnya, karena ini menjadi pengaman yang baik terhadap biaya tak terduga. Anda dapat membeli token dan melihat gambaran penggunaan Anda di konsol xAI di Invoices > Credits.

Menyiapkan lingkungan Python

Sekarang setelah kita memperoleh kunci API dan membeli kredit, saatnya menyiapkan klien Python. Kita perlu memasang dua dependensi agar permintaan API kita berjalan dengan sukses:

• python-dotenv untuk memuat kunci API sebagai variabel lingkungan dari file .env, dan
• klien openai sebagai antarmuka untuk mengirim permintaan ke Grok 3.

Untuk menyiapkan lingkungan bagi proyek kita, saya merekomendasikan menggunakan Anaconda untuk menghindari potensi konflik antar paket Python. Setelah memasang Anaconda, kita membuat environment bernama grok3 menggunakan Python 3.10 dan mengaktifkannya dengan perintah berikut di terminal:

conda create -n grok3 python=3.10
conda activate grok3Didukung oleh

Terakhir, pasang dependensinya:

pip install python-dotenv openaiDidukung oleh

Mengirim permintaan pengguna pertama

Saatnya memulai skrip pertama kita! Pertama, kita perlu mengimpor fungsi yang akan digunakan dari paket yang kita pasang sebelumnya, serta os untuk membaca kunci API.

import os
from dotenv import load_dotenv
from openai import OpenAIDidukung oleh

Variabel lingkungan yang merujuk ke kunci API dibuat tersedia dengan mengeksekusi fungsi load_dotenv() yang diimpor dari paket dotenv.

# Load environment variables
load_dotenv()Didukung oleh

Langkah berikutnya adalah menginisialisasi klien. Kita memanggil fungsi OpenAI dengan kunci API dari file .env dan URL server Grok, lalu menetapkannya ke variabel client.

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

Mari kita minta saran Grok tentang apa yang bisa dilakukan di San Francisco jika hujan. Yang perlu kita lakukan adalah menentukan model dan messages kita, lalu meneruskannya sebagai argumen ke fungsi client.chat.completions.create. Secara opsional, kita juga dapat menyesuaikan parameter seperti max_tokens untuk mengontrol panjang respons atau temperature untuk memengaruhi tingkat keacakan.

# Send a basic reasoning query
response = client.chat.completions.create(
    model="grok-3",
    messages=[
        {"role": "user", "content": "What kind of activity would you suggest, if it rains in San Francisco? Answer in one sentence."}
    ],
    max_tokens=1000,
    temperature=0.2,  # lower temperature for more deterministic answers
)Didukung oleh

Untuk mencetak jawaban Grok, kita harus mengekstraknya dari objek hasil. Karena kita menamai variabel yang menyimpan hasilnya response, jawabannya dapat ditemukan di response.choices[0].message.content.

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

If it rains in San Francisco, I suggest visiting indoor attractions like the San Francisco Museum of Modern Art or the California Academy of Sciences for an enriching and dry experience.Didukung oleh

Penalaran dengan Grok 3 Mini

Untuk melihat gaya penalaran Grok, mari ajukan pertanyaan dasar yang memerlukan penalaran logis. Kita akan menggunakan Grok 3 Mini untuk permintaan pertama ini karena model ini menjamin jejak penalaran lengkap dalam setiap respons API, sehingga lebih mudah mengikuti proses berpikir model langkah demi langkah tanpa mengandalkan rekayasa prompt khusus.

Parameter yang menentukan seberapa dalam model berpikir disebut reasoning_effort. Ini eksklusif untuk Grok 3 Mini dan secara bawaan disetel ke opsi yang lebih cepat "low". Menyetel reasoning_effort="high" membantu model menelusuri masalah dengan cermat langkah demi langkah sebelum memberikan jawaban akhir—sempurna untuk tugas seperti perencanaan, pengambilan keputusan, atau penalaran matematika.

Bayangkan kita ingin menggunakan Grok untuk menentukan apa yang harus dilakukan saat libur, tergantung cuaca. Kita bisa memberikan premis kepada Grok yang mendefinisikan aktivitas untuk hari cerah dan hujan, serta premis berdasarkan cuaca aktual.

response = client.chat.completions.create(
    model="grok-3-mini-beta",
    reasoning_effort="high",
    messages=[
        {"role": "user", "content": (
            "Premises:\n"
            "- If it is raining, the weather is suitable for indoor activities.\n"
        	"- Visiting a museum is an indoor activity.\n"
        	"- Today, it is raining.\n"
            "Question: What should we do today?"    	
        )}
    ],
    max_tokens=1000,
    temperature=0.2,
)Didukung oleh

Untuk bekerja dengan jejak penalaran, pertama kita perlu mengurai respons API dan mengekstrak atribut reasoning_content dari objek message. Kode berikut menunjukkan cara mencetak langkah-langkah penalaran terperinci dan jawaban akhir, mirip seperti saat ditampilkan di antarmuka web.

# Print the reasoning trace if available
reasoning = getattr(response.choices[0].message, "reasoning_content", None)
 
if reasoning:
    print("Reasoning steps:\n")
    print(reasoning)
else:
    print("No detailed reasoning trace found.")
 
# Print the final answer
print("\nFinal Answer:\n")
print(response.choices[0].message.content)Didukung oleh

Hasilnya terlihat seperti ini:

Reasoning steps:
First, the premises are:
1. If it is raining, the weather is suitable for indoor activities.
2. Visiting a museum is an indoor activity.
3. Today, it is raining.
The question is: What should we do today?
I need to reason step by step based on the given premises.
From premise 3, today it is raining.
From premise 1, if it is raining, then the weather is suitable for indoor activities. Since it's raining today, the weather is suitable for indoor activities today.  	
From premise 2, visiting a museum is an indoor activity. So, if the weather is suitable for indoor activities, and visiting a museum is an indoor activity, it makes sense that visiting a museum would be a good choice today.
The conclusion should be that we should visit a museum or engage in some indoor activity. But the question is "What should we do today?" and the premises point towards indoor activities, with a specific example given.
Let me chain the logic:
- It is raining (premise 3).
- Therefore, weather is suitable for indoor activities (from premise 1).
- Visiting a museum is an indoor activity (premise 2).
- So, since the weather is suitable for indoor activities, and museum visiting is an indoor activity, it should be suitable to visit a museum.
The premises don't explicitly say that we should do the most suitable activity or anything like that. They just provide conditions and facts.
However, the question implies a recommendation based on the premises. Given that it's raining and indoor activities are suitable, and a museum is mentioned, it's logical to suggest visiting a museum.
I should stick to what's given. The premises don't suggest any other activities or constraints, so based on the information, visiting a museum is a reasonable suggestion.
Final answer should be something like: "We should visit a museum today."
To make it clear, I can phrase it as: "Since it is raining and the weather is suitable for indoor activities, and visiting a museum is an indoor activity, we should visit a museum today."
But since the instruction is to put the final answer in a box, probably a concise statement.
Looking back at the user's message, it's a reasoning exercise, so the answer should be direct.
Final Answer:
Based on the given premises:
- It is raining today (premise 3).
- If it is raining, the weather is suitable for indoor activities (premise 1).   	
- Therefore, the weather is suitable for indoor activities today.
- Visiting a museum is an indoor activity (premise 2).
A suitable activity for today would be an indoor one, such as visiting a museum. 	
**Recommendation:** We should visit a museum today.Didukung oleh

Meskipun ini contoh yang cukup sederhana, kita dapat melihat bagaimana grok-3-mini dengan saksama menelusuri setiap premis, merangkai logika langkah demi langkah sebelum memberikan rekomendasi. Penalarannya metodis dan transparan, sehingga mudah menelusuri bagaimana model bergerak dari fakta ke saran akhir.

Pemanggilan Fungsi dengan Grok 3

Salah satu fitur yang membuat Grok 3 menarik adalah pemanggilan fungsi, yang memungkinkannya terhubung ke alat dan sistem eksternal. Ini memungkinkan model tidak hanya menghasilkan teks, tetapi juga memicu tindakan seperti mengambil prakiraan cuaca, melihat jadwal acara, menganalisis entri basis data, atau bahkan mengendalikan perangkat pintar.

Saat kita mengirim permintaan pengguna, Grok 3 dapat mengenali bahwa ia memerlukan informasi tambahan dan meminta pemanggilan fungsi dengan argumen tertentu. Klien Python kemudian menjalankan fungsi tersebut secara lokal, mengirimkan hasilnya kembali ke Grok 3, dan menerima respons akhir yang sepenuhnya terjelaskan.

Sumber: xAI

Persiapan

Kita akan membutuhkan paket json untuk mengakses struktur argumen dari fungsi yang dipanggil oleh Grok, jadi kita harus mengimpornya.

import jsonDidukung oleh

Untuk mencoba pemanggilan fungsi, kita perlu mendefinisikan fungsi callback yang dipanggil saat Grok memintanya di responsnya. Dalam kasus kita, fungsi get_weather_forecast adalah fungsi Python sederhana yang mengembalikan prakiraan cuaca yang di-hardcode. Saya meng-hardcode-nya untuk tujuan demonstrasi agar penjelasan tetap lugas dan tidak bergantung pada layanan eksternal.

# Define the dummy function
def get_weather_forecast(location: str, date: str) -> dict:
    """Simulated function to always return rainy weather."""
    return {
        "location": location,
        "date": “this weekend”, # hardcoded for demo purposes
        "forecast": "rainy"  # hardcoded for demo purposes
    }Didukung oleh

Kita juga harus mendefinisikan alat yang tersedia dengan menentukan nama, tujuan, dan parameter yang diperlukan dalam skema JSON, yang akan dikirim ke Grok bersama permintaan kita nanti. Pengaturan ini memberi tahu Grok 3 bahwa ia dapat memanggil alat ini kapan pun membutuhkan informasi cuaca untuk penalarannya.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather_forecast",
            "description": "Get a simulated weather forecast for a given location and date.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city where the activity will take place."
                    },
                    "date": {
                        "type": "string",
                        "description": "The date for which the weather is needed, in YYYY-MM-DD format."
                    }
            	    },
            	    "required": ["location", "date"]
            }
        }
    }
]Didukung oleh

Terakhir, kamus tools_map menautkan nama fungsi yang digunakan oleh Grok 3 ke fungsi Python lokal yang sebenarnya, sehingga klien dapat mengeksekusi pemanggilan alat yang diminta dengan benar.

# Link the function names to the functions
tools_map = {
    "get_weather_forecast": get_weather_forecast
}Didukung oleh

Meskipun mendefinisikan skema alat secara manual tidak masalah untuk proyek sederhana, menggunakan modul validasi data seperti Pydantic menjadi semakin berharga seiring bertambahnya ukuran dan kompleksitas proyek. Ini memungkinkan validasi input fungsi secara otomatis, penanganan error yang lebih baik, serta kode yang lebih rapi dan mudah dirawat.

Eksekusi

Mari kita lihat apakah Grok menggunakan fungsi prakiraan cuaca kita saat ditanya tentang aktivitas yang disarankan di San Francisco akhir pekan ini. Kita ikuti struktur alur kerja pemanggilan fungsi:

1. Pertama, kita mengirim permintaan pengguna awal yang berisi pertanyaan kita ke Grok bersama tools yang tersedia.
2. Kita memeriksa jawaban Grok apakah ada permintaan pemanggilan alat, dan jika ada, memanggil fungsi lokal yang cocok menggunakan tools_map. Jika Grok tidak meminta pemanggilan alat, kita bisa menanganinya dengan mengembalikan jawaban awal model.
3. Selanjutnya, kita tambahkan hasilnya ke riwayat pesan; dan
4. Kirimkan kembali ke Grok untuk menyelesaikan penalaran dan menghasilkan jawaban akhir.

# Step 1: Send the initial user request
messages = [
    {"role": "user", "content": "What should I do this weekend in San Francisco?"}
]

response = client.chat.completions.create(
    model="grok-3",
    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
        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)  # Grok'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-3",
                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

Fungsi diminta dan dijalankan dengan sukses, seperti yang ditunjukkan oleh jawaban Grok:

Thanks for the weather update. Since it's going to be rainy this weekend in San Francisco, I’ll suggest some indoor activities to keep you entertained and dry. Here are a few ideas for your weekend: (...)Didukung oleh

Anda mungkin memperhatikan argumen tool_choice dalam permintaan pengguna awal, yang merujuk pada mode pemanggilan fungsi. Secara bawaan, mode "auto" membiarkan Grok 3 memutuskan apakah dan fungsi mana yang akan dipanggil berdasarkan percakapan. Alternatifnya, kita dapat mengontrol perilaku dengan memaksa pemanggilan fungsi menggunakan "required", menentukan fungsi yang tepat untuk dipanggil, atau menonaktifkan pemanggilan fungsi sepenuhnya dengan "none".

Keluaran Terstruktur dengan Grok 3

Keluaran terstruktur memungkinkan Grok 3 mengembalikan jawaban dalam format ketat yang telah ditentukan seperti JSON, alih-alih teks bebas. Ini membuat proses mengurai, memvalidasi, dan mengintegrasikan respons model ke aplikasi atau alur kerja menjadi jauh lebih mudah.

Dengan mendefinisikan skema di awal, kita dapat memastikan keluaran Grok konsisten, dapat dibaca mesin, dan siap untuk pemrosesan lanjutan. Karenanya, ini sangat berguna untuk kasus penggunaan seperti data terstruktur dari dokumen atau mengalirkan wawasan yang dihasilkan AI ke sistem hilir seperti basis data, dasbor, atau pipeline otomatisasi tanpa perlu penguraian teks yang rapuh.

Kita menggunakan Pydantic untuk mendefinisikan skema keluaran karena menawarkan cara yang lebih bersih dan mudah dibaca untuk menstrukturkan data kompleks. Baik BaseModel maupun Field dari pydantic perlu diimpor agar definisi skema ini berfungsi dengan benar. Karena keluaran kita mencakup daftar langkah penalaran, kita juga mengimpor List dari modul typing Python untuk menentukan tipe elemen dengan lebih tepat.

Meskipun juga memungkinkan untuk mendefinisikan skema menggunakan JSON biasa, dari pengujian saya, Grok 3 terkadang mengembalikan keluaran yang tidak persis cocok dengan struktur yang diharapkan. JSON yang dikembalikan serupa secara makna tetapi mengikuti skema berbeda, yang dapat merusak aplikasi yang mengharapkan struktur tertentu. Karena inkonsistensi ini, terutama dengan elemen bersarang seperti daftar, saya sangat merekomendasikan menggunakan Pydantic untuk memastikan keluaran terstruktur divalidasi dan diurai dengan andal.

from pydantic import BaseModel, Field
from typing import ListDidukung oleh

Skema kita, bernama DecisionPlan, terdiri dari situation awal dan daftar DecisionSteps, yang didefinisikan oleh nomor step-nya, reasoning di baliknya, dan action yang disarankan.

# Define the schema for the structured output
class DecisionStep(BaseModel):
    step: int = Field(description="Step number in the decision process")
    reasoning: str = Field(description="Reasoning behind this step")
    action: str = Field(description="Suggested action at this step")
 
class DecisionPlan(BaseModel):
    situation: str = Field(description="The initial situation to consider")
    steps: List[DecisionStep] = Field(description="List of reasoning steps leading to the final action")Didukung oleh

Ada beberapa hal yang perlu dipertimbangkan terkait permintaan itu sendiri. Pertama-tama, kita perlu menggunakan client.beta.chat.completions.parse() alih-alih create(), agar Grok tahu bahwa kita menginginkan keluaran dengan format tertentu. Ini adalah skema yang baru saja kita definisikan, dan sesuai dengan itu, kita meneruskan DecisionPlan sebagai argumen response_format.

Akan berguna untuk menyertakan semua instruksi penting untuk tugas tertentu dalam prompt sistem, karena ini membantu Grok 3 tetap fokus pada tugas sepanjang percakapan. Digabungkan dengan skema yang didefinisikan terpisah, prompt pengguna tidak harus menentukan field yang diperlukan dalam JSON keluaran tetapi dapat fokus pada tugas itu sendiri.

Kita, misalnya, dapat dengan mudah memecah proses perencanaan aktivitas menjadi tiga langkah yang terdefinisi dengan baik:

# Send a prompt and request structured output
completion = client.beta.chat.completions.parse(
    model="grok-3",
    messages=[
        {"role": "system", "content": (
        "You are an expert travel planner."
        "When asked about activities, always break down the decision process into exactly 3 logical reasoning steps."
        "Return the output in structured JSON format following the provided schema, without any extra text."
        )},
        {"role": "user", "content": (
        "It's raining today in San Francisco. What indoor activity would you recommend?"
        )}
    ],
    response_format=DecisionPlan,
)Didukung oleh

Setelah mengurai keluaran terstruktur Grok 3, kita dapat bertindak berdasarkan hasilnya dengan merangkum rekomendasi utama, memicu alur kerja otomatis, atau bahkan membuat keputusan lebih lanjut secara terprogram.

Mari pilih contoh pertama dan hanya menampilkan situasi kita serta rekomendasi akhir dari pakar perjalanan kita, Grok. Karena keluaran kita dalam format JSON yang telah ditentukan, kita dapat mengakses rekomendasi langkah terakhir dengan mudah:

# Access the parsed result
plan = completion.choices[0].message.parsed
 
# Use the final action to create a summary message
final_step = plan.steps[-1]
 
print(f"\nSummary:")
print(f"Situation: {plan.situation}")
print(f"Recommended Action: {final_step.action}")Didukung oleh

Summary:
Situation: It's raining today in San Francisco, and an indoor activity is needed to make the most of the day.
Recommended Action: Visiting the California Academy of Sciences in Golden Gate Park for an educational and entertaining indoor experience.Didukung oleh

Menyatukan Semuanya: Membangun Aplikasi Penalaran Sederhana dengan Grok 3

Kita dapat menggabungkan pemanggilan fungsi dan keluaran terstruktur untuk membuat aplikasi sederhana yang menggunakan penalaran Grok. Kita dapat menyalin dan menempelkan kode untuk:

• Mengimpor semua paket dan fungsi yang disebutkan sebelumnya;
• Inisialisasi klien;
• Mendefinisikan skema fungsi, fungsi dummy, dan tools_map; serta
• Mendefinisikan skema keluaran.

Kita mulai dengan panggilan API menggunakan fungsi create() untuk memicu pemanggilan alat. Agar pengguna dapat memasukkan pertanyaan di terminal, kita cukup mengganti pertanyaan tentang aktivitas di San Francisco dengan input("> ").

Setelah menambahkan function_result ke daftar messages ada sedikit perbedaan: alih-alih membuat panggilan API lain yang menggunakan create(), kita melakukan parse() dan meneruskan DecisionPlan sebagai response_format.

Berikut adalah kode lengkap aplikasi kecil kita:

import os
import json
from dotenv import load_dotenv
from openai import OpenAI
from pydantic import BaseModel, Field
from typing import List
 
# Load environment variables
load_dotenv()
 
# Initialize the client
client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
)
 
# 1. Define the function schema (tool definition)
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather_forecast",
            "description": "Get a simulated weather forecast for a given location and date.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city where the activity will take place."
                	},
                    "date": {
                        "type": "string",
                        "description": "The date for which the weather is needed, in YYYY-MM-DD format."
                    }
            	    },
                "required": ["location", "date"]
        	}
        }
    }
]
 
# 2. Dummy weather function (hardcoded)
def get_weather_forecast(location: str, date: str) -> dict:
    return {
        "location": location,
        "date": "this weekend",
        "forecast": "rainy"
    }
 
# 3. Tool mapping
tools_map = {
    "get_weather_forecast": get_weather_forecast
}
 
# 4. Define structured output schema using Pydantic
class DecisionStep(BaseModel):
	step: int = Field(description="Step number in the decision process")
	reasoning: str = Field(description="Reasoning behind this step")
	action: str = Field(description="Suggested action at this step")
 
class DecisionPlan(BaseModel):
	situation: str = Field(description="The initial situation to consider")
	steps: List[DecisionStep] = Field(description="List of reasoning steps leading to the final action")
 
# 5. Defining messages: system prompt and input
messages = [
    {"role": "system", "content": (
        "You are an expert travel planner. When asked about weekend plans, "
        "first get the weather forecast via the tool provided. Then, based on the result, "
        "break down your reasoning into exactly 3 steps and return structured JSON only."
    )},
    {"role": "user", "content": input("> ")} # enter the question in the terminal
]
 
# 6. First API call to trigger the tool call
response = client.chat.completions.create(
    model="grok-3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)
 
tool_calls = getattr(response.choices[0].message, "tool_calls", [])
 
if tool_calls:
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)
        if function_name in tools_map:
            function_result = tools_map[function_name](**function_args)
 
        	# Add the assistant's tool call message and the tool result to the message history
            messages.append(response.choices[0].message)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(function_result)
        	})
 
        	# 7. Second API call with parse() to get structured output
            final_response = client.beta.chat.completions.parse(
                model="grok-3",
                messages=messages,
                response_format=DecisionPlan
        	)
 
        	plan = final_response.choices[0].message.parsed
 
        	# 8. Use the output
            final_action = plan.steps[-1].action
 
            print(f"\nSummary:")
            print(f"Situation: {plan.situation}")
            print(f"Recommended Action: {final_action}")
 
else:
    print("No tool call was requested.")Didukung oleh

Contoh eksekusi

Untuk mencoba aplikasi, kita menavigasi ke direktori proyek, memuat environment, dan menjalankan skrip:

cd <your/working/directory>
conda activate grok3
python app.pyDidukung oleh

Jika kita meminta beberapa saran untuk Helsinki, aplikasi Grok kita menjawab:

Ini saran yang lumayan, saya tahu dari pengalaman!

Kesimpulan

Kita telah membahas banyak hal—mari kita rangkum. Kita mengeksplorasi cara bekerja dengan Grok 3 API untuk menjalankan kueri sederhana, menangani jejak penalaran, dan memanfaatkan fitur lanjutan seperti pemanggilan fungsi dan keluaran terstruktur.

Kita menggabungkan kemampuan ini dalam proyek kecil yang menunjukkan bagaimana Grok dapat menggunakan alat eksternal dan mengembalikan jawaban terstruktur yang dapat ditindaklanjuti. Dipadukan dengan API—dalam kasus kita, API cuaca—aplikasi yang kuat dapat dibangun untuk sepenuhnya memanfaatkan keunggulan Grok 3.

Jika Anda sampai di sini, Anda mungkin tertarik mempelajari lebih lanjut tentang LLM. Silakan lihat juga sumber daya berikut:

• GPT-Image-1 API: Panduan Langkah demi Langkah Disertai Contoh
• Cara Menyiapkan dan Menjalankan Qwen3 Secara Lokal dengan Ollama
• Fine-Tuning Qwen3: Panduan Langkah demi Langkah