GPT-4.1 Leitfaden mit Demo-Projekt: Schlüsselwort-Code-Suchanwendung

Vor kurzem hat OpenAI die GPT-4.1-Familie eingeführteingeführt, die drei Varianten umfasst: GPT-4.1, GPT-4.1 Mini und GPT-4.1 Nano. Diese Modelle sind so konstruiert, dass sie bei der Codierung und beim Befolgen von Anweisungen hervorragende Leistungen erbringen und deutliche Fortschritte gegenüber ihren Vorgängern bieten. 

Eines ihrer herausragenden Merkmale ist ein erweitertes Kontextfenster, das bis zu 1 Million Token unterstützt - mehr als das Achtfache der Kapazität von GPT-4. Dank dieser Verbesserung können die Modelle mit umfangreichen Eingaben umgehen, z. B. mit ganzen Code-Repositories oder Workflows mit mehreren Dokumenten. 

In diesem Tutorial werden wir die Möglichkeiten von GPT-4.1 erkunden, indem wir ein Projekt erstellen, das es den Nutzern ermöglicht, ein ganzes Code-Repository anhand von Schlüsselwörtern aus ihren Eingabeaufforderungen zu durchsuchen. Die relevanten Inhalte aus dem Repository werden dann zusammen mit der Eingabeaufforderung des Nutzers dem GPT-4.1-Modell zur Verfügung gestellt. 

Als Ergebnis werden wir eine interaktive Anwendung erstellen, die es den Nutzern ermöglicht, mit ihrem Code-Repository zu chatten und GPT-4.1 zu verwenden, um den gesamten Code-Quellcode zu analysieren und zu verbessern.

Wir halten unsere Leserinnen und Leser mit The Median auf dem Laufenden, unserem kostenlosen Freitags-Newsletter, der die wichtigsten Meldungen der Woche aufschlüsselt. Melde dich an und bleibe in nur ein paar Minuten pro Woche auf dem Laufenden:

Erste Schritte mit GPT-4.1-Modellen

Bevor du mit dem Aufbau des Projekts beginnst, solltest du unbedingt die verschiedenen Versionen der GPT-4.1-Modelle testen und die neue responses API erkunden. Diese erweiterte API ermöglicht zustandsabhängige Interaktionen, indem sie frühere Ausgaben als Eingaben verwendet, unterstützt multimodale Eingaben wie Text und Bilder und erweitert die Möglichkeiten des Modells durch integrierte Tools für die Datei- und Websuche sowie die Integration externer Systeme durch Funktionsaufrufe.

Stelle zunächst sicher, dass du die neueste Version des OpenAI Python Clients installiert hast. Du kannst dies tun, indem du den folgenden Befehl im Terminal ausführst:

$ pip install -U openai -q

1. Verwendung des GPT-4.1 Nano Modells für die Texterstellung

In diesem Beispiel verwenden wir das Modell GPT-4.1 Nano, das für Geschwindigkeit und Kosteneffizienz optimiert ist, um Text zu erzeugen. 

Zuerst werden wir den OpenAI-Client initialisieren und mit ihm auf die Antwort-API zugreifen, um eine Antwort zu erzeugen.

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)

Das Modell GPT-4.1 Nano lieferte eine gut formatierte und prägnante Antwort.

2. Das GPT-4.1 Mini-Modell für das Bildverständnis nutzen

Als Nächstes werden wir das GPT-4.1 Mini-Modell testen, indem wir ihm eine Bild-URL geben und es bitten, das Bild in einem philosophischen Stil zu beschreiben.

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)

Das Modell GPT-4.1 Mini lieferte eine detaillierte und kreative Beschreibung des Bildes und stellte damit seine Fähigkeit unter Beweis, visuelle Inhalte zu interpretieren.

3. Verwendung des GPT-4.1 (Full) Modells für die Codegenerierung

Jetzt werden wir das "vollständige" GPT-4.1-Modell verwenden, um Code zu erzeugen. 

In diesem Beispiel werden wir das Modell mit Systemanweisungen und einer Benutzeraufforderung versehen und die Stream-Antwort aktivieren.

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

Wir haben die Ausgabe auf Systemebene (sys.stdout) verwendet, um die Streaming-Antwort in Echtzeit anzuzeigen.

4. Verwendung des GPT-4.1-Modells für die Codegenerierung mit Dateieingaben

Zum Schluss testen wir das große Kontextfenster des GPT-4.1-Modells, indem wir ihm eine Python-Datei als Eingabe geben. Die Datei wird im Base64-Format kodiert und zusammen mit den Benutzeranweisungen an das Modell gesendet.

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)

Das GPT-4.1-Modell lieferte kontextbezogene Vorschläge zur Verbesserung des Codes und zeigte, dass es mit großen Eingaben umgehen kann.

Wenn du bei der Ausführung des obigen Codes auf Probleme stößt, sieh bitte in der DataLab-Arbeitsmappe nach: Spielen mit der GPT-4.1 API - DataLab.

Aufbau der Anwendung zur Suche nach Schlüsselwörtern 

Die Keyword Code Search Application wurde entwickelt, um Entwicklern zu helfen, eine Codebasis effizient nach relevanten Snippets zu durchsuchen, die auf bestimmten Schlüsselwörtern basieren, und dann GPT-4.1 zu nutzen, um Erklärungen oder Einblicke in den Code zu geben. 

Die Anwendung besteht aus drei großen Teilen:

1. Codebase durchsuchen

Der erste Schritt der Anwendung besteht darin, die Codebasis nach relevanten Snippets zu durchsuchen, die der Anfrage des Entwicklers entsprechen. Dies wird mit der Funktion search_codebase erreicht, die Dateien in einem bestimmten Verzeichnis nach Zeilen durchsucht, die die angegebenen Schlüsselwörter enthalten.

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 Abfrage

Sobald relevante Codeschnipsel identifiziert sind, wird im nächsten Schritt GPT-4.1 abgefragt, um Erklärungen oder Erkenntnisse über den Code zu gewinnen. Die Funktion query_gpt nimmt die Frage des Entwicklers und die übereinstimmenden Codeschnipsel als Eingabe und gibt eine detaillierte Antwort zurück.

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. Stichwort Codesuche Chat-Anwendung

Der letzte Teil der Anwendung ist der interaktive Chatbot, der alles vereint. Es ermöglicht Entwicklern, Fragen zu ihrer Codebasis zu stellen, Schlüsselwörter aus der Anfrage zu extrahieren, die Codebasis nach relevanten Snippets zu durchsuchen und alles zusammen mit der Frage des Benutzers zur Generierung von Antworten an GPT-4.1 zu senden.

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

Dieser Chatbot bietet Entwicklern eine nahtlose Erfahrung, die es ihnen ermöglicht, mit ihrer Codebasis zu interagieren und KI-gestützte Erkenntnisse zu erhalten. 

Das Projekt umfasst auch ein Code-Repository (kingabzpro/Schlüsselwort-Code-Suche), das den Quellcode und Anleitungen zur Nutzung enthält.

Testen der Anwendung zur Suche nach Schlüsselwörtern

In diesem Abschnitt werden wir die Anwendung Keyword Code Search testen, indem wir sie im Terminal ausführen und ihre Funktionen erkunden. 

Um die Anwendung auszuführen, musst du den Pfad zu dem Code-Repository angeben, das du analysieren möchtest. Für dieses Beispiel werden wir das "Redis ML Projekt" verwenden.

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

Du wirst die Willkommensnachricht und die Anweisungen sehen. Gib einfach deine Frage zu deinem Code ein oder bitte ihn, einen bestimmten Teil der Codebasis zu verbessern.

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

Die Anwendung durchsucht die Codebasis nach relevanten Snippets und fragt GPT-4.1 ab, um eine Antwort zu generieren. 

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

Du kannst Folgefragen stellen, um das ganze Projekt zu verstehen.

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

Diese detaillierte Erklärung hilft den Entwicklern, den Zweck, die Funktionalität und die Struktur des Projekts zu verstehen.

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

Um die Anwendung zu beenden, gib einfach "quit" ein:

Enter your question about the codebase: quit

Exiting chatbot. Goodbye!

Die Keyword Code Search Application ist ein kleines, aber leistungsstarkes Tool, mit dem Entwickler mit ihren Code-Repositories chatten können. Sie kombiniert eine effiziente schlagwortbasierte Codesuche mit der Fähigkeit von GPT-4.1, kontextbezogene Antworten zu generieren. Egal, ob du einen bestimmten Teil deiner Codebasis verbessern oder das gesamte Projekt verstehen musst, diese Anwendung bietet eine nahtlose und intuitive Erfahrung.

Schlussgedanken

Die gesamte KI-Landschaft bewegt sich weg von Hype und oberflächlichen Benchmarks und konzentriert sich stattdessen darauf, einen echten Wert zu liefern, statt nur Illusionen zu haben. Die GPT4.1-Modelle verbessern die Erfahrungen von Entwicklern, indem sie große Sprachmodelle in die Lage versetzen, hochpräzisen und lauffähigen Code zu generieren - und das direkt nach dem Auspacken. Außerdem verfügen diese Modelle über große Kontextfenster, die es ihnen ermöglichen, das gesamte Code-Repository auf einen Schlag zu verstehen. 

Wenn du die OpenAI API in der Praxis kennenlernen möchtest, schau dir unseren Kurs an, Arbeiten mit der OpenAI API um mit der Entwicklung von KI-gestützten Anwendungen zu beginnen. Du kannst dir auch unser Tutorial über die Antworten-API und erfahre mehr über die neue o4-mini Argumentationsmodell.