Grok 3 API: een stapsgewijze gids met voorbeelden

Grok 3 is een redeneergerichte large language model (LLM) ontwikkeld door xAI, ontworpen om complexe logische taken aan te kunnen en problemen op een gestructureerde manier op te lossen.

In deze tutorial laat ik je zien hoe je Grok 3 via de API gebruikt, en lopen we alles door van simpele queries tot meer geavanceerde features zoals function calling en gestructureerde outputs.

Wat is Grok 3?

Grok 3 is xAI’s nieuwste large language model, speciaal gebouwd voor stapsgewijs redeneren, logische consistentie en gestructureerde outputs. In tegenstelling tot typische chatmodellen die de conversatiestroom prioriteren, denkt Grok 3 vóórdat het antwoordt. Dat maakt het ideaal voor taken die diepe logica vereisen, zoals complexe besluitvorming, wiskundig redeneren en kwantitatieve analyse.

Grok 3 is er in twee varianten: het reguliere model en een mini-model. Terwijl het mini-model volledig focust op het redeneeraspect en toegang biedt tot zijn redeneringstraces, wordt het reguliere model gepresenteerd als zijnde sterk in domeinkennis op gebieden als financiën, gezondheidszorg, recht en wetenschap.

Beide modelversies ondersteunen geavanceerde mogelijkheden zoals native function calling en het genereren van gestructureerde antwoorden, waardoor ontwikkelaars eenvoudig betrouwbare en voorspelbare AI-workflows kunnen bouwen.

Wil je meer weten over de architectuur en prestaties van Grok 3? Bekijk dan dit overzicht van Grok 3.

Voorbereiding: toegang krijgen tot de Grok 3 API

In deze sectie leg ik uit hoe je een API-sleutel aanmaakt, een Python-omgeving opzet om met de Grok API te verbinden en je eerste gebruikersverzoek doet.

Een API-sleutel aanmaken

Om de Python-client bij de API te authenticeren, moeten we een API-sleutel aanmaken. Het proces ziet er zo uit:

Ga naar de xAI-documentatiepagina.
Log in met je X-, xAI- of Google-account—of maak een xAI-account aan.
Klik op “Create an API key”, geef hem een naam en klik op “save”.
Kopieer de sleutel zodra deze zichtbaar is. Je kunt hem later niet meer bekijken, maar je kunt altijd een nieuwe aanmaken als je hem kwijtraakt.
Maak een bestand met de naam .env in je projectmap en plak de sleutel in het volgende formaat:

XAI_API_KEY=<your_api_key>Mogelijk gemaakt door

Grok 3 API-prijzen

Hoewel het gebruik van de API vaak wordt geassocieerd met lagere kosten dan een premiumabonnement, is het niet gratis. In plaats van een vast maandabonnement, dat begint bij $30 voor het SuperGrok-abonnement, zijn de kosten volledig afhankelijk van het gebruik. Voor een overzicht van de potentiële kosten kun je xAI's prijspagina bekijken.

De vermelde prijzen zijn per miljoen tokens, wat volgens een vuistregel overeenkomt met ongeveer 750.000 woorden aan input of output in het Engels.

Het mini-model is aanzienlijk goedkoper dan het reguliere model. De snelle versies van zowel Grok 3 als Grok 3 mini gebruiken exact dezelfde onderliggende modellen, maar draaien op snellere infrastructuur, wat leidt tot verbeterde reactietijden.

Om de API te gebruiken, moeten we tegoeden kopen. Het gebruik van prepaid tegoeden in plaats van automatische facturatie wordt in het begin aanbevolen, omdat dit een goede bescherming is tegen onverwachte kosten. Je kunt tokens kopen en een overzicht van je gebruik zien in de xAI-console onder Invoices > Credits.

De Python-omgeving instellen

Nu we een API-sleutel hebben en tegoeden hebben gekocht, is het tijd om de Python-client op te zetten. We moeten twee dependencies installeren om onze API-verzoeken succesvol te laten verlopen:

python-dotenv om de API-sleutel als omgevingsvariabele uit het .env-bestand te laden, en
de openai-client als interface om verzoeken naar Grok 3 te sturen.

Om de omgeving voor ons project op te zetten, raad ik aan Anaconda te gebruiken om mogelijke conflicten tussen verschillende Python-pakketten te vermijden. Na het installeren van Anaconda maken we een omgeving met de naam grok3 met Python 3.10 en activeren we deze met de volgende commando’s in de terminal:

conda create -n grok3 python=3.10
conda activate grok3Mogelijk gemaakt door

Tot slot installeren we de dependencies:

pip install python-dotenv openaiMogelijk gemaakt door

Het eerste gebruikersverzoek versturen

Tijd voor ons eerste script! Eerst importeren we de functies die we gaan gebruiken uit de eerder geïnstalleerde pakketten, plus os om de API-sleutel te lezen.

import os
from dotenv import load_dotenv
from openai import OpenAIMogelijk gemaakt door

De omgevingsvariabele die naar de API-sleutel verwijst, wordt beschikbaar gemaakt door de functie load_dotenv() uit het dotenv-pakket uit te voeren.

# Load environment variables
load_dotenv()Mogelijk gemaakt door

De volgende stap is het initialiseren van de client. We roepen de functie OpenAI aan met onze API-sleutel uit het .env-bestand en de URL van de Grok-server, en wijzen deze toe aan de variabele client.

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

Laten we Grok om advies vragen wat te doen in San Francisco als het regent. We moeten het model en onze messages specificeren en die als argumenten doorgeven aan de functie client.chat.completions.create. Optioneel kunnen we ook parameters aanpassen zoals max_tokens om de lengte van het antwoord te regelen of temperature om de willekeur te beïnvloeden.

# Send a basic reasoning query
response = client.chat.completions.create(
    model="grok-3",
    messages=[
        {"role": "user", "content": "What kind of activity would you suggest, if it rains in San Francisco? Answer in one sentence."}
    ],
    max_tokens=1000,
    temperature=0.2,  # lower temperature for more deterministic answers
)Mogelijk gemaakt door

Om Groks antwoord te printen, moeten we het uit het resulterende object halen. Aangezien we de variabele die het resultaat opslaat response hebben genoemd, staat het antwoord in response.choices[0].message.content.

print(response.choices[0].message.content) # Print the responseMogelijk gemaakt door

If it rains in San Francisco, I suggest visiting indoor attractions like the San Francisco Museum of Modern Art or the California Academy of Sciences for an enriching and dry experience.Mogelijk gemaakt door

Redeneren met Grok 3 Mini

Om Groks redeneerstijl te zien, stellen we een basisvraag die logisch redeneren vereist. We gebruiken Grok 3 Mini voor dit eerste verzoek omdat het in elke API-respons een volledige redeneertrace garandeert, waardoor je stap voor stap het denkproces van het model kunt volgen zonder speciale prompt engineering.

De parameter die bepaalt hoe diep het model nadenkt heet reasoning_effort. Deze is exclusief voor Grok 3 Mini en standaard ingesteld op de snellere optie ”low”. reasoning_effort="high" helpt het model het probleem zorgvuldig stap voor stap door te lopen voordat het het definitieve antwoord geeft, perfect voor taken zoals plannen, beslissen of wiskundig redeneren.

Stel dat we Grok willen gebruiken om te bepalen wat we op een vrije dag doen, afhankelijk van het weer. We kunnen Grok premissen geven die een activiteit definiëren voor zonnige en regenachtige dagen, en een premisse op basis van het actuele weer.

response = client.chat.completions.create(
    model="grok-3-mini-beta",
    reasoning_effort="high",
    messages=[
        {"role": "user", "content": (
            "Premises:\n"
            "- If it is raining, the weather is suitable for indoor activities.\n"
        	"- Visiting a museum is an indoor activity.\n"
        	"- Today, it is raining.\n"
            "Question: What should we do today?"    	
        )}
    ],
    max_tokens=1000,
    temperature=0.2,
)Mogelijk gemaakt door

Om met de redeneertrace te werken, moeten we eerst de API-respons parsen en het attribuut reasoning_content uit het message-object halen. De volgende code laat zien hoe je zowel de gedetailleerde redeneringsstappen als het definitieve antwoord print, vergelijkbaar met hoe ze in een webinterface zouden verschijnen.

# Print the reasoning trace if available
reasoning = getattr(response.choices[0].message, "reasoning_content", None)
 
if reasoning:
    print("Reasoning steps:\n")
    print(reasoning)
else:
    print("No detailed reasoning trace found.")
 
# Print the final answer
print("\nFinal Answer:\n")
print(response.choices[0].message.content)Mogelijk gemaakt door

Het resultaat ziet er zo uit:

Reasoning steps:
First, the premises are:
1. If it is raining, the weather is suitable for indoor activities.
2. Visiting a museum is an indoor activity.
3. Today, it is raining.
The question is: What should we do today?
I need to reason step by step based on the given premises.
From premise 3, today it is raining.
From premise 1, if it is raining, then the weather is suitable for indoor activities. Since it's raining today, the weather is suitable for indoor activities today.  	
From premise 2, visiting a museum is an indoor activity. So, if the weather is suitable for indoor activities, and visiting a museum is an indoor activity, it makes sense that visiting a museum would be a good choice today.
The conclusion should be that we should visit a museum or engage in some indoor activity. But the question is "What should we do today?" and the premises point towards indoor activities, with a specific example given.
Let me chain the logic:
- It is raining (premise 3).
- Therefore, weather is suitable for indoor activities (from premise 1).
- Visiting a museum is an indoor activity (premise 2).
- So, since the weather is suitable for indoor activities, and museum visiting is an indoor activity, it should be suitable to visit a museum.
The premises don't explicitly say that we should do the most suitable activity or anything like that. They just provide conditions and facts.
However, the question implies a recommendation based on the premises. Given that it's raining and indoor activities are suitable, and a museum is mentioned, it's logical to suggest visiting a museum.
I should stick to what's given. The premises don't suggest any other activities or constraints, so based on the information, visiting a museum is a reasonable suggestion.
Final answer should be something like: "We should visit a museum today."
To make it clear, I can phrase it as: "Since it is raining and the weather is suitable for indoor activities, and visiting a museum is an indoor activity, we should visit a museum today."
But since the instruction is to put the final answer in a box, probably a concise statement.
Looking back at the user's message, it's a reasoning exercise, so the answer should be direct.
Final Answer:
Based on the given premises:
- It is raining today (premise 3).
- If it is raining, the weather is suitable for indoor activities (premise 1).   	
- Therefore, the weather is suitable for indoor activities today.
- Visiting a museum is an indoor activity (premise 2).
A suitable activity for today would be an indoor one, such as visiting a museum. 	
**Recommendation:** We should visit a museum today.Mogelijk gemaakt door

Hoewel dit een vrij eenvoudig voorbeeld is, zien we hoe grok-3-mini zorgvuldig elke premisse doorloopt en de logica stap voor stap aaneenrijgt voordat het tot een aanbeveling komt. De redenering is methodisch en transparant, waardoor het eenvoudig is te volgen hoe het model van feiten naar de uiteindelijke suggestie gaat.

Function calling met Grok 3

Een van de functies die Grok 3 interessant maakt, is function calling, waarmee het kan verbinden met externe tools en systemen. Hierdoor kan het model niet alleen tekst genereren, maar ook acties triggeren zoals het ophalen van weersvoorspellingen, het opzoeken van eventschema’s, het analyseren van database-items of zelfs het aansturen van slimme apparaten.

Wanneer we een gebruikersverzoek sturen, kan Grok 3 herkennen dat extra informatie nodig is en een function call aanvragen met specifieke argumenten. De Python-client voert de functie vervolgens lokaal uit, stuurt het resultaat terug naar Grok 3 en ontvangt het definitieve, volledig beredeneerde antwoord.

Bron: xAI

Voorbereiding

We hebben het pakket json nodig om toegang te krijgen tot de argumentstructuur van een functie die door Grok is aangeroepen, dus we moeten het importeren.

import jsonMogelijk gemaakt door

Om function calling uit te proberen, definiëren we een callbackfunctie die wordt aangeroepen wanneer Grok hier in zijn antwoord om vraagt. In ons geval is de functie get_weather_forecast een simpele Python-functie die een hardgecodeerde weersvoorspelling retourneert. Ik heb deze hardgecodeerd voor demonstratiedoeleinden, om de uitleg eenvoudig te houden en niet afhankelijk te zijn van externe services.

# Define the dummy function
def get_weather_forecast(location: str, date: str) -> dict:
    """Simulated function to always return rainy weather."""
    return {
        "location": location,
        "date": “this weekend”, # hardcoded for demo purposes
        "forecast": "rainy"  # hardcoded for demo purposes
    }Mogelijk gemaakt door

We moeten ook de beschikbare tool definiëren door de naam, het doel en de vereiste parameters te specificeren in een JSON-schema, dat we later met ons verzoek naar Grok sturen. Deze setup laat Grok 3 weten dat het deze tool kan aanroepen wanneer het weersinformatie nodig heeft voor zijn redenering.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather_forecast",
            "description": "Get a simulated weather forecast for a given location and date.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city where the activity will take place."
                    },
                    "date": {
                        "type": "string",
                        "description": "The date for which the weather is needed, in YYYY-MM-DD format."
                    }
            	    },
            	    "required": ["location", "date"]
            }
        }
    }
]Mogelijk gemaakt door

Tot slot koppelt de tools_map dictionary de functienamen die Grok 3 gebruikt aan de daadwerkelijke lokale Python-functies, zodat de client de gevraagde tool-calls correct kan uitvoeren.

# Link the function names to the functions
tools_map = {
    "get_weather_forecast": get_weather_forecast
}Mogelijk gemaakt door

Hoewel het handmatig definiëren van toolschema’s prima is voor simpele projecten, wordt het gebruik van een datavalidatiemodule zoals Pydantic steeds waardevoller naarmate projecten groter en complexer worden. Het biedt automatische validatie van functie-inputs, betere foutafhandeling en schonere, beter onderhoudbare code.

Uitvoering

Laten we kijken of Grok onze weersvoorspellingsfunctie gebruikt wanneer we vragen om een activiteitenvoorstel in San Francisco dit weekend. We volgen de structuur van de function-callingworkflow:

Eerst sturen we ons initiële gebruikersverzoek met onze vraag naar Grok samen met de beschikbare tools.
We controleren Groks antwoord op een tool-callverzoek en roepen, indien van toepassing, de bijpassende lokale functie aan met behulp van de tools_map. Als Grok geen tool-call aanvraagt, kunnen we dat afhandelen door het initiële antwoord van het model te retourneren.
Vervolgens voegen we het resultaat toe aan de berichtgeschiedenis; en
sturen we het terug naar Grok om de redenering te voltooien en het definitieve antwoord te genereren.

# Step 1: Send the initial user request
messages = [
    {"role": "user", "content": "What should I do this weekend in San Francisco?"}
]

response = client.chat.completions.create(
    model="grok-3",
    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
        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)  # Grok'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-3",
                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)Mogelijk gemaakt door

De functie is aangevraagd en succesvol uitgevoerd, zoals blijkt uit Groks antwoord:

Thanks for the weather update. Since it's going to be rainy this weekend in San Francisco, I’ll suggest some indoor activities to keep you entertained and dry. Here are a few ideas for your weekend: (...)Mogelijk gemaakt door

Je hebt misschien het argument tool_choice opgemerkt in het initiële gebruikersverzoek, dat verwijst naar de function-callingmodus. Standaard laat de modus "auto" Grok 3 beslissen of en welke functie moet worden aangeroepen op basis van het gesprek. Alternatief kunnen we het gedrag sturen door een functiecall af te dwingen met ”required”, een exacte functie te specificeren, of function calling volledig uit te schakelen met ”none”.

Gestructureerde outputs met Grok 3

Gestructureerde outputs stellen Grok 3 in staat antwoorden terug te geven in een strikt, vooraf gedefinieerd formaat zoals JSON in plaats van vrije tekst. Dit maakt het veel eenvoudiger om modelantwoorden automatisch te parsen, te valideren en te integreren in applicaties of workflows.

Door vooraf een schema te definiëren, zorgen we ervoor dat Groks outputs consistent, machineleesbaar en klaar voor verdere verwerking zijn. Het is daarom erg handig voor use-cases zoals gestructureerde data uit documenten halen of AI-inzichten doorzetten naar downstreamsystemen zoals databases, dashboards of automatiseringspipelines zonder fragiele tekstparsing.

We gebruiken Pydantic om het outputschema te definiëren omdat het een schonere en beter leesbare manier biedt om complexe data te structureren. Zowel BaseModel als Field uit pydantic moeten worden geïmporteerd om deze schemadefinitie correct te laten werken. Omdat onze output een lijst met redeneerstappen bevat, importeren we ook List uit de typing-module van Python om het elementtype preciezer te specificeren.

Hoewel het ook mogelijk is om het schema met plain JSON te definiëren, heb ik tijdens het testen gemerkt dat Grok 3 soms output terugstuurde die niet exact overeenkwam met de verwachte structuur. De geretourneerde JSON was qua betekenis vergelijkbaar, maar volgde een ander schema, wat applicaties kan breken die een specifieke structuur verwachten. Vanwege deze inconsistentie, vooral met geneste elementen zoals lijsten, raad ik sterk aan Pydantic te gebruiken om ervoor te zorgen dat de gestructureerde output betrouwbaar wordt gevalideerd en geparset.

from pydantic import BaseModel, Field
from typing import ListMogelijk gemaakt door

Ons schema, DecisionPlan genaamd, bestaat uit onze initiële situation en een lijst DecisionSteps, die worden gedefinieerd door hun step-nummer, de reasoning erachter en een voorgestelde action.

# Define the schema for the structured output
class DecisionStep(BaseModel):
    step: int = Field(description="Step number in the decision process")
    reasoning: str = Field(description="Reasoning behind this step")
    action: str = Field(description="Suggested action at this step")
 
class DecisionPlan(BaseModel):
    situation: str = Field(description="The initial situation to consider")
    steps: List[DecisionStep] = Field(description="List of reasoning steps leading to the final action")Mogelijk gemaakt door

Er zijn een paar dingen om te overwegen met betrekking tot het verzoek zelf. Allereerst moeten we client.beta.chat.completions.parse() gebruiken in plaats van create(), zodat Grok weet dat we de output in een specifiek formaat willen. Dit is het schema dat we zojuist hebben gedefinieerd, en daarom geven we onze DecisionPlan door als het argument response_format.

Het kan nuttig zijn om alle belangrijke instructies voor een specifieke taak in de system prompt op te nemen, omdat dit Grok 3 helpt de hele conversatie gefocust te blijven op de taak. In combinatie met het apart gedefinieerde schema hoeft de user prompt de vereiste velden in de output-JSON niet te specificeren, maar kan deze zich richten op de taak zelf.

We kunnen bijvoorbeeld het planningsproces voor activiteiten eenvoudig opdelen in drie duidelijk gedefinieerde stappen:

# Send a prompt and request structured output
completion = client.beta.chat.completions.parse(
    model="grok-3",
    messages=[
        {"role": "system", "content": (
        "You are an expert travel planner."
        "When asked about activities, always break down the decision process into exactly 3 logical reasoning steps."
        "Return the output in structured JSON format following the provided schema, without any extra text."
        )},
        {"role": "user", "content": (
        "It's raining today in San Francisco. What indoor activity would you recommend?"
        )}
    ],
    response_format=DecisionPlan,
)Mogelijk gemaakt door

Na het parsen van Grok 3’s gestructureerde output kunnen we op de resultaten acteren door de belangrijkste aanbevelingen samen te vatten, geautomatiseerde workflows te starten of zelfs verder programmatisch beslissingen te nemen.

Laten we voor het eerste voorbeeld gaan en alleen onze situatie en de uiteindelijke aanbeveling van onze reisspecialist, Grok, tonen. Omdat onze output in ons vooraf gedefinieerde JSON-formaat staat, kunnen we de aanbeveling van de laatste stap eenvoudig benaderen:

# Access the parsed result
plan = completion.choices[0].message.parsed
 
# Use the final action to create a summary message
final_step = plan.steps[-1]
 
print(f"\nSummary:")
print(f"Situation: {plan.situation}")
print(f"Recommended Action: {final_step.action}")Mogelijk gemaakt door

Summary:
Situation: It's raining today in San Francisco, and an indoor activity is needed to make the most of the day.
Recommended Action: Visiting the California Academy of Sciences in Golden Gate Park for an educational and entertaining indoor experience.Mogelijk gemaakt door

Alles combineren: een eenvoudige redeneerapp bouwen met Grok 3

We kunnen function calling en gestructureerde outputs combineren om een simpele app te maken die Groks redenering gebruikt. We kunnen de code kopiëren en plakken voor:

Het importeren van alle eerder genoemde pakketten en functies;
Het initialiseren van de client;
Het definiëren van het functieschema, de dummyfunctie en de tools_map; en
Het definiëren van het outputschema.

We beginnen met een API-call met de functie create() om de tool-call te triggeren. Om de gebruiker de vraag in de terminal te laten invoeren, vervangen we onze vraag over de activiteit in San Francisco door input("> ").

Na het toevoegen van het function_result aan de lijst messages komt de twist: in plaats van nog een API-call te doen die create() gebruikt, parsen we en geven we onze DecisionPlan door als de response_format`.

Hier is de volledige code van onze kleine app:

import os
import json
from dotenv import load_dotenv
from openai import OpenAI
from pydantic import BaseModel, Field
from typing import List
 
# Load environment variables
load_dotenv()
 
# Initialize the client
client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
)
 
# 1. Define the function schema (tool definition)
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather_forecast",
            "description": "Get a simulated weather forecast for a given location and date.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city where the activity will take place."
                	},
                    "date": {
                        "type": "string",
                        "description": "The date for which the weather is needed, in YYYY-MM-DD format."
                    }
            	    },
                "required": ["location", "date"]
        	}
        }
    }
]
 
# 2. Dummy weather function (hardcoded)
def get_weather_forecast(location: str, date: str) -> dict:
    return {
        "location": location,
        "date": "this weekend",
        "forecast": "rainy"
    }
 
# 3. Tool mapping
tools_map = {
    "get_weather_forecast": get_weather_forecast
}
 
# 4. Define structured output schema using Pydantic
class DecisionStep(BaseModel):
	step: int = Field(description="Step number in the decision process")
	reasoning: str = Field(description="Reasoning behind this step")
	action: str = Field(description="Suggested action at this step")
 
class DecisionPlan(BaseModel):
	situation: str = Field(description="The initial situation to consider")
	steps: List[DecisionStep] = Field(description="List of reasoning steps leading to the final action")
 
# 5. Defining messages: system prompt and input
messages = [
    {"role": "system", "content": (
        "You are an expert travel planner. When asked about weekend plans, "
        "first get the weather forecast via the tool provided. Then, based on the result, "
        "break down your reasoning into exactly 3 steps and return structured JSON only."
    )},
    {"role": "user", "content": input("> ")} # enter the question in the terminal
]
 
# 6. First API call to trigger the tool call
response = client.chat.completions.create(
    model="grok-3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)
 
tool_calls = getattr(response.choices[0].message, "tool_calls", [])
 
if tool_calls:
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)
        if function_name in tools_map:
            function_result = tools_map[function_name](**function_args)
 
        	# Add the assistant's tool call message and the tool result to the message history
            messages.append(response.choices[0].message)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(function_result)
        	})
 
        	# 7. Second API call with parse() to get structured output
            final_response = client.beta.chat.completions.parse(
                model="grok-3",
                messages=messages,
                response_format=DecisionPlan
        	)
 
        	plan = final_response.choices[0].message.parsed
 
        	# 8. Use the output
            final_action = plan.steps[-1].action
 
            print(f"\nSummary:")
            print(f"Situation: {plan.situation}")
            print(f"Recommended Action: {final_action}")
 
else:
    print("No tool call was requested.")Mogelijk gemaakt door

Uitvoeringsvoorbeeld

Om de app te proberen, gaan we naar onze projectmap, laden we onze omgeving en draaien we het script:

cd <your/working/directory>
conda activate grok3
python app.pyMogelijk gemaakt door

Als we om advies voor Helsinki vragen, antwoordt onze Grok-app:

Dit is een prima suggestie, dat kan ik uit ervaring zeggen!

Conclusie

We hebben veel behandeld—laten we afronden. We verkenden hoe je met de Grok 3 API werkt om simpele queries uit te voeren, redeneertraces te verwerken en geavanceerde features zoals function calling en gestructureerde outputs te gebruiken.

We hebben deze mogelijkheden gecombineerd in een klein project dat liet zien hoe Grok externe tools kan gebruiken en gestructureerde, bruikbare antwoorden kan teruggeven. In combinatie met API’s—in ons geval een weer-API—kunnen krachtige applicaties worden gebouwd die de sterke punten van Grok 3 volledig benutten.

Als je tot hier bent gekomen, ben je waarschijnlijk geïnteresseerd om meer te leren over LLM’s. Bekijk ook gerust deze bronnen:

Onderwerpen

Kunstmatige intelligentie Large Language Models

Onderwerpen

Technologieën

Grok 3 API: een stapsgewijze gids met voorbeelden

Verken met AI

Wat is Grok 3?

Voorbereiding: toegang krijgen tot de Grok 3 API

Een API-sleutel aanmaken

Grok 3 API-prijzen

De Python-omgeving instellen

Het eerste gebruikersverzoek versturen

Redeneren met Grok 3 Mini

Function calling met Grok 3

Voorbereiding

Uitvoering

Gestructureerde outputs met Grok 3

Alles combineren: een eenvoudige redeneerapp bouwen met Grok 3

Uitvoeringsvoorbeeld

Conclusie

Onderwerpen

Leer AI met deze cursussen!

AI-toepassingen ontwikkelen

AI-systemen ontwikkelen met de OpenAI API

AI-beveiliging en risicobeheer

Gerelateerd

AI vanaf nul leren in 2026: een complete gids van de experts

Onderwerpen

Technologieën

Leer AI met deze cursussen!

AI-toepassingen ontwikkelen

AI-systemen ontwikkelen met de OpenAI API

AI-beveiliging en risicobeheer