Grok 4.6 API: İlk Çağrıdan Araç Kullanan Bir Ajana

Grok 4.6 API’sini Python’da Nasıl Kurarsınız?

Başlamak için bir SpaceXAI API anahtarına ve xai-sdk’nın kurulumuna ihtiyacınız olacak.

console.x.ai’den API anahtarı alma

Grok 4.6 API anahtarı oluşturmak için SpaceX AI konsolu API anahtarı oluşturma sayfasına gidiyoruz. Ardından sağ üst köşedeki Create API Key düğmesine tıklıyoruz.

API anahtarı oluşturma formu basittir. Anahtara, hangi projeye ait olduğunu anlayabileceğimiz bir ad veriyoruz. Ayrıca, API anahtarlarına her zaman bir son kullanma tarihi koymanızı, kötüye kullanım durumunda emniyet supabı olarak öneririm.

Anahtar oluşturulduktan sonra kopyalayıp Python betiklerimizi yazacağımız klasörle aynı dizinde oluşturduğumuz .env adlı bir dosyaya yapıştırıyoruz. Böylece, anahtarı kod dosyasında tutmamıza gerek kalmadan betiğe yüklemek kolaylaşır; aksi halde kodu paylaşırken ya da buluta yüklerken anahtarı yanlışlıkla ifşa etmemiz mümkündür.

.env dosyasının içeriği aşağıdaki gibi olmalıdır:

XAI_API_KEY=replace_with_the_api_key

xai-sdk kurulumu ve SpaceXAI API anahtarını yükleme

API anahtarıyla SpaceXAI’ye bağlanmak için xai-sdk paketini kullanırız. Sahip olabileceğimiz diğer projelerdeki Python paketleriyle çakışmayı önlemek için her proje için ayrı bir ortam oluşturmak iyi bir pratiktir. Bunu yapmak için aşağıdaki komutla Anaconda’yı kullanacağız:

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

Etkinleştirdikten sonra istediğimiz paketleri kurabiliriz. Şimdilik şunlarla başlayalım:

• xai-sdk: API’ye istek göndermek için kullanılan resmi SpaceXAI paketi.

• python-dotenv: API anahtarını .env dosyasından yüklemeyi kolaylaştıran yardımcı paket.

Kurmak için şu komutu kullanırız:

pip install xai-sdk python-dotenv

API anahtarını nasıl yükleyip Python’da bir SpaceXAI Client oluşturabileceğimiz aşağıda:

from dotenv import load_dotenv
from xai_sdk import Client

load_dotenv()

client = Client()

Bu kodun henüz bir istek yapmadığını unutmayın. Bunu bir sonraki adımda öğreneceğiz.

SpaceXAI API kredisi satın alma

Grok 4.6 API’sini kullanmak için API platformlarında kredi satın almamız gerekir. Bunlar olmadan API istekleri reddedilir. Bunu yapmak için kenar çubuğunun altındaki Credits bölümüne gidin, Add credits’e tıklayın ve tercih ettiğiniz tutarı ekleyin.

Grok 4.6’nın API üzerinden maliyeti nedir?

Grok 4.6 istekleri token başına faturalandırılır. Temel fiyatlandırma, milyon giriş tokeni başına 2 $, milyon çıkış tokeni başına 6 $’dır.

Grok 4.6’nın bir akıl yürütme modeli olduğunu not etmek önemlidir. Akıl yürütme, içsel bir öz konuşma olarak yapılır ve token tüketir; bunlar da çıktı tokenleri olarak faturalandırılır. Modelin belirli bir istek için ne kadar akıl yürütme yapacağını nasıl kontrol edeceğimizi daha sonra öğreneceğiz.

Önbelleğe alınmış tokenler çok daha ucuzdur; milyon token başına yalnızca 0,5 $’a mal olur.

Grok’un web araması, X araması ve kod çalıştırma olmak üzere üç yerleşik aracı olduğunu ve bunların tokenlerden ayrı olarak faturalandığını göreceğiz. Bunların tümü 1.000 çağrı başına 5,00 $’dır.

Uzun bağlamlar için, 200K eşiğini aşan istemlerdeki tüm tokenlerin iki katı oran üzerinden faturalandırıldığını akılda tutmak gerekir.

İlk Grok 4.6 API çağrınızı nasıl yaparsınız?

Önceki kodun üzerine inşa ederek SpaceXAI istemcisini kullanıp Grok 4.6’ya bir istek gönderelim.

Grok 4.6’ya istek göndermek için client.chat.create() ile grok-4.6’yı hedefleyen bir sohbet oturumu başlatır ve chat.append(user()) kullanarak istemimizi konuşma geçmişine ekleriz.

Son olarak chat.sample() çağrısı, yanıt üretmesi için konuşmayı modele gönderir; biz de response.content’i yazdırarak gösteririz.

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)

Grok’u bu şekilde kullandığımızda yanıtı tek seferde alırız; yani Grok tüm yanıtı üretmeyi bitirene kadar beklememiz gerekir. Akış kullanarak sözcük sözcük yanıt alabiliriz. 

Yanıt akışı

chat.sample() ile tam yanıtı beklemek yerine, chat.stream() kullanarak modelin çıktısını gerçek zamanlı alabiliriz.

# … 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()

Bu kod, akış üzerinde yineleme yapar; artımlı parçacık nesneleri döndürür ve her yeni metin parçasını (chunk.content) geldiği anda konsola yazdırarak duyarlı bir token token akış deneyimi yaratır.

Bu kodu çalıştırırken modelin token üretmeye başlamasının hâlâ biraz zaman aldığını fark ederiz. Bunun nedeni, Grok 4.6’nın bir akıl yürütme modeli olmasıdır. Varsayılan olarak, nihai yanıtın ilk görünen sözcüğünü üretmeden önce model, dahili bir "chain-of-thought" akıl yürütme aşamasından geçer.

Yukarıdaki kodu, modelin akıl yürütme sürecini de gösterecek şekilde şöyle güncelleyebiliriz:

# … 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()

Bu parçayı izleyen Grok 4.6 akışı iki tür token teslim eder:

• Modelin içsel chain-of-thought tokenleri
• Nihai yanıt

Bu betik, chunk.reasoning_content’ı kontrol ederek Grok’un adım adım düşünme sürecini önce akışa verir, ardından nihai yanıt başladığında chunk.content’i yazdırır.

Grok 4.6’da Akıl Yürütme Çabasını Nasıl Ayarlarsınız?

Yukarıda gördüğümüz gibi, diğer sınır modeller gibi Grok 4.6 da gizli bir düşünce zincirine dayanır. Nihai yanıtının tek bir sözcüğünü bile üretmeden önce, çözümleri keşfetmek, mantığı iki kez kontrol etmek ve kendi hatalarını düzeltmek için binlerce akıl yürütme tokeni üretir.

reasoning_effort parametresi, modelin bu akıl yürütme sürecine ne kadar çaba harcayacağını kontrol etmemizi sağlar. Yalnızca nihai yanıtın değil, akıl yürütme tokenlerinin de ücretlendirilmesi nedeniyle, maliyeti düşürmek istiyorsak yönetilmesi önemli bir parametredir.

Grok 3 mini geliştiricilerin reasoning_effort’ı ayarlamasına zaten izin veriyordu, ancak Grok 4 bu kontrolü kaldırdı. Akıl yürütme her zaman açıktı ve ayarlanamıyordu. SpaceXAI, Grok 4.x serisi boyunca (4.3 ve 4.5) bu kontrolü yeniden getirdi ve Grok 4.6 da bunu destekler; seçenekler low, medium, high (varsayılan) ve xhigh’dır.

Akıl yürütme çabasını ayarlamak için, client.chat.create() ile sohbeti başlatırken reasoning_effort parametresini kullanırız. Değer, istediğimiz çabayı belirten bir karakter dizisidir. Varsayılan değer "high"’dır. Bunu "low" olarak nasıl ayarlayabileceğimize bir örnek:

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

Aynı istemde low ve high karşılaştırması

Hem low hem de high akıl yürütmeyi kullanarak küçük bir oyun oluşturma, çok kötü biçimlendirilmiş para birimleri içeren bordro verilerini analiz eden bir betik yazma ve mantık bulmacaları çözme gibi birçok görevi denedim.

Tüm bu durumlarda model, düşük ya da yüksek akıl yürütmeyle benzer çözümler sunabildi.

Fark yaratmak için, akıl yürütmenin ortasında durmanın başarısızlığa yol açtığı bir göreve ihtiyacımız var. Bu yüzden çok sayıda çözümü olan bir bulmacaya döndüm. Kullandığım istem şu:

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.

Her iki akıl yürütme düzeyinde de Grok 4.6 doğru çözümler buldu. Ancak low olarak ayarlandığında, akıl yürütme bütçesi görevi tamamlamadan önce bitti. Bu nedenle eksik bir çözümle yanıt verdi. Yüksek akıl yürütme düzeyinde ise Grok 4.6 tüm 264 çözümü buldu.

Karşılaştırma için: low akıl yürütmede 16.422 akıl yürütme tokeni, high akıl yürütmede ise 56.455 token kullandı.

Xhigh, ekstra tokenlere ne zaman değer?

Yüksek ayar karmaşık mantık bulmacalarını ve veri ayrıştırma betiklerini kaba kuvvetle çözebiliyorsa, kim neden xhigh’ın devasa token tüketimi için ödeme yapsın?

Bence günlük programlama ve veri bilimi görevlerinin %99’u için xhigh gereğinden fazladır ve API bütçenizi hızla tüketir.

Ancak, xhigh, modeli bir kodlama asistanı olarak değil de otonom bir ajan olarak çalıştırmaya geçtiğinizde vazgeçilmez hale gelir. Esasen, modelin kendi işini agresif biçimde gözden geçirmesi, çıkmazlara saplanması ve nihai çıktıyı size göstermeden önce mantığını yeniden yazması için ödeme yapmış olursunuz.

Önerim, low ile başlayıp model bir görevde sistematik olarak başarısız oluyorsa ancak o zaman artırmanızdır. Evet, bazı durumlarda bu aynı problem için birden fazla kez ödeme yapacağımız anlamına gelir, ancak çoğu zaman çok daha düşük maliyetle iyi bir çözümle kurtuluruz.

Grok 4.6 API’sine Görselleri Nasıl Gönderirsiniz?

Grok 4.6 çok kipli bir modeldir ve bu nedenle görsel verileri işleyebilir. 

URL ile görsel gönderme

Modele görsel sağlamanın en kolay yolu bir URL kullanmaktır. Bunu kullanıcı mesajına ikinci argüman olarak verebiliriz:

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()

Dosya yükleme ile görsel gönderme

Çoğu zaman URL yerine yerel görselleri kullanmak isteriz. Bu, görseli base64 dizesi olarak yükleyerek yapılabilir. encode_image() işlevi bunu bizim için yapabilir:

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}"

Görsel kodlandıktan sonra aynı şekilde modele sağlayabiliriz:

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

Görsel girişi desteklemesine rağmen, Grok 4.6 yalnızca metin çıktısı verir. SpaceXAI görsel üretimi hakkında daha fazla bilgi edinmek isterseniz, Grok Imagine API eğitimimizi okumanızı öneririm.

Grok 4.6 Ajanlarında Araçları Nasıl Etkinleştiririm?

Grok 4.6 üç kullanışlı sunucu tarafı araca erişim sağlar ve özel araçlar oluşturma olanağı sunar.

Sunucu tarafı araçları çağırma (web araması, X araması, kod çalıştırma)

Grok 4.6 üç sunucu aracıyla birlikte gelir:

• Web araması: Yanıtı temellendirmek için ajanın web araması yapmasına olanak tanır.
• X araması: X platformundan gerçek zamanlı verileri sorgular.
• Kod çalıştırma: Sorguyu yanıtlamaya yardımcı olmak için kodu bir korumalı alanda çalıştırır.

Bu araçlar SpaceXAI sunucularında çalışır ve her araç çağrısı tokenlerden bağımsız olarak faturalandırılır.

Bunları etkinleştirmek için içe aktarıp client.chat.create() ile sohbeti başlatırken sağlamamız gerekir:

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()],
)

Yanıtları akışla alırken, ajanın bir araç kullanıp kullanmadığını chunk.tool_calls bayrağını kontrol ederek anlayabiliriz.

Aşağıda, akış yanıtını ajanın bir araç kullandığını kullanıcıya gösterecek şekilde işlemenin bir kesiti yer alıyor:

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)

Sunucu araçlarıyla tam bir örnek betiği eşlik eden GitHub depomda bulabilirsiniz.

Özel yerel araçlar uygulama

Yukarıdaki sunucu araçlarına ek olarak, Grok 4.6 ajanımızı özel araçlarla da donatabiliriz. Ajanın yerel dosyaları okuyup yazmasına olanak tanıyan araçları nasıl uygulayabileceğimizi görelim.

Özel bir araç uygulamak için iki şeye ihtiyacımız var:

1. SpaceXAI SDK’nın resmi tool() nesnesini kullanan bir araç belirtimi.

2. Aracın Python uygulaması; yani araç çağrıldığında çalıştırmak istediğimiz kod.

Bir araç belirtimi şunlardan oluşur:

• Çağrılacak Python işlevinin adı.
• Aracın ne yaptığını açıklayan bir açıklama. Bu kritik önemdedir, çünkü ajanın aracı ne zaman çağıracağını belirler.
• İşlevin parametre belirtimi.

Aşağıda, yerel dosyaları okuyan bir aracı uygulamak için kullanabileceğimiz bir işlev yer alıyor:

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}"

Güvenlik nedeniyle, aracı bir dosyayı okumadan önce her zaman kullanıcıdan izin isteyecek şekilde uyguladık. Bu, özel verileri kazara ajana sağlamayı önler.

Bu işlev için araç belirtimi aşağıdadır:

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"],
    },
)

Bir dosyaya yazma kodu benzerdir ve depodaki tools.py dosyasında bulunabilir.

Grok 4.6 ile Araç Kullanan Bir Ajan Döngüsü Nasıl Çalıştırılır?

Bu bölümde öğrendiklerimizi bir araya getirerek, yanıtları arama yoluyla çevrimiçi verilerle temellendirirken yerel dosyalar üzerinde işlem yaparak gerçek iş gerçekleştirme yeteneğine sahip bir Grok 4.6 ajan döngüsü oluşturacağız.

Ajan aşağıdaki diyagramda gösterildiği gibi çalışacaktır. Kullanıcı bir istem gönderir, ardından ajan gerekirse araçları kullanarak yanıt verir. Sonra yanıt kullanıcıya gönderilir ve kullanıcı ajanla etkileşime devam edebilir. 

Ajan, kullanıcı istemlerini, yanıtları ve araç sonuçlarını eklemek için chat.append() işlevini kullanarak tüm konuşmayı takip eder. Bir araç sonucu, tool_result() örneğine sarılmalıdır.

İşte tam ajan uygulaması:

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")

Grok 4.6 ajanını hisse senedi portföyü analizi için test etme

Ajanı test etmek için örnek bir hisse senedi portföyü CSV dosyası oluşturdum. Dosya oldukça basit; hisseleri listeliyor ve özellikle alış tarihini ve alış fiyatını gösteriyor. 

Amaç, ajandan şunları istemek:

1. CSV dosyasını yüklemek.
2. Her hissenin güncel fiyatlarını almak için web araması yapmak.
3. Güncel fiyatlarla yeni bir sütun ekleyerek CSV’yi güncellemek.
4. Bu sektörlerdeki en son gelişmeleri gösteren bir portföy raporu oluşturmasını istemek.

Aşağıda, 1’den 3’e kadar adımlar için Ajan ile etkileşimin ekran görüntüsü yer alıyor.

Web aramasını, kod çalıştırmayı ve oluşturduğumuz özel araçları kullanarak yerel dosyaları okuyup yazdığını gözlemliyoruz. Sonunda, güncel hisse fiyatlarını içeren yeni bir sütun ekleyerek CSV dosyasını güncelledi.

Ajan bir döngüde çalıştığı için konuşmaya devam edebiliriz. Bir sonraki etkileşimde, bu hisselerle ilgili haberleri aramasını, portföy çeşitliliğini analiz etmesini ve bir markdown raporu oluşturmasını istedim.

Oluşturduğu raporu merak ediyorsanız, GitHub deposunda.

Bir hisse senedi portföyünü analiz etmek gibi gerçek bir görev üzerinde ajanın test edilmesi, Grok 4.6’nın neler yapabildiğini gerçekten gösteriyor. Web aramalarını kullanarak, kod çalıştırarak ve yerel araçlara kendi başına erişerek model, karmaşık istekleri kolaylıkla ele alıyor.

İstem önbellekleme ve 200k fiyat eşiği

Çok turlu bir ajan uygularırken, modelin her etkileşimde tüm geçmişi yeniden işlemesini önlemek için konuşmanın önbelleğe alındığından emin olmalıyız. Bunu yapmamak büyük maliyetlere yol açabilir.

Önbellekleme otomatik olarak gerçekleşir, ancak önbellek girdileri sunucu başına saklanır ve varsayılan olarak istekler farklı sunuculara yönlendirilebilir ve önbelleği kaçırabilir. Önbellek isabetlerini en üst düzeye çıkarmak için, bir konuşmadaki tüm isteklerin aynı sunucuya ulaşmasını sağlayan sabit bir konuşma tanımlayıcısı sağlamalıyız. Bunu nasıl ileteceğiniz API’ye bağlıdır:

• xai-sdk (gRPC): İstemci başlatılırken gRPC üst verisi olarak iletilen x-grok-conv-id

• OpenAI Responses API: İstek gövdesinde ayarlanan prompt_cache_key

Aşağıdaki kesit bunun nasıl yapılacağını gösterir:

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]

Dikkate alınması gereken önemli bir husus, uzun konuşmalarda mali yaptırımın özellikle ağırlaşmasıdır. Toplam istem uzunluğunuz 200k tokena ulaştığında veya aştığında, API 2x çarpanı uygular ve tüm isteği standart oranın iki katı üzerinden faturalandırır.

Çok turlu döngülerin bu 200k eşiğini aşmasını engellemek için bağlam sıkıştırması uygulamak şiddetle tavsiye edilir. Bu, eski konuşma turlarını periyodik olarak özetleyerek veya kayan bir bağlam penceresi kullanarak yapılır. Bu strateji, temel talimatlarınızda ucuz önbellek isabetlerinden yararlanmaya devam ederken sonsuza dek büyüyen bir bağlam penceresinin ağır mali yaptırımlarından kaçınmanızı sağlar.

Sonuç

Bu eğitimde, Python ile SpaceXAI API’sini kullanarak Grok 4.6 ile nasıl etkileşim kuracağımızı öğrendik. Metin ve görsel istemleri göndermenin temellerini ve modelin üzerinde çalıştığı şeyi kullanıcıya bildirecek şekilde çıktıyı nasıl ele alacağımızı gördük. 

Modele araç sağlamayı öğrenerek, bunların hepsini bir araya getirip Grok 4.6’yı kullanarak bir borsa portföyünü analiz etmek gibi gerçek dünya görevlerini çözebilen bir yapay zeka ajanı oluşturabildik. Son olarak, uzun bağlamlı görevleri çalıştırmanın inanılmaz derecede pahalı olabileceğini, özellikle de önbellekleme kullanmazsak, öğrendik.

Burada öğrendiklerinizi test etmek için bir alıştırma olarak, ajan içinde önbelleklemeyi uygulamanızı ve çıktıyı akıl yürütme tokenlerini de gösterecek şekilde güncellemenizi öneririm. 

Eğer API’lerle yapay zeka ajanları oluşturma bilginizi derinleştirmek istiyorsanız, Working with the OpenAI API kursumuzu öneririm. Ajan konusuna derinlemesine inmek için en iyi yer AI Agent Fundamentals beceri yoludur.