Guide GPT-4.1 avec projet de démonstration : Application de recherche de code par mot-clé

Récemment, OpenAI a introduit la famille GPT-4.1qui comprend trois variantes : GPT-4.1, GPT-4.1 Mini et GPT-4.1 Nano. Ces modèles sont conçus pour exceller dans les tâches de codage et de suivi des instructions, offrant des avancées significatives par rapport à leurs prédécesseurs. 

L'une de leurs principales caractéristiques est une fenêtre contextuelle élargie qui prend en charge jusqu'à 1 million de jetons, soit plus de huit fois la capacité de la GPT-4. Cette amélioration permet aux modèles de gérer des entrées importantes, telles que des référentiels de code entiers ou des flux de travail multi-documents. 

Dans ce tutoriel, nous allons explorer les capacités de GPT-4.1 en construisant un projet qui permet aux utilisateurs de rechercher un référentiel de code entier en utilisant des mots-clés à partir de leurs invites. Le contenu pertinent du référentiel sera alors fourni au modèle GPT-4.1, avec l'invite de l'utilisateur. 

En conséquence, nous créerons une application interactive qui permettra aux utilisateurs de discuter avec leur dépôt de code et d'utiliser GPT-4.1 pour analyser et améliorer l'ensemble de la source de code.

Nous tenons nos lecteurs informés des dernières nouveautés en matière d'IA en leur envoyant The Median, notre lettre d'information gratuite du vendredi qui analyse les principaux sujets de la semaine. Abonnez-vous et restez à la pointe de la technologie en quelques minutes par semaine :

Pour commencer avec les modèles GPT-4.1

Avant de se lancer dans la construction du projet, il est essentiel de tester les différentes versions des modèles GPT-4.1 et d'explorer la nouvelle API responses. Cette API avancée avancée permet des interactions avec état en utilisant les sorties précédentes comme entrées, prend en charge les entrées multimodales telles que le texte et les images, et étend les capacités du modèle avec des outils intégrés pour la recherche de fichiers, la recherche sur le web et l'intégration de systèmes externes par l'appel de fonctions.

Pour commencer, assurez-vous d'avoir installé la dernière version du client OpenAI Python. Vous pouvez le faire en exécutant la commande suivante dans le terminal :

$ pip install -U openai -q

1. Utilisation du modèle GPT-4.1 Nano pour la génération de textes

Dans cet exemple, nous utiliserons le modèle GPT-4.1 Nano, optimisé pour la vitesse et la rentabilité, pour générer du texte. 

Tout d'abord, nous allons initialiser le client OpenAI et l'utiliser pour accéder à l'API de réponse afin de générer une réponse.

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)

Le modèle GPT-4.1 Nano a fourni une réponse bien formatée et concise.

2. Utilisation du modèle GPT-4.1 Mini pour la compréhension des images

Ensuite, nous testerons le mini-modèle GPT-4.1 en lui fournissant l'URL d'une image et en lui demandant de décrire l'image dans un style philosophique.

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)

Le modèle GPT-4.1 Mini a fourni une description détaillée et créative de l'image, démontrant ainsi sa capacité à interpréter le contenu visuel.

3. Utilisation du modèle GPT-4.1 (Full) pour la génération de codes

Nous allons maintenant utiliser le modèle GPT-4.1 "complet" pour générer du code. 

Dans cet exemple, nous fournirons au modèle des instructions sur le système ainsi qu'une invite à l'intention de l'utilisateur et nous activerons la réponse du flux.

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

Nous avons utilisé la sortie au niveau du système (sys.stdout) pour afficher la réponse en temps réel.

4. Utilisation du modèle GPT-4.1 pour la génération de code à partir de fichiers

Enfin, nous testerons la grande fenêtre contextuelle du modèle GPT-4.1 en lui fournissant un fichier Python en entrée. Le fichier est encodé au format Base64 et envoyé au modèle avec les instructions de l'utilisateur.

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)

Le modèle GPT-4.1 a fourni des suggestions contextuelles pour améliorer le code, démontrant ainsi sa capacité à gérer des entrées importantes.

Si vous rencontrez des problèmes lors de l'exécution du code ci-dessus, veuillez vous référer au classeur DataLab : Jouer avec l'API GPT-4.1 - DataLab.

Création de l'application de recherche de code par mot-clé 

L'application de recherche de code par mot-clé est conçue pour aider les développeurs à rechercher efficacement dans une base de code des extraits pertinents basés sur des mots-clés spécifiques, puis à utiliser GPT-4.1 pour fournir des explications ou des informations sur le code. 

L'application se compose de trois parties principales :

1. Recherche dans la base de données

La première étape de l'application consiste à rechercher dans la base de code les extraits pertinents qui correspondent à la requête du développeur. Pour ce faire, vous pouvez utiliser la fonction search_codebase, qui recherche dans les fichiers d'un répertoire donné les lignes contenant les mots-clés spécifiés.

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. Requête GPT 4.1

Une fois les extraits de code pertinents identifiés, l'étape suivante consiste à interroger GPT-4.1 pour obtenir des explications ou des informations sur le code. La fonction query_gpt prend en entrée la question du développeur et les extraits de code correspondants et renvoie une réponse détaillée.

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. Application de chat pour la recherche de codes par mots-clés

La dernière partie de l'application est le chatbot interactif, qui combine tous les éléments. Il permet aux développeurs de poser des questions sur leur base de code, d'extraire des mots-clés de la requête, de rechercher des extraits pertinents dans la base de code et d'envoyer le tout, avec la question de l'utilisateur, à GPT-4.1 pour la génération de réponses.

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

Ce chatbot offre une expérience transparente aux développeurs, leur permettant d'interagir avec leur base de code et de recevoir des informations alimentées par l'IA. 

Le projet comprend également un dépôt de code (kingabzpro/Keyword-Code-Search) qui contient le code source et des instructions sur la manière de l'utiliser.

Test de l'application de recherche de code par mot-clé

Dans cette section, nous allons tester l'application Keyword Code Search en l'exécutant dans le terminal et en explorant ses fonctionnalités. 

Pour exécuter l'application, vous devez fournir le chemin d'accès au dépôt de code que vous souhaitez analyser. Pour cet exemple, nous utiliserons le "Redis ML project".

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

Vous verrez le message de bienvenue et les instructions. Tapez simplement votre question sur votre code ou demandez-lui d'améliorer une certaine partie de la base de code.

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

L'application recherchera dans la base de code les extraits pertinents et interrogera GPT-4.1 pour générer une réponse. 

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...........

Vous pouvez poser des questions complémentaires pour comprendre l'ensemble du projet.

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

Cette explication détaillée aide les développeurs à comprendre l'objectif, la fonctionnalité et la structure du projet.

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…………

Pour quitter l'application, tapez simplement "quitter" :

Enter your question about the codebase: quit

Exiting chatbot. Goodbye!

L'application de recherche de code par mot-clé est un outil petit mais puissant qui permet aux développeurs de discuter avec leurs dépôts de code. Il combine une recherche de code efficace basée sur des mots-clés avec la capacité de GPT-4.1 à générer des réponses tenant compte du contexte. Que vous ayez besoin d'améliorer une partie spécifique de votre base de code ou de comprendre l'ensemble du projet, cette application offre une expérience transparente et intuitive.

Réflexions finales

L'ensemble du paysage de l'IA s'éloigne du battage médiatique et des références superficielles, pour se concentrer sur la fourniture d'une valeur réelle plutôt que sur de simples illusions. Les modèles GPT4.1 améliorent l'expérience des développeurs en permettant à de grands modèles linguistiques de générer un code très précis et exécutable dès sa sortie de l'emballage. En outre, ces modèles sont dotés de grandes fenêtres contextuelles, ce qui leur permet de comprendre l'ensemble du référentiel de code en une seule fois. 

Si vous souhaitez vous familiariser avec l'API OpenAI, consultez notre cours, Travailler avec l'API OpenAI pour commencer à développer des applications basées sur l'IA. Vous pouvez également consulter notre tutoriel sur l'API API Réponses et en savoir plus sur la nouvelle interface o4-mini et sur le nouveau modèle de raisonnement o4-mini.