Grok 4.6 API: Från första anrop till en verktygsanvändande agent

Hur sätter du upp Grok 4.6 API i Python?

För att komma igång behöver du en SpaceXAI‑API‑nyckel och installera xai-sdk.

Skaffa en API‑nyckel från console.x.ai

För att skapa en Grok 4.6‑API‑nyckel går vi till SpaceX AI‑konsolens sida för API‑nycklar. Därefter klickar vi på knappen Create API Key uppe till höger.

Formuläret för att skapa API‑nyckeln är rakt på sak. Vi ger nyckeln ett namn för att känna igen vilket projekt den tillhör. Jag rekommenderar också alltid att sätta ett utgångsdatum för API‑nycklar som en säkerhetsåtgärd om de skulle komprometteras.

När nyckeln har genererats kopierar vi den och klistrar in den i en fil med namnet .env som vi skapar i samma mapp där vi ska skriva våra Python‑skript. Då blir det lätt att ladda nyckeln i skriptet utan att den ligger i kodfilen, vilket annars lätt skulle leda till att vi av misstag exponerar nyckeln när vi delar eller laddar upp koden till molnet.

Filen .env ska ha följande innehåll:

XAI_API_KEY=replace_with_the_api_key

Installera xai-sdk och ladda SpaceXAI‑API‑nyckeln

För att ansluta till SpaceXAI med API‑nyckeln använder vi paketet xai-sdk. Det är god praxis att skapa en separat miljö för varje projekt för att undvika konflikter mellan Python‑paket i olika projekt vi kan ha. För att göra det använder vi Anaconda med följande kommando:

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

När den är aktiv kan vi installera de paket vi vill. Låt oss tills vidare börja med:

• xai-sdk: Det officiella SpaceXAI‑paketet för att göra förfrågningar till deras API.

• python-dotenv: Ett hjälppaket som gör det enkelt att ladda API‑nyckeln från .env-filen.

För att installera dem använder vi kommandot:

pip install xai-sdk python-dotenv

Så här kan vi ladda API‑nyckeln och skapa en SpaceXAI‑klient i Python:

from dotenv import load_dotenv
from xai_sdk import Client

load_dotenv()

client = Client()

Observera att den här koden inte gör någon begäran ännu. Det lär vi oss härnäst.

Köpa SpaceXAI‑API‑krediter

För att använda Grok 4.6‑API:t behöver vi också köpa krediter på deras API‑plattform. Utan dessa kommer API‑begäranden att nekas. Gå till Credits längst ned i sidofältet, klicka på Add credits och lägg till önskat belopp.

Hur dyrt är Grok 4.6 via API?

Begäranden till Grok 4.6 debiteras per token. Grundpriset är 2 $ per miljon input‑token och 6 $ per miljon output‑token.

Det är viktigt att notera att Grok 4.6 är en resonemangsmodell. Resonemanget sker som en intern självdialog och förbrukar också token, som debiteras som output‑token. Vi lär oss senare hur vi kan styra mängden resonemang modellen utför för en given begäran.

Cache:ade token är mycket billigare och kostar bara 0,5 $ per miljon token.

Som vi ska se har Grok tre inbyggda verktyg som debiteras separat från token: webbsökning, X‑sökning och kodkörning. Alla dessa kostar 5,00 $ per 1 000 anrop.

För långa kontexter är det värt att notera att alla token i prompter som överskrider tröskeln 200K debiteras till dubbla priset.

Hur gör du ditt första Grok 4.6‑API‑anrop?

Låt oss bygga vidare på koden ovan för att använda SpaceXAI‑klienten och skicka en begäran till Grok 4.6.

För att skicka en begäran till Grok 4.6 initierar vi en chatsession riktad mot grok-4.6 med client.chat.create() och lägger till vår prompt i konversationshistoriken med chat.append(user()).

Till sist skickar chat.sample() konversationen till modellen för att generera ett svar, som vi visar genom att skriva ut response.content.

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)

När vi använder Grok på detta sätt får vi svaret på en gång, så vi behöver vänta tills Grok har genererat hela svaret innan något visas. Vi kan få ett ord‑för‑ord‑svar genom strömning. 

Strömning av svar

I stället för att vänta på det kompletta svaret med chat.sample() kan vi använda chat.stream() för att ta emot modellens utdata i realtid.

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

Den här koden itererar över strömmen, levererar inkrementella chunk‑objekt och skriver ut varje nytt textstycke (chunk.content) till konsolen så snart det kommer, vilket skapar en responsiv token‑för‑token‑strömning.

När vi kör koden märker vi att det fortfarande tar modellen en stund att börja producera token. Anledningen är att Grok 4.6 är en resonemangsmodell. Som standard går modellen igenom en intern "chain-of-thought"‑resonemangsfas innan den genererar det första synliga ordet i det slutliga svaret.

Vi kan uppdatera koden ovan för att även visa modellens resonemangsprocess, så här:

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

Grok 4.6‑strömmen efter denna snutt levererar två typer av token:

• Modellens interna chain‑of‑thought‑token
• Det slutliga svaret

Detta skript skiljer mellan de två genom att kontrollera chunk.reasoning_content för att först strömma Groks steg‑för‑steg‑tänkande, och därefter skriva ut chunk.content när det slutliga svaret börjar.

Hur kan du ställa in resonemangsinsatsen i Grok 4.6?

Som vi såg ovan, liksom andra frontier‑modeller, förlitar sig Grok 4.6 på en dold chain of thought. Innan den skriver ett enda ord av sitt slutliga svar genererar den tusentals resonemangstoken för att utforska lösningar, dubbelkolla logik och korrigera egna misstag.

Parametern reasoning_effort låter oss styra hur mycket ansträngning modellen lägger på denna process. Eftersom vi också betalar för resonemangstoken, inte bara det slutliga svaret, är detta en viktig parameter att hantera om vi vill minska kostnaderna.

Grok 3 mini lät redan utvecklare justera reasoning_effort, men Grok 4 tog bort den kontrollen. Dess resonemang var alltid på och kunde inte justeras. SpaceXAI återinförde kontrollen i hela Grok 4.x‑serien (4.3 och 4.5), och Grok 4.6 stöder den också, med low, medium, high (standard) och xhigh.

För att ställa in resonemangsinsatsen använder vi parametern reasoning_effort när vi initierar chatten med client.chat.create(). Värdet är en sträng med den insats vi vill ha. Standardvärdet är "high". Här är ett exempel på hur vi kan sätta den till "low":

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

Jämförelse mellan low och high på samma prompt

Jag har testat många uppgifter med både low och high resonemang, såsom att bygga ett litet spel, skapa ett skript för att analysera löneunderlag med flera illa formaterade valutafält och lösa logikpussel.

I alla dessa fall kunde modellen ge liknande lösningar med antingen låg eller hög resonemangsnivå.

För att göra skillnad behöver vi en uppgift där ett avbrott mitt i resonemanget leder till misslyckande. Så jag valde ett pussel med många lösningar. Här är prompten jag använde:

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.

På båda resonemangsnivåerna hittade Grok 4.6 korrekta lösningar. Men när den var inställd på low tog resonemangsbudgeten slut innan uppgiften kunde slutföras. Därför svarade den med en ofullständig lösning. Med hög resonemangsnivå hittade Grok 4.6 samtliga 264 lösningar.

Som jämförelse använde den 16 422 resonemangstoken med low, medan den använde 56 455 med high.

När är xhigh värt extra token?

Om high‑läget kan brute‑forca komplexa logikpussel och data‑parsingskript, varför skulle någon betala för xhigh:s massiva tokenförbrukning?

Jag tror att för 99 % av dagliga programmerings- och data science‑uppgifter är xhigh överkurs som bara bränner din API‑budget.

Däremot blir xhigh oumbärligt när du går från att be modellen agera kodassistent till att be den agera som en autonom agent. Du betalar i praktiken för att modellen aggressivt ska granska sitt eget arbete, köra fast och skriva om sin logik innan den ens visar dig det slutliga resultatet.

Mitt råd är att börja med low och bara öka om modellen systematiskt misslyckas med en uppgift. Det är sant att vi i vissa fall då betalar flera gånger för samma problem, men oftast klarar vi oss med en bra lösning till en bråkdel av kostnaden.

Hur skickar du bilder till Grok 4.6 API?

Grok 4.6 är multimodal och kan därmed hantera bilddata. 

Skicka en bild via URL

Det enklaste sättet att ge modellen en bild är via en URL. Vi kan ange den som ett andra argument till användarmeddelandet:

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

Skicka en bild via filuppladdning

Ofta vill vi använda lokala bilder i stället för URL:er. Detta kan göras genom att ladda bilden som en base64‑sträng. Funktionen encode_image() kan göra det åt oss:

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

När bilden väl är kodad ger vi den till modellen på samma sätt:

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

Trots stöd för bildinmatning ger Grok 4.6 endast text som utdata. Om du vill lära dig mer om SpaceXAI:s bildgenerering rekommenderar jag vår guide om Grok Imagine API.

Hur aktiverar jag verktyg med Grok 4.6‑agenter?

Grok 4.6 ger tillgång till tre användbara server‑side‑verktyg och erbjuder möjlighet att skapa egna verktyg.

Anropa server‑side‑verktyg (webbsökning, X‑sökning, kodkörning)

Grok 4.6 kommer utrustad med tre serververktyg:

• Webbsökning: Låter agenten göra en webbsökning för att förankra svaret.
• X‑sökning: Frågar efter realtidsdata från plattformen X.
• Kodkörning: Kör kod i en sandlåda för att hjälpa till att besvara frågan.

Dessa verktyg körs på SpaceXAI:s servrar, och varje verktygsanrop debiteras oberoende av token.

För att aktivera dem behöver vi importera dem och tillhandahålla dem när vi instansierar chatten med 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()],
)

När vi strömmar svaren kan vi se om agenten använder ett verktyg genom att kontrollera flaggan chunk.tool_calls.

Här är en kodsnutt som visar hur man bearbetar den strömmade responsen på ett sätt som visar användaren när agenten använder ett verktyg:

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)

Ett fullständigt exempelskript med serververktyg finns i det medföljande GitHub‑repo:t.

Implementera egna lokala verktyg

Utöver serververktygen ovan kan vi också utrusta vår Grok 4.6‑agent med egna verktyg. Låt oss se hur vi kan implementera verktyg som låter agenten läsa och skriva till lokala filer.

För att implementera ett eget verktyg behöver vi två saker:

1. En verktygsspecifikation med det officiella objektet tool() från SpaceXAI SDK.

2. En Python‑implementation av verktyget, det vill säga koden vi vill köra när verktyget anropas.

En verktygsspecifikation består av:

• Namnet på Python‑funktionen som ska anropas.
• En beskrivning som förklarar vad verktyget gör. Detta är avgörande eftersom det styr när agenten anropar verktyget.
• Funktionens parameterspecifikation.

Nedan är en funktion vi kan använda för att implementera ett verktyg som läser lokala filer:

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

Av säkerhetsskäl implementerade vi verktyget så att det alltid frågar användaren om tillstånd innan en fil läses. Detta förhindrar att privat data oavsiktligt tillhandahålls agenten.

Här är verktygsspecifikationen för den här funktionen:

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

Koden för att skriva till en fil är snarlik och finns i filen tools.py i repo:t.

Hur kör du en verktygsanvändande agentloop med Grok 4.6?

I det här avsnittet sätter vi samman allt vi lärt oss för att bygga en Grok 4.6‑agentisk loop där vi kan prata med en agent som kan utföra faktiskt arbete genom att agera på lokala filer samtidigt som svaren förankras med onlinedata via sökning.

Agenten fungerar som i diagrammet nedan. Användaren skickar en prompt, agenten svarar sedan med verktyg vid behov. Sedan skickas svaret tillbaka till användaren, som kan fortsätta interagera med agenten. 

Agenten håller reda på hela konversationen genom att använda funktionen chat.append() för att lägga till användarprompter, svar och verktygsresultat. Ett verktygsresultat måste kapslas i en instans av tool_result().

Här är hela agentimplementeringen:

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

Testa Grok 4.6‑agenten för att göra en aktieportföljanalys

För att testa agenten skapade jag en exempel‑CSV för en aktieportfölj. Filerna är ganska enkla och listar aktier, särskilt köpedatum och köppris. 

Tanken är att be agenten att:

1. Läsa in CSV‑filen.
2. Göra en webbsökning för att hämta aktuella kurser för var och en av aktierna.
3. Uppdatera CSV:n genom att lägga till en ny kolumn med aktuella kurser.
4. Be agenten skapa en rapport om vår portfölj som visar de senaste händelserna i våra sektorer.

Nedan är en skärmdump av interaktionen med agenten för steg 1 till 3.

Vi ser att den använde webbsökning, kodkörning och de egna verktyg vi skapade för att läsa och skriva till lokala filer. Till slut uppdaterade den CSV‑filen genom att lägga till en ny kolumn med aktuella aktiekurser.

Eftersom agenten körs i en loop kan vi fortsätta konversationen. I nästa interaktion bad jag den att leta upp nyheter relaterade till dessa aktier, analysera portföljens diversifiering och skapa en markdown‑rapport.

Om du är nyfiken på rapporten den skapade finns den i GitHub‑repo:t.

Att testa agenten på en verklig uppgift som att analysera en aktieportfölj visar verkligen vad Grok 4.6 kan göra. Genom att använda webbsökningar, köra kod och nyttja lokala verktyg på egen hand hanterar modellen enkelt komplicerade förfrågningar.

Prompt‑cache och prisklipp vid 200k

När vi implementerar en agent med flera turer bör vi se till att konversationen cachas så att modellen inte behöver bearbeta hela historiken vid varje interaktion. Att inte göra det kan medföra enorma kostnader.

Caching sker automatiskt, men cacheposter lagras per server och som standard kan begäranden dirigeras till olika servrar och missa cachen. För att maximera cache‑träffar tillhandahåller vi en stabil konversationsidentifierare så att alla begäranden i en konversation når samma server. Hur du skickar den beror på API:et:

• xai-sdk (gRPC): x-grok-conv-id, skickas som gRPC‑metadata när klienten initieras

• OpenAI Responses API: prompt_cache_key, ställs in i begärandekroppen

Följande snutt visar hur man gör:

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]

En viktig aspekt är att den ekonomiska bestraffningen blir särskilt kännbar vid omfattande konversationer. När din totala promptlängd når eller överstiger 200k token tillämpas en 2×‑multiplikator, och hela begäran debiteras till dubbla standardpriset.

För att förhindra att loopar med flera turer passerar denna 200k‑tröskel rekommenderas starkt att implementera kontextkomprimering. Detta görs genom att periodiskt sammanfatta äldre turer i konversationen eller skjuta kontextfönstret. Strategin gör att du fortsatt kan dra nytta av billiga cache‑träffar på dina kärninstruktioner samtidigt som du undviker de hårda ekonomiska påföljderna av ett oändligt växande kontextfönster.

Slutsats

I den här handledningen lärde vi oss hur man använder SpaceXAI‑API:t med Python för att interagera med Grok 4.6. Vi gick igenom grunderna i att skicka text- och bildprompter och hur man hanterar utdata för att låta användaren veta vad modellen arbetar med. 

Genom att lära oss hur vi tillhandahåller verktyg till AI‑modellen kunde vi sedan sätta ihop allt och bygga en AI‑agent som kan använda Grok 4.6 för att lösa verkliga uppgifter som att analysera en aktieportfölj. Slutligen lärde vi oss att uppgifter med långt sammanhang kan bli oerhört dyra, särskilt om vi inte använder caching.

Som en övning för att testa det du lärt dig här föreslår jag att du implementerar caching i agenten och uppdaterar utdata för att även visa resonemangstoken. 

Om du vill fördjupa dina kunskaper i att bygga AI‑agenter med API:er rekommenderar jag vår kurs Working with the OpenAI API. Den bästa platsen för att gå på djupet med AI‑agenter är AI Agent Fundamentals‑spåret.