Grok 4 API: Eine Schritt-für-Schritt-Anleitung mit Beispielen

Erste Schritte mit der Grok 4 API

Bevor wir unsere erste Anfrage stellen, brauchen wir einen API-Schlüssel und eine Python-Umgebung, die sich mit der Grok-API verbinden kann.

Deinen API-Schlüssel erstellen

Um einen API-Schlüssel zu erstellen, mit dem du den Client bei der API authentifizieren kannst, machst du Folgendes:

1. Schau mal auf der offiziellen xAI-Dokumentationsseite.
2. Melde dich mit deinem X-, xAI- oder Google-Konto an. Wenn du noch kein Konto hast, kannst du dich für ein neues xAI-Konto anmelden.
3. Such die Option „API-Schlüssel erstellen“. Gib einen Namen für deinen Schlüssel ein und klick auf „Speichern“.
4. Sobald dein Schlüssel angezeigt wird, kopiere ihn sofort. Du kannst ihn später nicht mehr sehen, aber bei Bedarf kannst du jederzeit einen neuen erstellen.
5. Erstell in deinem Projektverzeichnis eine Datei mit dem Namen .env. Füge deinen API-Schlüssel in diesem Format ein:

XAI_API_KEY=<your_api_key_here>

Preise für die Grok 4 API

Die Nutzung der API kann zwar günstiger sein als ein Premium-Abo, ist aber nicht kostenlos. Anders als beim SuperGrok-Tarif, der bei 30 $ pro Monat für ein festes Abonnement anfängt, hängen die API-Kosten komplett davon ab, wie viel du den Service nutzt. Wenn du aber auf Grok 4 Heavy zugreifen willst, läuft das anders: Du brauchst ein aktives SuperGrok Heavy-Abo (300 $ pro Monat), auch wenn du die API nutzt.

Eine detaillierte Aufschlüsselung der möglichen Kosten findest du auf der Preisseite auf xAI.

Quelle: xAI

Die Preise für die Grok-API hängen davon ab, wie viel du sie nutzt, und werden pro Million Tokens berechnet. Zur Info: Eine Million Tokens sind ungefähr 750.000 englische Wörter, egal ob als Eingabe oder Ausgabe. Obwohl das Kontextfenster im Vergleich zum Vorgängermodell fast doppelt so groß ist, kostet Grok 4 genau so viel wie das Standardmodell Grok 3. Du zahlst 3 $ pro Million Eingabetoken und 15 $ pro Million Ausgabetoken.

Um die API nutzen zu können, musst du Credits kaufen. Am Anfang ist es besser, Prepaid-Guthaben zu nutzen, statt sich automatisch etwas berechnen zu lassen – so vermeidest du böse Überraschungen. Du kannst Tokens kaufen und deine Nutzung in der xAI-Konsole unter „Rechnungen“ > „Guthaben“ verfolgen.

Python-Umgebung einrichten

Sobald du deinen API-Schlüssel und deine Credits hast, musst du als Nächstes deine Python-Umgebung vorbereiten. Für eine reibungslose API-Integration brauchst du zwei Pakete:

• python-dotenv Lade deinen API-Schlüssel aus der Datei „ .env “ als Umgebungsvariable.
• Der Client „ openai ” für die Interaktion mit der Grok 4 API.

Um die Abhängigkeiten deines Projekts übersichtlich zu halten, solltest du Anaconda verwenden. Nach der Installation von Anaconda richtest du eine neue Umgebung namens „ grok4 “ mit Python 3.10 ein, indem du Folgendes ausführst:

conda create -n grok4 python=3.10
conda activate grok4

Wenn deine Umgebung läuft, installier die benötigten Pakete:

pip install python-dotenv openai

Letzte Vorbereitungen

Lass uns loslegen und unser erstes Skript schreiben. Importiere zuerst die benötigten Funktionen aus den installierten Paketen zusammen mit „ os “, um auf deinen API-Schlüssel zugreifen zu können:

import os
from dotenv import load_dotenv
from openai import OpenAI

Als Nächstes lädst du mit „ load_dotenv() “ aus dem Paket „ dotenv “ deine Umgebungsvariablen, damit dein API-Schlüssel für das Skript verfügbar ist:

# Load environment variables
load_dotenv()

Jetzt musst du den API-Client initialisieren, indem du deinen API-Schlüssel (aus der Datei „ .env “) und die Grok-Server-URL an die Klasse „ OpenAI “ übergibst (in diesem Tutorial verwenden wir das OpenAI SDK, aber Grok 4 hat auch ein natives xAI Python SDK, das auch mit dem SDK von Antrhopic kompatibel ist). Weise dies der Variablen „ client “ zu:

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

Mit diesen Schritten ist dein Skript bereit, Anfragen an Grok 4 zu senden.

Bilderkennung mit Grok 4

Jetzt, wo wir alles vorbereitet haben, lass uns mal die Bilderkennung ausprobieren, eine der neuen Funktionen von Grok 4. Wir zeigen dir das, indem wir das Foto einer vegetarischen Lasagne hochladen und Grok bitten, die sichtbaren Zutaten zu erkennen.

Um ein Bild mit der Grok 4 API zu analysieren, müssen wir eine Anfrage senden, die sowohl ein Bild als auch eine Eingabeaufforderung enthält. Am besten nimmst du einen Python-Client, der mit OpenAI klarkommt, gibst als Modell „ grok-4 “ an und fügst die Bild-URL und deine Frage in das Nachrichten-Array ein. Die API gibt eine detaillierte Antwort zurück, die den Inhalt des Bildes beschreibt und auf die im Antwortobjekt zugegriffen werden kann.

Bevor wir die Anfrage abschicken, müssen wir sichergehen, dass das Bild die API-Anforderungen erfüllt. Es werden nur JPEG- und PNG-Formate unterstützt, und die Datei darf nicht größer als 20 MB sein. Das Bild muss über einen direkten Link erreichbar sein und der Server muss den richtigen Content-Type-Header senden (entweder image/jpeg oder image/png).

Nachdem wir die benötigten Pakete importiert, deine Umgebungsvariablen geladen und den Client eingerichtet haben, können wir unsere Abfrage so senden:

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

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? 😊

In diesem Fall hat Grok sogar nur anhand des Bildes erkannt, dass es sich um eine vegetarische Version handelt – echt beeindruckend!

Mit Grok argumentieren 4

Grok 4 ist für fortgeschrittenes Denken gemacht und kann komplizierte Probleme Schritt für Schritt lösen. Anders als bei einigen früheren Modellen zeigt Grok 4 aber nicht, wie es zu seinen Antworten kommt, sodass du keinen detaillierten „Denkprozess” oder eine Gedankenkette als separates Feld aus der API-Antwort herausziehen kannst. Die Ausgabe, die du bekommst, ist die endgültige Antwort, nicht die Zwischenschritte des Modells oder der Rohdaten.

Außerdem unterstützt Grok 4 den Parameter „ reasoning_effort “ nicht, der zum Beispiel in Grok 3 mini verwendet wird (mehr über diesen Parameter erfährst du in diesem Grok 3 API-Tutorial). Das heißt, du kannst nicht einstellen, wie viel das Modell „nachdenkt“, bevor es zu einer endgültigen Schlussfolgerung kommt. Deshalb wird jede Argumentationsabfrage genau wie eine normale Abfrage aufgebaut.

Probieren wir Grok mit einer weiteren Aufgabe zum Thema Lasagne aus und bitten wir es, seine Überlegungen in der Ausgabe zu zeigen.

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

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

Ich habe Groks Antwort gekürzt, um die wichtigsten Punkte hervorzuheben, aber auch in dieser kürzeren Version wird deutlich, dass das Modell seine Aufgabe gut erfüllt hat. Grok ging Schritt für Schritt vor, um

• Versteh die Diätvorschriften
• Die verfügbaren Rezepte checken
• Wähle die beste Rezeptkombination aus
• Schlag doch mal konkrete Zutaten vor, die man ersetzen könnte.
• Gib eine komplette Liste der geänderten Zutaten an.
• Komm nochmal drauf zurück, warum es alle zufriedenstellt.
• Mögliche Nachteile und Alternativen besprechen

Funktionsaufruf mit Grok 4

Genau wie sein Vorgänger unterstützt Grok 4 auch Funktionsaufrufe. Damit kann das Modell direkt mit externen Tools und Diensten interagieren. Das heißt, Grok kann nicht nur Texte erstellen, sondern auch Sachen machen wie Wetter-Updates holen, Veranstaltungszeiten checken, Datenbank-Einträge analysieren oder sogar Smart-Home-Geräte bedienen.

Wenn du eine Anfrage sendest, kann Grok feststellen, ob zusätzliche Daten benötigt werden, und fordert dann den Aufruf einer bestimmten Funktion mit den richtigen Parametern an. Der Python-Client kümmert sich darum, diese Funktion lokal auszuführen, gibt das Ergebnis an Grok zurück, und schon bekommst du eine vollständige, gut begründete Antwort.

Vorbereitung

Um mit Funktionsaufrufen zu arbeiten, müssen wir das Paket „ json “ importieren, das uns den Zugriff auf die Argumentstruktur jeder von Grok aufgerufenen Funktion ermöglicht. Als Nächstes machen wir eine Callback-Funktion klar, die Grok aufruft, wenn es bestimmte Daten braucht.

In diesem Beispiel ist die Funktion „ suggest_lasagna_recipe “ eine einfache Python-Funktion, die einen festen Rezeptvorschlag zurückgibt. Dieser fest programmierte Ansatz macht die Demo einfach und vermeidet Abhängigkeiten von externen Diensten.

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

Wir müssen auch das Tool festlegen, das Grok aufrufen kann. Dazu musst du den Namen des Tools, seinen Zweck und die benötigten Parameter in einem JSON-Schema angeben. Dieses Schema wird zusammen mit der Anfrage an Grok geschickt und sagt ihm, dass er dieses Tool rufen kann, wenn er zusätzliche Infos braucht, um seine Schlussfolgerungen zu unterstützen.

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

Schließlich verbindet das Wörterbuch „ tools_map “ die von Grok verwendeten Funktionsnamen mit den tatsächlichen Python-Funktionen in deinem Code. Mit dieser Zuordnung kann der Client die angeforderten Funktionsaufrufe richtig ausführen.

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

Während das manuelle Definieren von Werkzeugschemata für einfache Projekte gut funktioniert, empfiehlt sich für komplexere Projekte die Verwendung einer Datenvalidierungsbibliothek wie Pydantic empfehlenswert, wenn dein Projekt größer wird. Pydantic macht die automatische Überprüfung von Funktionseingaben und eine bessere Fehlerbehandlung möglich, was zu saubererem und besser wartbarem Code führt.

Ausführung

Schauen wir mal, ob Grok unsere Funktion nutzt, wenn es nach einem Lasagne-Rezept gefragt wird. So läuft der Ablauf beim Aufruf der Funktion ab:

1. Zuerst schicken wir eine Frage von einem Nutzer – „Welche Lasagne kann ich mit meinen Zutaten machen?“ – zusammen mit den verfügbaren „ tools “ an Grok. 
2. Grok checkt dann die Anfrage und fragt, wenn es einen Funktionsaufruf braucht, nach dem Rezept, indem es unsere lokale Funktion startet. Wenn kein Tool aufgerufen wird, nehmen wir einfach die erste Antwort von Grok.
3. Wenn ein Tool-Aufruf angefordert wird, führen wir die entsprechende lokale Funktion aus und fügen das Ergebnis zum laufenden Nachrichtenverlauf hinzu.
4. Diese aktualisierte Historie wird dann an Grok zurückgeschickt, damit es seine Schlussfolgerungen vervollständigen und eine endgültige, kontextbezogene Antwort geben kann.

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

suggest_lasagna_recipe successfully called

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

Wie wir sehen können, hat Grok unsere Funktion aufgerufen und das passende Rezept vorgeschlagen.

Du wirst vielleicht auch das Argument „ tool_choice “ in der ersten Anfrage bemerken. Standardmäßig entscheidet Grok mit „auto“, ob und welche Funktion aufgerufen wird. Wenn du mehr Kontrolle haben willst, kannst du einen bestimmten Funktionsaufruf erzwingen, genau angeben, welche Funktion verwendet werden soll, oder den Funktionsaufruf komplett deaktivieren, indem du diesen Parameter änderst.

Strukturierte Ausgaben mit Grok 4

Ähnlich wie bei Funktionsaufrufen sind strukturierte Ausgaben eine Funktion, die mit Grok 3 eingeführt wurde. Sie lassen Grok Antworten in einem strengen Format wie JSON statt in reinem Text liefern. Mit diesem Ansatz kannst du die Antworten des Modells in deinen Anwendungen oder Arbeitsabläufen viel einfacher analysieren, überprüfen und nutzen.

Wenn du vorher ein Schema festlegst, kannst du sicher sein, dass die Ergebnisse von Grok immer einheitlich, maschinenlesbar und für die weitere Verarbeitung bereit sind. Das ist besonders praktisch, wenn du strukturierte Daten aus Dokumenten extrahieren oder KI-generierte Inhalte direkt in Datenbanken, Dashboards oder Automatisierungstools senden musst, ohne dir Gedanken über unzuverlässige Textanalyse machen zu müssen.

Um das Ausgabeschema zu definieren, benutzen wir Pydantic, das die Strukturierung komplexer Daten einfacher und übersichtlicher macht (dieses Pydantic-Tutorial hilft dir dabei, mehr darüber zu erfahren). Dafür musst du sowohl „ BaseModel ” als auch „ Field ” von pydantic importieren. Da unsere Ausgabe eine Liste von Zutaten enthält, importieren wir auch „ List “ aus dem Python-Modul „ typing “, um den Typ jedes Listenelements klar anzugeben.

Wir könnten das Schema zwar mit einfachem JSON einrichten, aber Grok gibt manchmal Ergebnisse zurück, die nicht ganz der erwarteten Struktur entsprechen. Die Bedeutung kann zwar dieselbe sein, aber das Schema kann abweichen, was zu Problemen führen kann, wenn deine Anwendung ein bestimmtes Format braucht. Das gilt vor allem für verschachtelte Elemente wie Listen. Deshalb empfehle ich Pydantic – damit wird die strukturierte Ausgabe jedes Mal zuverlässig validiert und geparst.

In unserem Beispiel enthält das Schema – „ Recipe“ genannt – den Namen, die Anzahl der Portionen und eine Liste der Zutaten. Jede „ Ingredient ” hat einen Namen, die Menge, die für das Rezept gebraucht wird, ob sie verfügbar ist, den Preis pro Kilogramm und ob sie vegetarisch, vegan oder glutenfrei ist. Es ist praktisch, Standardwerte direkt im Schema festzulegen, so wie wir es gerade für die Anzahl der Portionen machen.

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

Bei der Anfrage solltest du ein paar Sachen beachten. Anstatt „ client.chat.completions.create() “ zu verwenden, möchten wir „ client.beta.chat.completions.parse() “ aufrufen. Das sagt Grok, dass wir die Ausgabe in einem bestimmten Format brauchen, und unser Schema „ Recipe“ wird als Argument „ response_format “ übergeben.

Es ist auch hilfreich, alle wichtigen Anweisungen für die Aufgabe in die Systemaufforderung zu schreiben. Dadurch bleibt Grok 4 während der gesamten Unterhaltung fokussiert und konsistent. Da das Schema separat definiert ist, kann sich die Benutzeraufforderung auf die eigentliche Aufgabe konzentrieren, ohne die erforderlichen Felder für die JSON-Ausgabe auflisten zu müssen.

Du könntest Grok zum Beispiel so einrichten, dass es die Rolle eines italienischen Kochs übernimmt und dafür sorgt, dass alle Rezepte, die es serviert, echt italienisch sind, sodass du keine Ananas auf deiner Pizza findest!

# 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,
)

Sobald wir die strukturierte Ausgabe von Grok 4 analysiert haben, werden die Vorteile gegenüber reinem Text klar. Wir können die Infos ganz einfach an unsere Bedürfnisse anpassen oder sogar bestimmte Daten direkt in automatisierte Arbeitsabläufe einspeisen. In unserem Beispiel heißt das, dass wir schnell die Preise pro Kilogramm der Zutaten mit den benötigten Mengen multiplizieren, die Kosten für das, was schon in der Speisekammer ist, zusammenzählen und mit nur ein paar Schritten den Endpreis pro Portion berechnen können.

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

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.7625

Fazit

Grok 4 hat neue Features wie ein größeres Kontextfenster und bessere Schlussfolgerungsfähigkeiten. Die Bilderkennung und Funktionsaufrufe eröffnen coole Möglichkeiten, KI mit echten Daten und Aktionen zu verbinden, während strukturierte Ausgaben zuverlässige, maschinenlesbare Antworten liefern. Die API-Einrichtung ist einfach und ermöglicht eine schnelle Integration in deine Python-Projekte mit nur wenigen Abhängigkeiten.

Und wenn dir bei all den Lasagne-Beispielen der Magen knurrt, bist du nicht allein – ich glaube, ich muss mir auch ein Stück holen!