Grok 3 API: Adım Adım Rehber ve Örnekler

Grok 3 Nedir?

Grok 3, adım adım akıl yürütme, mantıksal tutarlılık ve yapılandırılmış çıktılar için özel olarak geliştirilmiş xAI’nin en yeni büyük dil modelidir. Sohbet akışını önceleyen tipik sohbet modellerinden farklı olarak, Grok 3 yanıt vermeden önce düşünür; bu da karmaşık karar verme, matematiksel akıl yürütme ve nicel analiz gibi derin mantık gerektiren görevler için idealdir.

Grok 3 iki farklı sürümde gelir: normal model ve mini model. Mini model tamamen akıl yürütme yönüne odaklanır ve akıl yürütme izlerine erişim sağlar; normal model ise finans, sağlık, hukuk ve bilim gibi alanlarda kapsamlı alan bilgisini barındırdığı şeklinde tanıtılır.

Her iki model sürümü de yerel fonksiyon çağırma ve yapılandırılmış yanıt üretimi gibi gelişmiş yetenekleri destekler; böylece geliştiricilerin güvenilir ve öngörülebilir yapay zekâ iş akışları kurmasını kolaylaştırır.

Grok 3’ün mimarisi ve performansı hakkında daha fazla bilgi edinmek isterseniz, şu genel bakışa göz atın: Grok 3.

Hazırlık: Grok 3 API Erişimi Alma

Bu bölümde bir API anahtarı oluşturmayı, Grok API’ye bağlanmak için bir Python ortamı kurmayı ve ilk kullanıcı isteğinizi göndermeyi açıklayacağım.

API anahtarı oluşturma

Python istemcisini API ile kimlik doğrulamak için bir API anahtarı oluşturmamız gerekir. Süreç şu şekildedir:

1. Şu adrese gidin: xAI dokümantasyon sayfası.
2. X, xAI veya Google hesabınızla oturum açın—ya da bir xAI hesabı oluşturun.
3. “Create an API key”e tıklayın, bir ad verin ve “save”e tıklayın.
4. Anahtar göründüğünde kopyalayın. Daha sonra tekrar göremeyeceksiniz; ancak kaybederseniz her zaman yenisini oluşturabilirsiniz.
5. Proje dizininizde .env adlı bir dosya oluşturun ve anahtarı aşağıdaki biçimde yapıştırın:

XAI_API_KEY=<your_api_key>Altyapı:

Grok 3 API fiyatlandırması

Her ne kadar API kullanımı genellikle bir premium aboneliğe kıyasla daha düşük maliyetle ilişkilendirilse de ücretsiz değildir. Aylık sabit bir hesap ücreti yerine (SuperGrok aboneliği için 30 $’dan başlar), maliyet tamamen kullanım miktarına bağlıdır. Olası maliyetlere genel bakış için xAI’in fiyatlandırma sayfasını ziyaret edin.

Listelenen fiyatlar milyon başına token içindir; bu da, kabaca bir hesapla İngilizce’de yaklaşık 750.000 kelime giriş veya çıkışa karşılık gelir.

Mini model, normal modele kıyasla belirgin şekilde daha ucuzdur. Hem Grok 3 hem de Grok 3 mini’nin hızlı sürümleri aynı temel modelleri kullanır; ancak daha hızlı bir altyapıda sunuldukları için yanıt süreleri iyileşir.

API’yi kullanmak için kredi satın almamız gerekir. Başlangıçta otomatik faturalandırma yerine ön ödemeli kredi kullanmak önerilir; bu, beklenmedik maliyetlere karşı iyi bir önlemdir. xAI konsolunda Invoices > Credits altında token satın alabilir ve kullanımınıza genel bakış edinebilirsiniz.

Python ortamını kurma

Artık bir API anahtarı edindik ve kredi satın aldık; Python istemcisini kurma zamanı. API isteklerimizin başarıyla çalışması için iki bağımlılık kurmamız gerekiyor:

• python-dotenv ile API anahtarını .env dosyasından ortam değişkeni olarak yüklemek ve
• openai istemcisi ile Grok 3’e istek göndermek.

Projemizin ortamını kurmak için, farklı Python paketleri arasındaki olası çakışmaları önlemek adına Anaconda kullanmanızı öneririm. Anaconda’yı kurduktan sonra, Python 3.10 kullanarak grok3 adlı bir ortam oluşturup terminalde şu komutlarla etkinleştiriyoruz:

conda create -n grok3 python=3.10
conda activate grok3Altyapı:

Son olarak, bağımlılıkları kuruyoruz:

pip install python-dotenv openaiAltyapı:

İlk kullanıcı isteğini gönderme

İlk betiğimizle başlama zamanı! Önce, daha önce kurduğumuz paketlerden kullanacağımız fonksiyonları ve API anahtarını okumak için os’u içe aktarmamız gerekiyor.

import os
from dotenv import load_dotenv
from openai import OpenAIAltyapı:

API anahtarına atıfta bulunan ortam değişkeni, dotenv paketinden içe aktarılan load_dotenv() fonksiyonunu çalıştırarak kullanılabilir hâle getirilir.

# Load environment variables
load_dotenv()Altyapı:

Sıradaki adım istemciyi başlatmaktır. .env dosyamızdaki API anahtarı ve Grok sunucusunun URL’siyle OpenAI fonksiyonunu çağırıyoruz ve bunu client değişkenine atıyoruz.

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

San Francisco’da yağmur yağarsa ne yapacağımıza dair Grok’tan tavsiye isteyelim. Yapmamız gereken model ve messages’ı belirtip bunları client.chat.completions.create fonksiyonuna argüman olarak geçmek. İsteğe bağlı olarak, yanıt uzunluğunu kontrol etmek için max_tokens veya rastgeleliği etkilemek için temperature gibi parametreleri de ayarlayabiliriz.

# 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
)Altyapı:

Grok’un cevabını yazdırmak için sonucu döndüren nesneden çıkarmamız gerekir. Sonucu saklayan değişkene response adını verdiğimiz için, yanıt response.choices[0].message.content içinde bulunabilir.

print(response.choices[0].message.content) # Print the responseAltyapı:

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.Altyapı:

Grok 3 Mini ile Akıl Yürütme

Grok’un akıl yürütme tarzını görmek için, biraz mantıksal düşünme gerektiren basit bir soru soralım. Bu ilk istek için Grok 3 Mini’yi kullanacağız; çünkü her API yanıtında tam bir akıl yürütme izi garanti eder ve özel istem mühendisliğine başvurmadan modelin düşünce sürecini adım adım takip etmeyi kolaylaştırır.

Modelin ne kadar derin düşündüğünü belirleyen parametre reasoning_effort olarak adlandırılır. Bu parametre yalnızca Grok 3 Mini’ye özeldir ve varsayılan olarak daha hızlı seçenek olan ”low” değerine ayarlıdır. reasoning_effort="high" olarak ayarlamak, modelin nihai yanıtı vermeden önce problemi dikkatlice adım adım işlemesine yardımcı olur; planlama, karar verme veya matematiksel akıl yürütme gibi görevler için idealdir.

Diyelim ki hava durumuna bağlı olarak izin gününde ne yapacağımızı bulmak için Grok’u kullanmak istiyoruz. Güneşli ve yağmurlu günler için birer etkinlik tanımlayan öncüller ile gerçek hava durumuna dayalı bir öncülü Grok’a iletebiliriz.

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,
)Altyapı:

Akıl yürütme iziyle çalışmak için önce API yanıtını ayrıştırmamız ve message nesnesinden reasoning_content özniteliğini çıkarmamız gerekir. Aşağıdaki kod, ayrıntılı akıl yürütme adımlarını ve nihai yanıtı, bir web arayüzünde görüneceğine benzer şekilde nasıl yazdıracağınızı gösterir.

# 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)Altyapı:

Sonuç şu şekilde görünür:

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.Altyapı:

Bu oldukça basit bir örnek olsa da Grok-3-mini’nin her bir öncülü dikkatlice nasıl ele aldığını, mantığı adım adım zincirleyerek bir öneriye nasıl ulaştığını görebiliyoruz. Akıl yürütmesi sistematik ve şeffaftır; modelin olgulardan nihai öneriye nasıl geçtiğini izlemeyi kolaylaştırır.

Grok 3 ile Fonksiyon Çağırma

Grok 3’ü ilginç kılan özelliklerden biri, kendisini harici araçlara ve sistemlere bağlamasını sağlayan fonksiyon çağırmadır. Bu sayede model yalnızca metin üretmekle kalmaz; hava tahmini getirme, etkinlik takvimlerine bakma, veritabanı kayıtlarını analiz etme veya akıllı cihazları kontrol etme gibi eylemleri de tetikleyebilir.

Bir kullanıcı isteği gönderdiğimizde Grok 3 ek bilgiye ihtiyaç duyduğunu fark edip belirli argümanlarla bir fonksiyon çağrısı talep edebilir. Python istemcisi ardından fonksiyonu yerelde çalıştırır, sonucu tekrar Grok 3’e gönderir ve nihai, tamamen gerekçelendirilmiş yanıtı alır.

Kaynak: xAI

Hazırlık

Grok tarafından çağrılan bir fonksiyonun argüman yapısına erişmek için json paketine ihtiyacımız olacak; bu nedenle içe aktarmalıyız.

import jsonAltyapı:

Fonksiyon çağırmayı denemek için, Grok yanıtında talep ettiğinde çağrılacak bir geri çağırma fonksiyonu tanımlamamız gerekir. Bizim durumumuzda get_weather_forecast fonksiyonu, sabit bir hava tahmini döndüren basit bir Python fonksiyonudur. Açıklamayı yalın tutmak ve harici servislere bağımlı olmamak için örnek amacıyla sabitledim.

# 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
    }Altyapı:

Ayrıca kullanılabilir aracı adını, amacını ve gerekli parametrelerini bir JSON şemasıyla tanımlamalıyız; bu şema isteğimizle birlikte Grok’a gönderilecektir. Bu kurulum, Grok 3’e akıl yürütmesi için ihtiyaç duyduğunda bu aracı çağırabileceğini bildirir.

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"]
            }
        }
    }
]Altyapı:

Son olarak, tools_map dictionary Grok 3 tarafından kullanılan fonksiyon adlarını yerel Python fonksiyonlarına bağlar; böylece istemci istenen araç çağrılarını doğru şekilde çalıştırabilir.

# Link the function names to the functions
tools_map = {
    "get_weather_forecast": get_weather_forecast
}Altyapı:

Araç şemalarını elle tanımlamak basit projeler için tamamen yeterli olsa da, projeler büyüdükçe Pydantic gibi bir veri doğrulama modülü kullanmak giderek daha değerli hâle gelir. Fonksiyon girdilerinin otomatik doğrulanmasını, daha iyi hata yönetimini ve daha temiz, bakımı kolay bir kod yapısını sağlar.

Yürütme

Gelin, Grok’tan bu hafta sonu San Francisco’da önerilen bir etkinliği sorduğumuzda hava tahmini fonksiyonumuzu kullanıp kullanmadığını görelim. Fonksiyon çağırma iş akışının yapısını izliyoruz:

1. Önce, sorumuzu içeren ilk kullanıcı isteğini, mevcut tools ile birlikte Grok’a gönderiyoruz.
2. Grok’un yanıtında bir araç çağrısı talebi olup olmadığını kontrol ediyor ve uygunsa tools_map kullanarak eşleşen yerel fonksiyonu çağırıyoruz. Grok bir araç çağrısı istemezse, modelin ilk yanıtını döndürerek durumu ele alabiliriz.
3. Sonraki adımda sonucu mesaj geçmişine ekliyoruz; ve
4. Akıl yürütmeyi tamamlaması ve nihai yanıtı üretmesi için tekrar Grok’a gönderiyoruz.

# 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)Altyapı:

Grok’un yanıtı, fonksiyonun istendiğini ve başarıyla çalıştırıldığını gösteriyor:

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: (...)Altyapı:

İlk kullanıcı isteğinde yer alan tool_choice argümanını fark etmiş olabilirsiniz; bu, fonksiyon çağırma moduna atıfta bulunur. Varsayılan olarak "auto" modu, Grok 3’ün sohbete göre bir fonksiyon çağırıp çağırmayacağına ve hangisini çağıracağına karar vermesine izin verir. Alternatif olarak, davranışı ”required” ile bir fonksiyon çağrısını zorlayarak, çağrılacak fonksiyonu tam olarak belirterek veya fonksiyon çağırmayı tamamen ”none” ile devre dışı bırakarak kontrol edebiliriz.

Grok 3 ile Yapılandırılmış Çıktılar

Yapılandırılmış çıktılar, Grok 3’ün serbest biçimli metin yerine JSON gibi katı, önceden tanımlı bir formatta yanıt döndürmesini sağlar. Bu, model yanıtlarını otomatik olarak ayrıştırmayı, doğrulamayı ve uygulama veya iş akışlarına entegre etmeyi çok daha kolay hâle getirir.

Başta bir şema tanımlayarak Grok’un çıktılarının tutarlı, makine tarafından okunabilir ve aşağı akış işlemleri için hazır olmasını sağlayabiliriz. Bu nedenle belgelerden yapılandırılmış veri çıkarma ya da yapay zekâ tarafından üretilen içgörüleri veritabanları, panolar veya otomasyon hatları gibi sistemlere kırılgan metin ayrıştırmaya ihtiyaç duymadan besleme gibi kullanımlar için oldukça yararlı bir özelliktir.

Çıkış şemasını tanımlamak için Pydantic kullanıyoruz; çünkü karmaşık verileri yapılandırmak için daha temiz ve okunaklı bir yol sunar. Bu şema tanımının doğru çalışması için pydantic’ten BaseModel ve Field’i içe aktarmamız gerekir. Çıktımız bir akıl yürütme adımları listesi içerdiğinden, öğe türünü daha hassas şekilde belirtmek için Python’un typing modülünden List’i de içe aktarıyoruz.

Şema düz JSON ile de tanımlanabilir olsa da, testlerimde Grok 3’ün bazen beklenen yapıyla tam olarak eşleşmeyen çıktılar döndürdüğünü gördüm. Dönen JSON anlamca benzerdi ama farklı bir şemayı izliyordu; bu da belirli bir yapıyı bekleyen uygulamaları bozabilir. Bu tutarsızlık nedeniyle—özellikle listeler gibi iç içe öğelerde—yapılandırılmış çıktının güvenilir şekilde doğrulanması ve ayrıştırılması için Pydantic kullanımını şiddetle öneririm.

from pydantic import BaseModel, Field
from typing import ListAltyapı:

DecisionPlan adını verdiğimiz şemamız, başlangıçtaki situation alanımız ve step numarası, arkasındaki reasoning ve önerilen action ile tanımlanan DecisionSteps listesinden oluşur.

# 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")Altyapı:

İsteğin kendisiyle ilgili dikkate alınması gereken birkaç nokta var. Öncelikle, Grok’a çıktıyı belirli bir formatta istediğimizi bildirmek için create() yerine client.beta.chat.completions.parse() kullanmamız gerekir. Bu, az önce tanımladığımız şemadır; buna uygun olarak DecisionPlan’imizi response_format argümanı olarak geçiriyoruz.

Belirli bir görev için tüm önemli talimatları sistem istemine dahil etmek faydalı olabilir; bu, Grok 3’ün tüm konuşma boyunca göreve odaklanmasına yardımcı olur. Ayrı tanımlanmış şema ile birlikte, kullanıcı isteminin çıktı JSON’unda zorunlu alanları belirtmesi gerekmez; görevin kendisine odaklanabilir.

Örneğin, etkinlik planlama sürecini kolayca üç net adıma ayırabiliriz:

# 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,
)Altyapı:

Grok 3’ün yapılandırılmış çıktısını ayrıştırdıktan sonra, temel önerileri özetleyerek, otomatik iş akışlarını tetikleyerek veya hatta programatik olarak daha ileri kararlar alarak sonuçları kullanabiliriz.

İlk örneği uygulayalım ve seyahat uzmanımız Grok’un yalnızca durumumuzu ve nihai önerisini görüntüleyelim. Çıktımız önceden tanımlı JSON formatımızda olduğundan, son adımın önerisine kolayca erişebiliriz:

# 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}")Altyapı:

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.Altyapı:

Hepsini Bir Araya Getirme: Grok 3 ile Basit Bir Akıl Yürütme Uygulaması

Fonksiyon çağırma ve yapılandırılmış çıktıları birleştirerek Grok’un akıl yürütmesini kullanan basit bir uygulama oluşturabiliriz. Aşağıdaki kodları kopyalayıp yapıştırabiliriz:

• Daha önce bahsedilen tüm paketlerin ve fonksiyonların içe aktarılması;
• İstemcinin başlatılması;
• Fonksiyon şemasının, sahte fonksiyonun ve tools_map’in tanımlanması; ve
• Çıktı şemasının tanımlanması.

Araç çağrısını tetiklemek için create() fonksiyonunu kullanarak bir API çağrısıyla başlıyoruz. Kullanıcının soruyu terminalde girmesine izin vermek için, San Francisco’daki etkinlikle ilgili sorumuzu input("> ") ile değiştiriyoruz.

function_result’ı messages listesine ekledikten sonra bir fark devreye giriyor: create() kullanan bir başka API çağrısı oluşturmak yerine, parse() ediyor ve DecisionPlan’imizi response_format olarak geçiriyoruz.

Küçük uygulamamızın tüm kodu şöyle:

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.")Altyapı:

Çalıştırma örneği

Uygulamayı denemek için proje dizinimize gidiyor, ortamımızı yüklüyor ve betiği çalıştırıyoruz:

cd <your/working/directory>
conda activate grok3
python app.pyAltyapı:

Helsinki için biraz tavsiye istersek, Grok uygulamamız şöyle yanıt verir:

Deneyimlerimden söyleyebilirim ki gayet yerinde bir öneri!

Sonuç

Pek çok şeyi ele aldık—hadi toparlayalım. Grok 3 API ile nasıl çalışılacağını; basit sorgular yürütmeyi, akıl yürütme izlerini ele almayı ve fonksiyon çağırma ile yapılandırılmış çıktılar gibi gelişmiş özellikleri kullanmayı inceledik.

Bu yetenekleri, Grok’un harici araçları kullanabildiğini ve yapılandırılmış, eyleme dönüştürülebilir yanıtlar döndürebildiğini gösteren küçük bir projede birleştirdik. API’lerle—bizim örneğimizde bir hava durumu API’si—birlikte Grok 3’ün güçlü yönlerini tam olarak kullanan güçlü uygulamalar geliştirilebilir.

Buraya kadar geldiyseniz, muhtemelen LLM’ler hakkında daha fazla şey öğrenmekle ilgileniyorsunuzdur. Şu kaynaklara da göz atabilirsiniz:

• GPT-Image-1 API: Adım Adım Rehber ve Örnekler
• Qwen3’ü Yerel Olarak Ollama ile Kurma ve Çalıştırma
• Qwen3 İnce Ayarı: Adım Adım Rehber