Grok 4.6 API: Vom ersten Aufruf bis zum toolfähigen Agenten

Wie richtest du die Grok 4.6 API in Python ein?

Für den Start brauchst du einen SpaceXAI-API-Schlüssel und installierst das xai-sdk.

API-Schlüssel über console.x.ai erhalten

Um einen Grok-4.6-API-Schlüssel zu erstellen, rufen wir die SpaceX AI Console – API-Key-Erstellung auf. Anschließend klicken wir oben rechts auf Create API Key.

Das Formular zur Key-Erstellung ist selbsterklärend. Wir vergeben einen Namen, um den Key dem Projekt zuordnen zu können. Außerdem empfehle ich, immer ein Ablaufdatum zu setzen – als Failsafe, falls der Key kompromittiert wird.

Sobald der Key generiert ist, kopieren wir ihn und fügen ihn in eine Datei namens .env ein, die wir im gleichen Ordner anlegen, in dem wir unsere Python-Skripte schreiben. So lässt sich der Key im Skript bequem laden, ohne im Code zu stehen – was das versehentliche Teilen oder Hochladen in die Cloud verhindern hilft.

Die .env-Datei sollte folgenden Inhalt haben:

XAI_API_KEY=replace_with_the_api_key

xai-sdk installieren und SpaceXAI-API-Schlüssel laden

Zur Verbindung mit SpaceXAI per API-Schlüssel nutzen wir das Paket xai-sdk. Es ist gute Praxis, pro Projekt eine eigene Umgebung anzulegen, um Konflikte zwischen Python-Paketen unterschiedlicher Projekte zu vermeiden. Dazu verwenden wir Anaconda mit folgendem Befehl:

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

Ist die Umgebung aktiv, installieren wir die benötigten Pakete. Für den Anfang diese beiden:

• xai-sdk: Das offizielle SpaceXAI-Paket, um Anfragen an ihre API zu senden.

• python-dotenv: Ein Hilfspaket, das den API-Schlüssel bequem aus der .env-Datei lädt.

Zur Installation nutzen wir:

pip install xai-sdk python-dotenv

So lädst du den API-Schlüssel und erstellst in Python einen SpaceXAI-Client:

from dotenv import load_dotenv
from xai_sdk import Client

load_dotenv()

client = Client()

Beachte: Dieser Code sendet noch keine Anfrage. Als Nächstes lernst du, wie das geht.

SpaceXAI-API-Guthaben kaufen

Für die Nutzung der Grok-4.6-API müssen wir auf der API-Plattform Guthaben kaufen. Ohne Guthaben werden Anfragen abgewiesen. Gehe dazu zu Credits unten in der Seitenleiste, klicke auf Add credits und lade den gewünschten Betrag auf.

Wie teuer ist Grok 4.6 per API?

Anfragen an Grok 4.6 werden pro Token abgerechnet. Der Grundpreis liegt bei 2 $ pro eine Million Input-Token und 6 $ pro eine Million Output-Token.

Wichtig: Grok 4.6 ist ein Reasoning-Modell. Das Reasoning erfolgt als Selbstdialog und verbraucht ebenfalls Token, die als Output-Token abgerechnet werden. Später lernst du, wie du den Reasoning-Aufwand pro Anfrage steuerst.

Gecachte Token sind deutlich günstiger und kosten nur 0,5 $ pro eine Million Token.

Wie wir sehen werden, hat Grok drei eingebaute Tools, die getrennt von den Token abgerechnet werden: Websuche, X-Suche und Codeausführung. Alle kosten 5,00 $ pro 1.000 Aufrufe.

Für lange Kontexte gilt: Alle Token in Prompts oberhalb der 200k-Grenze werden zum doppelten Satz berechnet.

Wie machst du deinen ersten Grok-4.6-API-Call?

Aufbauend auf dem obigen Code nutzen wir den SpaceXAI-Client, um eine Anfrage an Grok 4.6 zu senden.

Dazu initialisieren wir eine Chatsession für grok-4.6 mit client.chat.create() und hängen unseren Prompt mit chat.append(user()) an den Gesprächsverlauf an.

Mit chat.sample() wird die Konversation schließlich an das Modell gesendet. Die Antwort zeigen wir über response.content an.

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)

So genutzt, erhältst du die Antwort am Stück – du wartest also, bis Grok die komplette Antwort generiert hat. Mit Streaming kannst du eine Wort-für-Wort-Ausgabe bekommen. 

Antwort-Streaming

Statt mit chat.sample() auf die vollständige Antwort zu warten, können wir chat.stream() verwenden und die Ausgabe des Modells in Echtzeit empfangen.

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

Dieser Code iteriert über den Stream, liefert inkrementelle Chunks und druckt jedes neue Textstück (chunk.content) sofort bei Eintreffen – für ein reaktionsschnelles Token-by-Token-Streaming.

Beim Ausführen fällt auf, dass das Modell dennoch etwas Zeit braucht, um mit der Tokenproduktion zu starten. Der Grund: Grok 4.6 ist ein Reasoning-Modell. Bevor es das erste sichtbare Wort der finalen Antwort erzeugt, durchläuft es standardmäßig eine interne „Chain-of-Thought“-Reasoningphase.

Wir können den obigen Code so erweitern, dass auch der Reasoning-Prozess angezeigt wird:

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

Der Grok-4.6-Stream liefert nach diesem Muster zwei Token-Typen:

• Die internen Chain-of-Thought-Token des Modells
• Die finale Antwort

Das Skript unterscheidet beide, indem es chunk.reasoning_content prüft, um Groks schrittweises Denken zuerst zu streamen, und anschließend chunk.content ausgibt, sobald die finale Antwort beginnt.

Wie stellst du den Reasoning-Aufwand in Grok 4.6 ein?

Wie oben gesehen, setzt Grok 4.6 – wie andere Frontier-Modelle – auf eine versteckte Chain of Thought. Bevor es ein Wort der finalen Antwort ausgibt, erzeugt es tausende Reasoning-Token, um Lösungen zu erkunden, Logik zu prüfen und eigene Fehler zu korrigieren.

Der Parameter reasoning_effort erlaubt, wie viel Aufwand das Modell in diesen Prozess steckt. Da auch Reasoning-Token berechnet werden, ist das ein wichtiger Hebel zur Kostensenkung.

Grok 3 mini ließ reasoning_effort bereits anpassen, aber Grok 4 entfernte diese Kontrolle – Reasoning war immer aktiv und nicht justierbar. SpaceXAI hat sie in der Grok-4.x-Linie (4.3 und 4.5) wieder eingeführt, und Grok 4.6 unterstützt sie ebenfalls – mit low, medium, high (Standard) und xhigh.

Den Reasoning-Aufwand setzen wir beim Initialisieren des Chats mit client.chat.create() über den Parameter reasoning_effort. Der Wert ist eine Zeichenkette. Standard ist "high". So setzen wir ihn z. B. auf "low":

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

Low vs. High beim gleichen Prompt

Ich habe viele Aufgaben mit low und high getestet – etwa ein kleines Spiel bauen, ein Skript zur Analyse von Payroll-Daten mit vielen schlecht formatierten Währungsangaben und Logikrätsel lösen.

In all diesen Fällen lieferte das Modell mit beiden Einstellungen ähnliche Lösungen.

Um wirklich einen Unterschied zu sehen, braucht es Aufgaben, bei denen ein Abbruch mitten im Reasoning scheitert. Also habe ich ein Rätsel mit vielen Lösungen gewählt. Hier ist der Prompt:

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.

Bei beiden Reasoning-Stufen fand Grok 4.6 korrekte Lösungen. Mit low war jedoch das Reasoning-Budget aufgebraucht, bevor es die Aufgabe vollständig abschließen konnte – die Antwort blieb unvollständig. Mit hohem Reasoning fand Grok 4.6 alle 264 Lösungen.

Zum Vergleich: Mit low verbrauchte es 16.422 Reasoning-Token, mit high 56.455.

Wann lohnt sich xhigh trotz vieler Token?

Wenn High komplexe Logikrätsel und Datenparserskripte per Brute-Force lösen kann – warum sollte man dann für xhigh und seinen massiven Tokenverbrauch zahlen?

Meiner Einschätzung nach ist xhigh für 99 % der täglichen Programmier- und Data-Science-Aufgaben überdimensioniert und verbrennt nur Budget.

Unverzichtbar wird xhigh, wenn du das Modell nicht mehr als Coding-Assistent, sondern als autonomen Agenten agieren lässt. Du bezahlst im Grunde dafür, dass das Modell seine Arbeit aggressiv prüft, in Sackgassen läuft und seine Logik neu schreibt, bevor es dir überhaupt etwas zeigt.

Mein Rat: Starte mit low und erhöhe nur, wenn das Modell eine Aufgabe systematisch verfehlt. Ja, in manchen Fällen zahlst du damit mehrfach für dasselbe Problem – meistens kommst du aber mit einer guten Lösung zum Bruchteil der Kosten davon.

Wie sendest du Bilder an die Grok-4.6-API?

Grok 4.6 ist multimodal und kann daher Bilddaten verarbeiten. 

Ein Bild per URL senden

Am einfachsten übergibst du ein Bild per URL. Wir geben sie als zweites Argument in der User-Nachricht mit:

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

Ein Bild per Datei-Upload senden

Oft möchten wir lokale Bilder statt URLs nutzen. Das geht, indem wir das Bild als Base64-String laden. Die Funktion encode_image() übernimmt das:

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

Sobald das Bild encodiert ist, übergeben wir es dem Modell genauso:

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

Trotz Bildinput gibt Grok 4.6 nur Text aus. Wenn du mehr über die Bildgenerierung von SpaceXAI erfahren willst, lies unser Tutorial zur Grok Imagine API.

Wie aktiviere ich Tools bei Grok-4.6-Agenten?

Grok 4.6 bietet Zugriff auf drei nützliche serverseitige Tools und die Möglichkeit, eigene Tools zu erstellen.

Serverseitige Tools aufrufen (Websuche, X-Suche, Codeausführung)

Grok 4.6 bringt drei Server-Tools mit:

• Websuche: Ermöglicht dem Agenten, eine Websuche durchzuführen und Antworten zu untermauern.
• X-Suche: Fragt Echtzeitdaten von X ab.
• Codeausführung: Führt Code in einer Sandbox aus, um die Anfrage zu beantworten.

Diese Tools laufen auf SpaceXAI-Servern; jeder Toolaufruf wird unabhängig von den Token berechnet.

Zur Aktivierung importieren wir sie und übergeben sie beim Erstellen des Chats mit client.chat.create():

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

Beim Streaming können wir über das Flag chunk.tool_calls erkennen, ob der Agent ein Tool nutzt.

So verarbeitest du den Stream, um anzuzeigen, wann der Agent ein Tool verwendet:

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)

Ein vollständiges Beispielskript mit Server-Tools findest du in meinem begleitenden GitHub-Repo.

Eigene lokale Tools implementieren

Neben den Server-Tools können wir unseren Grok-4.6-Agenten auch mit Custom Tools ausstatten. Schauen wir uns an, wie wir Tools implementieren, mit denen der Agent lokale Dateien lesen und schreiben kann.

Für ein Custom Tool brauchen wir zwei Dinge:

1. Eine Tool-Spezifikation mit dem offiziellen tool()-Objekt aus dem SpaceXAI SDK.

2. Eine Python-Implementierung des Tools – also den Code, der beim Toolaufruf ausgeführt wird.

Eine Tool-Spezifikation umfasst:

• Den Namen der aufzurufenden Python-Funktion.
• Eine Beschreibung, was das Tool macht. Das ist entscheidend, weil sie bestimmt, wann der Agent das Tool nutzt.
• Die Parameterspezifikation der Funktion.

Unten eine Funktion, mit der wir ein Tool zum Lesen lokaler Dateien implementieren:

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

Aus Sicherheitsgründen fragt das Tool vor jedem Lesezugriff nach deiner Erlaubnis. So verhinderst du, dass private Daten unbeabsichtigt an den Agenten gelangen.

Hier ist die Tool-Spezifikation zu dieser Funktion:

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

Der Code zum Schreiben in eine Datei ist ähnlich und steht in der Datei tools.py im Repository.

Wie baust du einen Tool-Using-Agent-Loop mit Grok 4.6?

In diesem Abschnitt kombinieren wir alles und bauen einen Grok-4.6-Agentenloop, in dem wir mit einem Agenten sprechen können, der echte Arbeit leistet: lokale Dateien bearbeiten und Antworten per Onlinesuche fundieren.

Der Agent arbeitet wie im folgenden Diagramm: Du sendest einen Prompt, der Agent antwortet – bei Bedarf unter Nutzung von Tools. Dann geht die Antwort an dich zurück und du kannst die Interaktion fortsetzen. 

Der Agent hält die gesamte Konversation nach, indem er mit chat.append() User-Prompts, Antworten und Tool-Ergebnisse anhängt. Ein Tool-Ergebnis wird in eine Instanz von tool_result() verpackt.

Hier ist die vollständige Agent-Implementierung:

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

Den Grok-4.6-Agenten mit einer Portfolioanalyse testen

Zum Testen habe ich eine Beispiel-CSV für ein Aktienportfolio erstellt. Die Datei ist recht einfach und listet Aktien – insbesondere mit Kaufdatum und Kaufkurs. 

Die Idee ist, den Agenten zu bitten:

1. Die CSV zu laden.
2. Eine Websuche durchzuführen, um die aktuellen Kurse der Aktien zu ermitteln.
3. Die CSV zu aktualisieren und eine neue Spalte mit den aktuellen Kursen hinzuzufügen.
4. Einen Bericht zu unserem Portfolio zu erstellen, der die neuesten Entwicklungen in unseren Sektoren zeigt.

Unten siehst du einen Screenshot der Interaktion mit dem Agenten für die Schritte 1 bis 3.

Dabei nutzte er Websuche, Codeausführung und unsere Custom Tools zum Lesen und Schreiben lokaler Dateien. Am Ende ergänzte er die CSV um eine neue Spalte mit den aktuellen Kursen.

Weil der Agent in einer Schleife läuft, können wir die Unterhaltung fortsetzen. Im nächsten Schritt bat ich ihn, News zu diesen Aktien zu recherchieren, die Portfoliodiversität zu analysieren und einen Markdown-Report zu erstellen.

Wenn du neugierig auf den Report bist, findest du ihn im GitHub-Repository.

Der Test an einer realen Aufgabe wie der Analyse eines Aktienportfolios zeigt eindrucksvoll, was Grok 4.6 kann. Durch Websuche, Codeausführung und lokale Tools erledigt das Modell komplexe Anforderungen souverän.

Prompt-Caching und die 200k-Preisklippe

Bei einem Multi-Turn-Agenten sollten wir sicherstellen, dass die Konversation gecacht wird, damit das Modell nicht bei jeder Interaktion die gesamte Historie neu verarbeiten muss. Andernfalls können enorme Kosten entstehen.

Caching passiert automatisch, aber Cache-Einträge werden pro Server gespeichert. Standardmäßig können Anfragen an unterschiedliche Server geroutet werden und so den Cache verfehlen. Um Cache-Hits zu maximieren, geben wir eine stabile Konversations-ID an, damit alle Anfragen einer Unterhaltung denselben Server erreichen. Wie du sie übergibst, hängt von der API ab:

• xai-sdk (gRPC): x-grok-conv-id, als gRPC-Metadaten beim Initialisieren des Clients

• OpenAI Responses API: prompt_cache_key, im Request-Body

Das folgende Snippet zeigt, wie es geht:

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]

Wichtig zu wissen: Die finanzielle Belastung wird bei langen Gesprächen besonders hoch. Erreicht oder überschreitet deine Gesamteingabe 200.000 Token, greift ein 2×-Multiplikator – die gesamte Anfrage wird zum doppelten Standardsatz abgerechnet.

Um zu verhindern, dass Multi-Turn-Loops über diese 200k-Grenze hinauswachsen, empfiehlt sich Context-Compaction: Ältere Turns periodisch zusammenfassen oder das Kontextfenster verschieben. So profitierst du weiter von günstigen Cache-Hits für deine Kerninstruktionen und vermeidest die hohen Mehrkosten eines endlos wachsenden Kontextfensters.

Fazit

In diesem Tutorial hast du gelernt, wie du die SpaceXAI-API mit Python nutzt, um mit Grok 4.6 zu interagieren. Wir haben die Basics zum Senden von Text- und Bildprompts behandelt und gesehen, wie du die Ausgabe so aufbereitest, dass Nutzerinnen und Nutzer den Arbeitsstand des Modells sehen. 

Mit Tools für das KI-Modell konnten wir daraus einen KI-Agenten bauen, der mit Grok 4.6 reale Aufgaben löst – etwa die Analyse eines Aktienportfolios. Und wir haben gelernt, dass lange Kontexte sehr teuer werden können, insbesondere ohne Caching.

Als Übung: Implementiere Caching im Agenten und erweitere die Ausgabe um die Anzeige von Reasoning-Token. 

Wenn du dein Wissen zum Bau von KI-Agenten über APIs vertiefen willst, empfehle ich unseren Kurs Working with the OpenAI API. Am tiefsten steigst du im AI Agent Fundamentals Skill Track ein.