GPT-4.1-gids met demoproject: applicatie voor zoekwoorden in code

Onlangs heeft OpenAI de GPT-4.1-familie geïntroduceerd, bestaande uit drie varianten: GPT-4.1, GPT-4.1 Mini en GPT-4.1 Nano. Deze modellen zijn ontworpen om uit te blinken in codeer- en instructietaken en bieden aanzienlijke verbeteringen ten opzichte van hun voorgangers. 

Een van de opvallendste kenmerken is een uitgebreidere contextvenster dat tot 1 miljoen tokens ondersteunt—meer dan acht keer de capaciteit van GPT-4. Dankzij deze verbetering kunnen de modellen omvangrijke input verwerken, zoals volledige coderepositories of workflows met meerdere documenten. 

In deze tutorial verkennen we de mogelijkheden van GPT-4.1 door een project te bouwen waarmee gebruikers een volledige coderepository kunnen doorzoeken op basis van zoekwoorden uit hun prompts. De relevante inhoud uit de repository wordt vervolgens samen met de prompt van de gebruiker aan het GPT-4.1-model verstrekt. 

Het resultaat is een interactieve applicatie waarmee gebruikers met hun coderepository kunnen chatten en GPT-4.1 kunnen gebruiken om de volledige broncode te analyseren en te verbeteren.

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

Aan de slag met GPT-4.1-modellen

Voordat we het project gaan bouwen, is het belangrijk om eerst de verschillende versies van GPT-4.1 te testen en de nieuwe responses-API te verkennen. Deze geavanceerde API maakt stateful interacties mogelijk door eerdere outputs als input te gebruiken, ondersteunt multimodale input zoals tekst en afbeeldingen, en breidt de mogelijkheden van het model uit met ingebouwde tools voor bestandszoekopdrachten, webzoekopdrachten en integratie met externe systemen via function calling.

Zorg er om te beginnen voor dat je de nieuwste versie van de OpenAI Python-client hebt geïnstalleerd. Dat kan met de volgende opdracht in de terminal:

$ pip install -U openai -q

1. De GPT-4.1 Nano-modus gebruiken voor tekstgeneratie

In dit voorbeeld gebruiken we het GPT-4.1 Nano-model, geoptimaliseerd voor snelheid en kosten, om tekst te genereren. 

Eerst initialiseren we de OpenAI-client en gebruiken die om via de responses-API een antwoord te genereren.

from openai import OpenAI
from IPython.display import Markdown, display

client = OpenAI()

response = client.responses.create(
    model="gpt-4.1-nano",
    input= "Write a proper blog on getting rich."
)

Markdown(response.output_text)

Het GPT-4.1 Nano-model gaf een goed opgemaakt en beknopt antwoord.

2. Het GPT-4.1 Mini-model gebruiken voor beeldbegrip

Vervolgens testen we het GPT-4.1 Mini-model door een afbeeldings-URL te geven en te vragen de afbeelding in een filosofische stijl te beschrijven.

response = client.responses.create(
    model="gpt-4.1-mini",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": "Please describe the image as a philosopher would."},
            {
                "type": "input_image",
                "image_url": "https://thumbs.dreamstime.com/b/lucha-de-dos-vacas-56529466.jpg",
            },
        ],
    }],
)

print(response.output_text)

Het GPT-4.1 Mini-model gaf een gedetailleerde en creatieve beschrijving van de afbeelding en liet zien dat het visuele inhoud kan interpreteren.

3. Het GPT-4.1 (volledige) model gebruiken voor codegeneratie

Nu gebruiken we het “volledige” GPT-4.1-model om code te genereren. 

In dit voorbeeld geven we het model systeeminstructies en een gebruikersprompt mee en schakelen we streamen van de respons in.

import sys

# Request a streamed response from the model.
stream = client.responses.create(
    model="gpt-4.1",
    instructions="You are a machine learning engineer, which is an expert in creating model inference.",
    input="Create a FastAPI app for image classification",
    stream=True,
)

# Iterate over stream events and print text as soon as it's received.
for event in stream:
    # Check if the event includes a text delta.
    if hasattr(event, "delta") and event.delta:
        sys.stdout.write(event.delta)
        sys.stdout.flush()

We hebben systeemoutput (sys.stdout) gebruikt om de streamingrespons realtime weer te geven.

4. Het GPT-4.1-model gebruiken voor codegeneratie met bestandsinput

Tot slot testen we het grote contextvenster van het GPT-4.1-model door een Python-bestand als input te geven. Het bestand wordt in Base64 gecodeerd en samen met gebruikersinstructies naar het model verzonden.

import base64
from openai import OpenAI
client = OpenAI()

with open("main.py", "rb") as f:
    data = f.read()

base64_string = base64.b64encode(data).decode("utf-8")

response = client.responses.create(
    model="gpt-4.1",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "filename": "main.py",
                    "file_data": f"data:text/x-python;base64,{base64_string}",
                },
                {
                    "type": "input_text",
                    "text": "Enhance the code by incorporating additional features to improve the user experience.",
                },
            ],
        },
    ]
)

Markdown(response.output_text)

Het GPT-4.1-model gaf contextbewuste suggesties om de code te verbeteren en liet zien dat het met grote input overweg kan.

Als je problemen ondervindt bij het uitvoeren van bovenstaande code, raadpleeg dan de DataLab-workbook: Spelen met de GPT-4.1 API — DataLab.

De applicatie voor zoeken op zoekwoorden in code bouwen 

De Keyword Code Search-applicatie helpt ontwikkelaars efficiënt een codebase te doorzoeken op relevante fragmenten op basis van specifieke zoekwoorden en vervolgens GPT-4.1 te gebruiken om uitleg of inzichten over de code te geven. 

De applicatie bestaat uit drie hoofdonderdelen:

1. Codebase doorzoeken

De eerste stap is het doorzoeken van de codebase naar relevante fragmenten die overeenkomen met de vraag van de ontwikkelaar. Dit gebeurt met de functie search_codebase, die bestanden in een opgegeven map scant op regels met de opgegeven zoekwoorden.

searcher.py:

import os

def search_codebase(directory: str, keywords: list, allowed_extensions: list) -> list:
    """
    Search for code snippets in the codebase that match any of the given keywords.
    Returns a list of dictionaries with file path, the line number where a match was found,
    and a code snippet that includes 2 lines of context before and after the matched line.
    """
    matches = []

    for root, _, files in os.walk(directory):
        for file in files:
            if file.endswith(tuple(allowed_extensions)):
                file_path = os.path.join(root, file)
                try:
                    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
                        lines = f.readlines()
                    for i, line in enumerate(lines):
                        # Check if any keyword is in the current line (case insensitive)
                        if any(keyword in line.lower() for keyword in keywords):
                            snippet = {
                                "file": file_path,
                                "line_number": i + 1,
                                "code": "".join(lines[max(0, i - 2) : i + 3]),
                            }
                            matches.append(snippet)
                except Exception as e:
                    print(f"Skipping file {file_path}: {e}")
    return matches

2. GPT 4.1-query

Zodra relevante codefragmenten zijn gevonden, is de volgende stap GPT-4.1 raadplegen om uitleg of inzichten over de code te genereren. De functie query_gpt neemt de vraag van de ontwikkelaar en de overeenkomende codefragmenten als input en retourneert een gedetailleerd antwoord.

gpt_explainer.py:

import os

from openai import OpenAI


def query_gpt(question: str, matches: list):
    """
    Queries GPT-4.1 with the developer's question and the relevant code snippets,
    then returns the generated explanation.
    """
    if not matches:
        return "No code snippets found to generate an explanation."

    # Combine all matches into a formatted string
    code_context = "\n\n".join(
        [
            f"File: {match['file']} (Line {match['line_number']}):\n{match['code']}"
            for match in matches
        ]
    )

    # Create the GPT-4.1 prompt
    system_message = "You are a helpful coding assistant that explains code based on provided snippets."
    user_message = f"""A developer asked the following question:
                    "{question}"
                    Here are the relevant code snippets:
                    {code_context}
                    Based on the code snippets, answer the question clearly and concisely.
                    """

    # Load API key from environment variable
    api_key = os.environ.get("OPENAI_API_KEY")
    if not api_key:
        return "Error: OPENAI_API_KEY environment variable is not set."

    # Create an OpenAI client using the API key
    client = OpenAI(api_key=api_key)

    try:
        # Return the stream object for the caller to process
        return client.responses.create(
            model="gpt-4.1",
            input=[
                {"role": "system", "content": system_message},
                {"role": "user", "content": user_message},
            ],
            stream=True,
        )

    except Exception as e:
        return f"Error generating explanation: {e}"

3. Chatapplicatie voor zoeken op zoekwoorden in code

Het laatste onderdeel is de interactieve chatbot, die alles combineert. Hiermee kunnen ontwikkelaars vragen stellen over hun codebase, zoekwoorden uit de vraag halen, de codebase doorzoeken op relevante fragmenten en alles samen met de vraag van de gebruiker naar GPT-4.1 sturen om een antwoord te genereren.

main.py:

import argparse

from gpt_explainer import query_gpt
from searcher import search_codebase


def print_streaming_response(stream):
    """Print the streaming response from GPT-4.1"""
    print("\nGPT-4.1 Response:")
    for event in stream:
        # Check if the event includes a text delta.
        if hasattr(event, "delta") and event.delta:
            print(event.delta, end="")
    print("\n")


def main():
    parser = argparse.ArgumentParser(
        description="Keyword-Based Code Search with GPT-4.1"
    )
    parser.add_argument("--path", required=True, help="Path to the codebase")
    args = parser.parse_args()

    allowed_extensions = [".py", ".js", ".txt", ".md", ".html", ".css", ".sh"]

    print("Welcome to the Code Search Chatbot!")
    print("Ask questions about your codebase or type 'quit' to exit.")

    while True:
        question = input("\nEnter your question about the codebase: ")

        if question.lower() == "quit":
            print("Exiting chatbot. Goodbye!")
            break

        # Extract keywords from the question and remove stop words
        stop_words = {'a', 'an', 'the', 'and', 'or', 'but', 'is', 'are', 'was', 'were',
                     'in', 'on', 'at', 'to', 'for', 'with', 'by', 'about', 'like',
                     'from', 'of', 'as', 'how', 'what', 'when', 'where', 'why', 'who'}
        keywords = [word for word in question.lower().split() if word not in stop_words][:5]

        print("Searching codebase...")
        matches = search_codebase(args.path, keywords, allowed_extensions)

        if not matches:
            print("No relevant code snippets found.")
            continue

        print("Querying GPT-4.1...")
        stream = query_gpt(question, matches)
        print_streaming_response(stream)


if __name__ == "__main__":
    main()

Deze chatbot biedt een soepele ervaring voor ontwikkelaars, zodat ze met hun codebase kunnen communiceren en AI-gestuurde inzichten krijgen. 

Het project bevat ook een coderepository (kingabzpro/Keyword-Code-Search) met broncode en instructies voor gebruik. 

De applicatie voor zoeken op zoekwoorden in code testen

In dit deel testen we de Keyword Code Search-app door die in de terminal uit te voeren en de functies te verkennen. 

Om de app uit te voeren, geef je het pad op naar de coderepository die je wilt analyseren. In dit voorbeeld gebruiken we het “Redis ML-project”.

$ python main.py --path C:\Repository\GitHub\Redis-ml-project  

Je ziet het welkomstbericht en de instructies. Typ gewoon je vraag over je code of vraag om een bepaald deel van de codebase te verbeteren.

Welcome to the Code Search Chatbot!
Ask questions about your codebase or type 'quit' to exit.

Enter your question about the codebase: help me improve the training script

De applicatie doorzoekt de codebase naar relevante fragmenten en raadpleegt GPT-4.1 om een antwoord te genereren. 

Searching codebase...
Querying GPT-4.1...

GPT-4.1 Response:
Certainly! Based on the provided snippets, here's how you can **improve the training script (`train.py`)** for your phishing email classification proje...........

Je kunt vervolgvragen stellen om het hele project te begrijpen.

Enter your question about the codebase: help me understand the project

Deze uitgebreide uitleg helpt ontwikkelaars het doel, de functionaliteit en de structuur van het project te begrijpen.

Searching codebase...
Querying GPT-4.1...

GPT-4.1 Response:
Certainly! Here's a concise overview of the project based on your code snippets:

## Project Purpose

**Phishing Email Classification App with Redis**  
This project classifies emails as "Phishing" or "Safe" using machine learning and serves predictions via a web API. It also uses Redis for caching predictions to optimize performance…………

Om de applicatie af te sluiten, typ je gewoon ‘quit’:

Enter your question about the codebase: quit

Exiting chatbot. Goodbye!

De Keyword Code Search-applicatie is klein maar krachtig en laat ontwikkelaars met hun coderepositories chatten. Ze combineert efficiënt zoeken op zoekwoorden met GPT-4.1’s vermogen om contextbewuste antwoorden te genereren. Of je nu een specifiek deel van je codebase wilt verbeteren of het hele project wilt begrijpen, deze applicatie biedt een naadloze en intuïtieve ervaring.

Tot slot

Het volledige AI-landschap beweegt weg van hype en oppervlakkige benchmarks, met de focus op het leveren van echte waarde in plaats van schijn. De GPT4.1-modellen verbeteren de ontwikkelaarservaring door grote taalmodellen in staat te stellen direct zeer nauwkeurige, uitvoerbare code te genereren. Daarnaast hebben deze modellen grote contextvensters, waardoor ze in één keer de volledige coderepository kunnen begrijpen. 

Wil je praktisch aan de slag met de OpenAI API? Bekijk dan onze cursus Working with the OpenAI API om te beginnen met het ontwikkelen van AI‑apps. Bekijk ook onze tutorial over de Responses API en lees meer over het nieuwe o4-mini-redeneermodel.