OpenAI's O3 API: Stapsgewijze tutorial met voorbeelden

OpenAI's o3-model kan complexe meerstapsproblemen oplossen, visuele en tekstuele input combineren en tools zoals Python, zoeken of beeldinspectie gebruiken om antwoorden te verbeteren.

In deze tutorial leg ik stap voor stap uit hoe je o3 via de API gebruikt, wat o3 anders maakt dan generalistische modellen zoals GPT-4o, en hoe je redeneerkosten effectief beheert.

We houden onze lezers op de hoogte van het laatste AI-nieuws met The Median, onze gratis vrijdagse nieuwsbrief die de belangrijkste verhalen van de week samenvat. Abonneer je en blijf scherp in een paar minuten per week:

Wanneer moet je O3 gebruiken?

OpenAI’s o3-model is ontworpen voor geavanceerde, complexe taken die diepgaande redenering en autonomie vereisen. Het is bijzonder effectief voor ingewikkelde probleemoplossing in domeinen zoals softwareontwikkeling, wiskunde, wetenschappelijk onderzoek en visuele datainterpretatie.

Dankzij de agent-achtige mogelijkheden kan het model autonoom tools gebruiken zoals websearch, Python en beeldgeneratie, waardoor het ideaal is voor taken die meerstapsanalyse en dynamische besluitvorming vereisen.

Overweeg het o3-model via de API te gebruiken wanneer je projecten complexe, multimodale redeneertaken omvatten die profiteren van de hoge autonomie en geavanceerde analytische vaardigheden.

Laten we snel o3, o4-mini en GPT-4o vergelijken:

Bron: OpenAI

Prijsstelling is ook een belangrijke factor om mee te nemen wanneer je de API gebruikt:

Bron: OpenAI

OpenAI O3 API: Zo koppel je met de API van OpenAI

Voordat je de geavanceerde redeneercapaciteiten van o3 kunt gebruiken, moet je toegang tot de OpenAI API instellen. In deze sectie laat ik je zien:

• Je API-sleutel veilig instellen
• Je eerste API-aanroep naar het o3-model doen
• Belangrijke setup-verschillen voor redeneermodellen uitlichten

Stap 1: API-referenties verkrijgen

Om toegang te krijgen tot de OpenAI API heb je een geldige API-sleutel nodig, die je kunt verkrijgen via de OpenAI API Keys-pagina, en zorg dat je facturatie is ingeschakeld.

Let op: Om o3 te gebruiken, moet je eerst je OpenAI-organisatie verifiëren hier. Het kan tot 15 minuten duren voordat de verificatie actief is.

Stap 2: Importeer de openai-bibliotheek

We beginnen met het installeren en updaten van de openai-bibliotheek om via de API toegang te krijgen tot het O3-model. Voer de volgende opdracht uit:

pip install --upgrade openaiMogelijk gemaakt door

Na installatie importeren we de OpenAI-klasse uit de openai-bibliotheek:

from openai import OpenAIMogelijk gemaakt door

Stap 3: Initialiseer het clientobject

Om met de API van OpenAI te communiceren, authenticeren we door onze geheime API-sleutel in te stellen, zodat we geautoriseerde aanvragen kunnen doen naar modellen zoals o3.

client = OpenAI(api_key=YOUR_API_KEY)Mogelijk gemaakt door

Stap 4: Doe een API-aanroep

Nu de setup klaar is, doen we onze eerste API-aanroep naar o3 en kijken we hoe het een eenvoudige meerstaps redeneertaak afhandelt via de Responses API.

Voorbeeld 1: Eenvoudige prompt zonder tools

Laten we de o3 API-aanroep begrijpen met een eenvoudig promptvoorbeeld.

response = client.responses.create(
    model="o3",
    input=[{"role": "user", "content": "What’s the difference between inductive and deductive reasoning?"}]
)
print(response.output_text)Mogelijk gemaakt door

Dit voorbeeld stuurt een vraag in natuurlijke taal rechtstreeks naar het o3-model zonder tools of speciale redeneerparameters te gebruiken.

• model="o3" vertelt de API dat het o3-redeneermodel gebruikt moet worden.
• input=[{"role": "user", "content": "..."}] definieert één bericht van de gebruiker met een conceptuele vraag.
• O3 gebruikt intern standaard een redeneringsketen met gemiddelde inspanning voordat het de uiteindelijke output produceert.

Dit zijn de tokens die meetellen voor onze uiteindelijke kosten:

• Inputtokens: de prompt
• Redeneertokens: de interne chain-of-thought van o3
• Outputtokens: uiteindelijke output

Voorbeeld 2: Code en wiskundige probleemoplossing

In dit voorbeeld vragen we o3 om zowel te coderen als de wiskunde achter het oplossen van kwadratische vergelijkingen uit te leggen. Dit is een tweedelige taak, die niet alleen code vereist maar ook een gedetailleerde wiskundige uitleg.

prompt = "Write a Python function that solves quadratic equations and also explain the math behind it."
response = client.responses.create(
    model="o3",
    reasoning={"effort": "high"},
    input=[{"role": "user", "content": prompt}]
)
print(response.output_text)Mogelijk gemaakt door

Deze taak vereist meerstaps wiskundig redeneren: eerst de kwadratische formule oplossen en vervolgens de afleiding uitleggen. De parameter reasoning={"effort": "high"} dwingt o3 om "harder na te denken" en een grotere redeneertrace te genereren. Dit is ideaal voor taken die technische diepgang of oplossingen in meerdere stappen vragen.

Kostenopmerking: Meer redeneerinspanning betekent meer redeneertokens, wat resulteert in hogere outputkosten.

Voorbeeld 3: Coderefactoring

In dit voorbeeld geven we O3 een coderefactoringtaak mee, samen met een reeks instructies.

prompt = """
Instructions:
- Given the React component below, change it so that nonfiction books have red
  text. 
- Return only the code in your reply
- Do not include any additional formatting, such as markdown code blocks
- For formatting, use four space tabs, and do not allow any lines of code to 
  exceed 80 columns
const books = [
  { title: 'Dune', category: 'fiction', id: 1 },
  { title: 'Frankenstein', category: 'fiction', id: 2 },
  { title: 'Moneyball', category: 'nonfiction', id: 3 },
];
export default function BookList() {
  const listItems = books.map(book =>
    <li>
      {book.title}
    </li>
  );
  return (
    <ul>{listItems}</ul>
  );
}
"""
response = client.responses.create(
    model="o3",
    reasoning={"effort": "medium", "summary": "detailed"},
    input=[
        {
            "role": "user",
            "content": prompt,
        }
    ]
)
print(response.output_text)Mogelijk gemaakt door

In de bovenstaande code geven we O3 een sterk gestructureerde codebewerkingsopdracht met gedetailleerde formatteringsregels.

• De parameter reasoning={"effort": "medium"} geeft aan dat het zorgvuldig maar efficiënt moet redeneren.
• De parameter summary="detailed" vraagt om een volledige interne samenvatting van het denkproces. O3 redeneert intern en kan optioneel een samengevatte trace teruggeven als je later het summary-veld inspecteert.

Tip: Er zijn een paar beschikbare samenvattingsinstellingen die je kunt gebruiken, zoals "concise", "detailed" of "auto".

Voorbeeld 4: Visueel redeneren

Laten we deze conferentiefoto gebruiken en o3 vragen om een schema te maken op basis van onze interesses.

Stap 4.1: Helperfunctie

Laten we beginnen met het importeren van de benodigde bibliotheken en het schrijven van een helperfunctie:

import base64, mimetypes, pathlib
def to_data_url(path: str) -> str:
    mime = mimetypes.guess_type(path)[0] or "application/octet-stream"
    data = pathlib.Path(path).read_bytes()
    b64  = base64.b64encode(data).decode()
    return f"data:{mime};base64,{b64}"Mogelijk gemaakt door

De functie to_data_url() zet het lokale afbeeldingsbestand om naar een base64-gecodeerde data-URL, omdat de API van OpenAI afbeeldingsinput als URL verwacht in plaats van als ruwe bestanden.

De functie to_data_url doet het volgende:

• Leest het afbeeldingsbestand (pad) van je computer.
• Leidt het type af (bijv. image/png).
• Codeert vervolgens de binaire inhoud naar een base64-tekenreeks.
• Geeft tenslotte een data-URL terug

Stap 4.2: Verstuur zowel tekst als afbeelding naar O3

Nu we onze afbeelding hebben gecodeerd, geven we zowel de tekst als de gecodeerde afbeeldingsinformatie door aan O3.

prompt = (
    "Create a schedule using this blurry conference photo. "
    "Ensure 10-minute gaps between talks and include all talks related to LLMs."
)
image_path   = "IMAGE_PATH"
image_url    = to_data_url(image_path)        
response = client.chat.completions.create(
    model="o3",                                  
    messages=[
        {
            "role": "user",
            "content": [
                { "type": "text",      "text": prompt },
                { "type": "image_url", "image_url": { "url": image_url } }
            ],
        }
    ],
)
print(response.choices[0].message.content)Mogelijk gemaakt door

Zo werkt het:

• We beginnen met client.chat.completions.create(), waarbij de inputinhoud een lijst is die zowel bevat:
• de tekstinstructie (het planningsverzoek van de gebruiker),
• en de afbeeldingsdata (de conferentiefoto).
• Het o3-model verwerkt beide inputs gezamenlijk tijdens zijn interne denkketen.
• Tot slot printen we response.choices[0].message.content, met het gegenereerde schema dat het model maakte na te redeneren over de tekstinstructies en de visuele data.

Belangrijke kostenoverwegingen:

• Afbeeldingsinput telt als inputtokens.
• Het model gebruikt visuele inspectie binnen de redeneerloop.
• Als de redeneringsketen lang is, moeten we de kosten zorgvuldig beheren met de parameter max_completion_tokens, die we in de volgende sectie behandelen.

Laten we het resultaat bekijken:

Kosten beheren met redeneertokens

O3 gebruikt redeneertokens naast gewone input/outputtokens, wat betekent meer tokens dan reguliere input/output en dus hogere outputkosten. Op basis van ons vorige voorbeeld bekijken we hoe redeneertokens de kosten beïnvloeden.

print(response.usage)Mogelijk gemaakt door

CompletionUsage(completion_tokens=3029,prompt_tokens=1007, total_tokens=4036, completion_tokens_details=CompletionTokensDetails(accepted_prediction_tokens=0, audio_tokens=0, reasoning_tokens=2112, rejected_prediction_tokens=0), prompt_tokens_details=PromptTokensDetails(audio_tokens=0, cached_tokens=0))Mogelijk gemaakt door

Als je de kosten wilt beheersen, gebruik dan de parameter max_completion_tokens om het totale gebruik te begrenzen:

limit_token_response = client.chat.completions.create(
    model="o3",                                  
    messages=[
        {
            "role": "user",
            "content": [
                { "type": "text",      "text": prompt },
                { "type": "image_url", "image_url": { "url": image_url } }
            ],
        }
    ],
    max_completion_tokens=3000,
)
print(limit_token_response.usage)Mogelijk gemaakt door

CompletionUsage(completion_tokens=2746, prompt_tokens=1007, total_tokens=3753, completion_tokens_details=CompletionTokensDetails(accepted_prediction_tokens=0, audio_tokens=0, reasoning_tokens=2112, rejected_prediction_tokens=0), prompt_tokens_details=PromptTokensDetails(audio_tokens=0, cached_tokens=0))Mogelijk gemaakt door

Uit de bovenstaande output zien we dat het instellen van een max_completion_tokens-waarde cruciaal is om het gedrag van het model te sturen. Door het maximale aantal te genereren tokens te begrenzen, voorkomen we dat o3 onnodig lange outputs produceert of buitensporig veel redeneertokens verbruikt, wat helpt om de totale API-kosten te optimaliseren. Dit is vooral belangrijk bij complexe taken waarbij interne redenering anders het tokengebruik zou kunnen domineren zonder evenredige, voor de gebruiker zichtbare output op te leveren.

Belangrijk: Gebruik bij complexe visuele taken met o3 altijd een conservatief hoge max_completion_tokens. Als de tokenlimiet te laag is, kan het model alle tokens intern verbruiken en geen zichtbare output retourneren.

Beste promptpraktijken met O3

Het O3-model gedraagt zich anders dan generalistische modellen zoals GPT-4o of Claude 3.5 Sonnet, omdat o3 intern diepgaande chain-of-thought-redenering toepast. Het presteert het best met heldere, doelgerichte prompts; te veel stappen voorschrijven kan de prestaties schaden.

Hier zijn enkele best practices die OpenAI aanbeveelt voor prompts met o3:

• Houd prompts beknopt en duidelijk: O3 gedijt bij directe instructies zonder uitgebreide uitleg.
• Vermijd chain-of-thought-prompts: Je hoeft O3 niet te vertellen om "stap voor stap" te denken—het redeneert intern.
• Gebruik delimiters voor duidelijkheid: Gebruik triple quotes, XML-tags of andere scheidingstekens om verschillende delen van de input te ordenen.
• Beperk extra context: Als je retrieval-augmented generation (RAG) gebruikt, neem dan alleen de meest relevante informatie op om het model niet te overladen.

Conclusie

In deze blog leerden we hoe je verbinding maakt met OpenAI’s O3-model via de API, redeneerkosten beheert en effectieve prompts opstelt met best practices. Als je project geavanceerde redeneercapaciteiten vereist, zoals meerstaps wiskunde, coderefactoring of visueel begrip, dan is O3 de beste keuze.

Wil je meer leren over het werken met de API’s? Dan raad ik deze blogs aan:

• O4-Mini API: Stapsgewijze tutorial met demoproject
• Grok 3 API: Een stapsgewijze gids met voorbeelden
• GPT-Image-1 API: Een stapsgewijze gids met voorbeelden
• DeepSeek API: Een gids met voorbeelden en kostencalculaties