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

Grok 4 API ile Başlarken

İlk kullanıcı isteğimizi göndermeden önce bir API anahtarına ve Grok API’sine bağlanabilen bir Python ortamına ihtiyacımız var.

API anahtarınızı oluşturma

API ile istemciyi kimlik doğrulaması için kullanabileceğiniz bir API anahtarı oluşturmak üzere şu adımları izleyebilirsiniz:

1. Resmî xAI dokümantasyon sitesini ziyaret edin.
2. X, xAI veya Google hesabınızla oturum açın. Henüz hesabınız yoksa, yeni bir xAI hesabı oluşturabilirsiniz.
3. “Create an API key” seçeneğini bulun. Anahtarınız için bir ad girin ve “save”e tıklayın.
4. Anahtarınız göründüğünde hemen kopyalayın. Daha sonra tekrar görüntüleyemezsiniz; ancak gerektiğinde her zaman yenisini oluşturabilirsiniz.
5. .env adlı bir dosyayı proje dizininizde oluşturun. API anahtarınızı aşağıdaki biçimde içine yapıştırın:

XAI_API_KEY=<your_api_key_here>Altyapı:

Grok 4 API fiyatlandırması

API’yi kullanmak, premium bir aboneliğe kıyasla daha ekonomik olabilir; ancak ücretsiz değildir. Aylık sabit abonelikle başlayan SuperGrok planından farklı olarak, API maliyetleri tamamen kullanımınıza bağlıdır. Ancak Grok 4 Heavy’e erişmek isterseniz işler farklıdır: API’yi kullanırken bile aktif bir SuperGrok Heavy aboneliğine (ayda 300 $) ihtiyacınız olacaktır.

Olası giderlerin ayrıntılı dökümü için xAI’deki fiyatlandırma sayfasına göz atın.

Kaynak: xAI

Grok API’nin fiyatlandırması kullanım esaslıdır ve milyon başına token üzerinden ölçülür. Referans olarak bir milyon token, girdi veya çıktı olması fark etmeksizin yaklaşık 750.000 İngilizce kelimeye eşittir. Bağlam penceresi selefine kıyasla neredeyse iki katına çıkmış olmasına rağmen, Grok 4’ün fiyatı standart Grok 3 modeliyle aynıdır. Her bir milyon giriş token’ı için 3 $, her bir milyon çıkış token’ı için 15 $ ödersiniz.

API’ye erişmek için kredi satın almanız gerekir. Başlarken, otomatik faturalandırma yerine ön ödemeli krediler kullanmak akıllıca olacaktır—bu, sürpriz ücretlerden kaçınmanıza yardımcı olur. xAI konsolunda Invoices > Credits altında token satın alabilir ve kullanımınızı takip edebilirsiniz.

Python ortamının kurulumu

API anahtarınız ve kredileriniz hazır olduğunda, bir sonraki adım Python ortamınızı hazırlamaktır. Sorunsuz API entegrasyonu için iki pakete ihtiyacınız olacak:

• python-dotenv, .env dosyasındaki API anahtarınızı ortam değişkeni olarak yüklemek için.
• Grok 4 API ile etkileşim kurmak için openai istemcisi.

Proje bağımlılıklarını temiz tutmak için Anaconda kullanmanız iyi bir fikirdir. Anaconda’yı kurduktan sonra, Python 3.10 ile grok4 adlı yeni bir ortamı şu komutlarla oluşturun:

conda create -n grok4 python=3.10
conda activate grok4Altyapı:

Ortamınız etkinleştirildiğinde, gerekli paketleri yükleyin:

pip install python-dotenv openaiAltyapı:

Son hazırlıklar

Hadi ilk betiğimizi yazarak başlayalım. Yüklediğiniz paketlerden gerekli fonksiyonları ve API anahtarınıza erişmek için os modülünü içe aktararak başlayın:

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

Sonra, dotenv paketinden load_dotenv() fonksiyonunu kullanarak ortam değişkenlerinizi yükleyin; böylece API anahtarınız betiğe erişilebilir hâle gelir:

# Load environment variables
load_dotenv()Altyapı:

Şimdi, API anahtarınızı (.env dosyasından) ve Grok sunucu URL’sini OpenAI sınıfına geçirerek API istemcisini başlatın (bu eğitimde OpenAI SDK’sını kullanacağız; ancak Grok 4’ün yerel xAI Python SDK’sı da vardır ve Anthropic’in SDK’sı ile de uyumludur). Bunu client değişkenine atayın:

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

Bu adımlarla betiğiniz Grok 4’e istek göndermeye hazır.

Grok 4 ile Görüntü Tanıma

Artık zemin hazır olduğuna göre, Grok 4’ün yeni özelliklerinden biri olan görsel tanımayı test edelim. Bunu, aşağıdaki vejetaryen lazanya fotoğrafını yükleyip Grok’tan görünen malzemeleri tanımlamasını isteyerek göstereceğiz.

Grok 4 API ile bir görseli analiz etmek için hem görseli hem de bir istemi içeren bir istek göndermemiz gerekir. Önerilen yöntem, OpenAI uyumlu bir Python istemcisi kullanmak; modeli grok-4 olarak belirtmek ve mesajlar dizisine görsel URL’si ile sorunuzu eklemektir. API, görsel içeriğini ayrıntılı şekilde tanımlayan bir yanıt döndürecektir; bu yanıta response nesnesinden erişebilirsiniz.

İsteği göndermeden önce, görselin API gereksinimlerini karşıladığından emin olmalıyız. Yalnızca JPEG ve PNG formatları desteklenir ve dosya boyutu 20 MB’ı aşmamalıdır. Görsel doğrudan bir bağlantı ile erişilebilir olmalı ve sunucu doğru Content-Type başlığını göndermelidir (image/jpeg veya image/png).

Gerekli paketleri içe aktarıp ortam değişkenlerinizi yükledikten ve istemciyi kurduktan sonra sorgumuzu şu şekilde gönderebiliriz:

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

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? 😊Altyapı:

Bu örnekte, Grok yalnızca fotoğrafa bakarak bunun vejetaryen bir versiyon olduğunu bile anladı—oldukça etkileyici!

Grok 4 ile Akıl Yürütme

Grok 4, gelişmiş akıl yürütme için tasarlanmıştır ve karmaşık problemleri adım adım çözebilir. Ancak bazı önceki modellerin aksine, Grok 4 dahili akıl yürütme izlerini dışa vurmaz; bu nedenle API yanıtından ayrık bir alan olarak ayrıntılı bir “düşünme süreci” veya düşünce zinciri çıkartamazsınız. Aldığınız çıktı, modelin ara adımları veya ham akıl yürütme içeriği değil, nihai yanıttır.

Ayrıca, Grok 4, örneğin Grok 3 mini’de kullanılan reasoning_effort parametresini de desteklemez (bu parametrenin nasıl kullanılacağını öğrenmek için şu Grok 3 API eğitimine bakın). Bu da modelin nihai sonuca varmadan önce ne kadar “düşüneceğini” ayarlayamayacağınız anlamına gelir. Dolayısıyla, herhangi bir akıl yürütme sorgusu, tıpkı normal bir sorgu gibi oluşturulur.

Grok’u, lazanya ile ilgili başka bir akıl yürütme göreviyle test edelim ve çıktıda akıl yürütmesini göstermesini isteyelim.

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

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

Grok’un yanıtını ana noktaları vurgulamak için kısalttım, ancak bu daha kısa sürümde bile modelin işini iyi yaptığı açık. Grok adım adım şunları yaptı:

• Diyet kısıtlamalarını anlama
• Mevcut tarifleri değerlendirme
• En iyi tarif kombinasyonunu seçme
• Belirli malzeme ikameleri önermesi
• Tam bir değiştirilmiş tarif taslağı sunması
• Herkesi nasıl memnun ettiğini yeniden ele alması
• Olası dezavantajları ve alternatifleri tartışması

Grok 4 ile Fonksiyon Çağırma

Selefi gibi, Grok 4 de fonksiyon çağırmayı destekler. Bu sayede model doğrudan harici araçlar ve hizmetlerle etkileşime girebilir. Yani Grok yalnızca metin üretmekle sınırlı değildir—hava durumunu çekmek, etkinlik saatlerini kontrol etmek, veritabanı kayıtlarını analiz etmek veya akıllı ev cihazlarını işletmek gibi eylemleri de gerçekleştirebilir.

Bir istek gönderdiğinizde, Grok ekstra veriye ihtiyaç duyarsa bunu belirler ve doğru parametrelerle çağrılması gereken belirli bir fonksiyon ister. Python istemcisi bu fonksiyonu yerelde çalıştırır, sonucu Grok’a iletir ve siz de eksiksiz, mantıklı bir yanıt alırsınız.

Hazırlık

Fonksiyon çağırma ile çalışmak için, Grok’un çağırdığı herhangi bir fonksiyonun argüman yapısına erişmemizi sağlayan json paketini içe aktarmamız gerekir. Ardından, belirli veriler istendiğinde Grok’un çağıracağı bir geri çağırma fonksiyonu tanımlarız.

Bu örnekte, suggest_lasagna_recipe fonksiyonu sabit bir tarif önerisi döndüren basit bir Python fonksiyonudur. Bu gömülü yaklaşım, gösterimi basit tutar ve harici hizmetlere bağımlılığı önler.

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

Ayrıca Grok’un çağırabileceği aracı tanımlamamız gerekir. Bu, aracın adını, amacını ve gerekli parametrelerini bir JSON şemasında belirtmeyi içerir. Bu şema, istekle birlikte Grok’a gönderilir ve ek bilgi gerektiğinde bu aracı çağırabileceğini bildirir.

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

Son olarak, tools_map sözlüğü Grok’un kullandığı fonksiyon adlarını kodunuzdaki gerçek Python fonksiyonlarına bağlar. Bu eşleştirme, istemcinin istenen fonksiyon çağrılarını doğru şekilde yürütmesini sağlar.

# link the function names to the functions
tools_map = {
    "suggest_lasagna_recipe": suggest_lasagna_recipe
}Altyapı:

Araç şemalarını elle tanımlamak basit projelerde iyi çalışsa da, projeniz büyüdükçe Pydantic gibi bir veri doğrulama kütüphanesi kullanmanızı şiddetle öneririm. Pydantic, fonksiyon girdilerinin otomatik doğrulamasını, geliştirilmiş hata yönetimini sağlar ve daha temiz, sürdürülebilir koda yol açar.

Yürütme

Grok’tan bir lazanya tarifi istendiğinde fonksiyonumuzu kullanıp kullanmadığını kontrol edelim. İşte fonksiyon çağırma iş akışının nasıl ilerlediği:

1. Önce, mevcut tools ile birlikte Grok’a şu kullanıcı sorusunu gönderiyoruz—“Mevcut malzemelerle hangi lazanyayı yapabilirim?” 
2. Grok ardından isteği inceler ve bir fonksiyon çağrısına ihtiyaç olduğuna karar verirse, yerel fonksiyonumuzu tetikleyerek tarif ister. Herhangi bir araç çağrısı yapılmazsa, Grok’un ilk yanıtını kullanırız.
3. Bir araç çağrısı istendiğinde, ilgili yerel fonksiyonu çalıştırır ve sonucu devam eden mesaj geçmişine ekleriz.
4. Bu güncellenmiş geçmiş daha sonra Grok’a geri gönderilir; böylece Grok akıl yürütmesini tamamlayıp nihai, bağlama duyarlı bir yanıt sağlar.

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

suggest_lasagna_recipe successfully called

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

Gördüğümüz gibi, Grok fonksiyonumuzu çağırdı ve karşılık gelen tarifi önerdi.

İlk istekteki tool_choice argümanına da dikkat etmiş olabilirsiniz. Varsayılan “auto”, Grok’un hangi fonksiyonu çağıracağına karar vermesine izin verir. Daha fazla kontrol isterseniz, belirli bir fonksiyon çağrısını zorlayabilir, tam olarak hangi fonksiyonun kullanılacağını belirtebilir veya bu parametreyi değiştirerek fonksiyon çağırmayı tamamen kapatabilirsiniz.

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

Fonksiyon çağırmaya benzer şekilde, yapılandırılmış çıktılar Grok 3 ile tanıtılan bir özelliktir. Grok’un yanıtları düz metin yerine JSON gibi katı bir biçimde teslim etmesini sağlar. Bu yaklaşım, model yanıtlarını uygulamalarınızda veya iş akışlarınızda ayrıştırmayı, doğrulamayı ve kullanmayı çok daha kolay hâle getirir.

Önden bir şema kurarak, Grok’un çıktılarının tutarlı, makine tarafından okunabilir ve ileri işlemeye hazır olacağından emin olabilirsiniz. Bu, özellikle belgelerden yapılandırılmış veri çıkarmanız veya yapay zekâ tarafından üretilen içeriği güvenilmez metin ayrıştırmayla uğraşmadan doğrudan veritabanlarına, panolara veya otomasyon araçlarına göndermeniz gerektiğinde kullanışlıdır.

Çıktı şemasını tanımlamak için Pydantic kullanıyoruz; bu da karmaşık verilerin yapılandırılmasını daha basit ve okunaklı kılar (daha fazla bilgi için şu Pydantic eğitimi size yardımcı olacaktır). Bunun için pydantic’ten BaseModel ve Field’ı içe aktarmanız gerekir. Çıktımız malzeme listesini içerdiğinden, listedeki her öğenin türünü açıkça belirtmek için Python’un typing modülünden List’i de içe aktarıyoruz.

Şemayı düz JSON ile de kurabilirdik; ancak Grok bazen beklenen yapıyla bire bir örtüşmeyen çıktılar döndürebilir. Anlam aynı olsa da şema farklı olabilir; bu da uygulamanız belirli bir biçime ihtiyaç duyduğunda sorunlara yol açabilir. Bu durum özellikle listeler gibi iç içe öğeler için geçerlidir. Bu yüzden Pydantic kullanmanızı öneririm—yapılandırılmış çıktının her seferinde güvenilir şekilde doğrulanıp ayrıştırılmasına yardımcı olur.

Örneğimizde, Recipe adlı şema; adını, porsiyon sayısını ve bir malzeme listesini içerir. Her bir Ingredient, adı, tarif için gereken miktarı, mevcut olup olmadığı, kilogram başına fiyatı ve malzemenin vejetaryen, vegan veya glutensiz olup olmadığı bilgisiyle tanımlanır. Şemanın kendisinde, örneğin porsiyon sayısında yaptığımız gibi, varsayılan değerler belirlemek faydalıdır.

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

İstek yaparken akılda tutulması gereken birkaç ayrıntı vardır. client.chat.completions.create() yerine client.beta.chat.completions.parse() çağrısını kullanmak isteriz. Bu, Grok’a çıktıyı belirli bir biçimde beklediğimizi bildirir ve Recipe şemamız response_format argümanı olarak iletilir.

Ayrıca, göreve ilişkin tüm temel talimatları sistem istemine koymak faydalıdır. Bu, Grok 4’ün konuşma boyunca odaklı ve tutarlı kalmasını sağlar. Şema ayrı tanımlandığından, kullanıcı istemi görevin kendisine odaklanabilir; çıktı JSON’u için gereken alanları listelemeye gerek yoktur.

Örneğin, Grok’u bir İtalyan şefi rolüne ayarlayabilir ve böylece sunduğu tüm tariflerin özgün İtalyan tarifleri olmasını sağlayabilirsiniz; pizzanıza ananas kaçması engellenir!

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

Grok 4’ün yapılandırılmış çıktısını ayrıştırdıktan sonra, düz metne göre faydaları netleşir. Bilgileri ihtiyaçlarınıza göre kolayca yeniden düzenleyip özelleştirebilir veya belirli veri noktalarını doğrudan otomatik iş akışlarına besleyebilirsiniz. Örneğimizde bu, malzemelerin kilogram fiyatlarını gereken miktarlarla hızlıca çarpabileceğimiz, kilerde zaten olanlara göre maliyetleri toplayabileceğimiz ve birkaç adımda porsiyon başı nihai fiyatı hesaplayabileceğimiz anlamına gelir.

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

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

Sonuç

Grok 4, daha büyük bir bağlam penceresi ve daha iyi akıl yürütme yetenekleri gibi yeni özellikler getiriyor. Görüntü tanıma ve fonksiyon çağırma, yapay zekâyı gerçek dünya verileri ve eylemleriyle birleştirmek için heyecan verici olanaklar sunarken, yapılandırılmış çıktılar güvenilir, makinece okunabilir yanıtlar sağlar. API kurulumu basittir ve yalnızca birkaç bağımlılıkla Python projelerinize hızlı entegrasyona olanak tanır.

Ve eğer tüm bu lazanya örnekleri sizi de acıktırdıysa, yalnız değilsiniz—ben de kendime bir dilim almaya gidebilirim!