Panduan GPT-4.1 dengan Proyek Demo: Aplikasi Pencarian Kode Berbasis Kata Kunci

Baru-baru ini, OpenAI memperkenalkan keluarga GPT-4.1, yang mencakup tiga varian: GPT-4.1, GPT-4.1 Mini, dan GPT-4.1 Nano. Model-model ini dirancang untuk unggul dalam tugas pemrograman dan mengikuti instruksi, menawarkan peningkatan signifikan dibanding pendahulunya. 

Salah satu fitur unggulannya adalah jendela konteks yang diperluas hingga 1 juta token—lebih dari delapan kali kapasitas GPT-4. Peningkatan ini memungkinkan model menangani masukan yang luas, seperti seluruh repositori kode atau alur kerja multi-dokumen. 

Dalam tutorial ini, kita akan mengeksplorasi kemampuan GPT-4.1 dengan membangun proyek yang memungkinkan pengguna menelusuri seluruh repositori kode menggunakan kata kunci dari prompt mereka. Konten relevan dari repositori kemudian akan diberikan ke model GPT-4.1, bersama dengan prompt pengguna. 

Hasilnya, kita akan membuat aplikasi interaktif yang memungkinkan pengguna mengobrol dengan repositori kodenya dan menggunakan GPT-4.1 untuk menganalisis serta meningkatkan seluruh sumber kode.

Kami selalu memperbarui pembaca tentang hal terbaru di AI melalui The Median, buletin gratis setiap Jumat yang merangkum berita utama pekan ini. Berlangganan dan tetap up-to-date hanya dalam beberapa menit setiap minggu:

Memulai dengan Model GPT-4.1

Sebelum mulai membangun proyek, penting untuk terlebih dahulu menguji berbagai versi model GPT-4.1 dan mengeksplorasi API responses yang baru. API tingkat lanjut ini memungkinkan interaksi stateful dengan menggunakan keluaran sebelumnya sebagai masukan, mendukung masukan multimodal seperti teks dan gambar, serta memperluas kemampuan model dengan alat bawaan untuk pencarian file, pencarian web, dan integrasi sistem eksternal melalui pemanggilan fungsi.

Untuk memulai, pastikan Anda telah memasang klien Python OpenAI versi terbaru. Anda dapat melakukannya dengan menjalankan perintah berikut di terminal:

$ pip install -U openai -q

1. Menggunakan model GPT-4.1 Nano untuk pembuatan teks

Dalam contoh ini, kita akan menggunakan model GPT-4.1 Nano, yang dioptimalkan untuk kecepatan dan efisiensi biaya, untuk menghasilkan teks. 

Pertama, kita akan menginisialisasi klien OpenAI dan menggunakannya untuk mengakses API response guna menghasilkan respons.

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)

Model GPT-4.1 Nano memberikan respons yang terformat rapi dan ringkas.

2. Menggunakan model GPT-4.1 Mini untuk memahami gambar

Berikutnya, kita akan menguji model GPT-4.1 Mini dengan memberinya URL gambar dan memintanya mendeskripsikan gambar tersebut dalam gaya filosofis.

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)

Model GPT-4.1 Mini memberikan deskripsi gambar yang detail dan kreatif, menunjukkan kemampuannya menafsirkan konten visual.

3. Menggunakan model GPT-4.1 (Penuh) untuk pembuatan kode

Sekarang, kita akan menggunakan model GPT-4.1 versi “penuh” untuk menghasilkan kode. 

Dalam contoh ini, kita akan memberikan instruksi sistem dan prompt pengguna ke model serta mengaktifkan respons streaming.

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

Kita menggunakan keluaran tingkat sistem (sys.stdout) untuk menampilkan respons streaming secara real time.

4. Menggunakan model GPT-4.1 untuk pembuatan kode dengan masukan file

Terakhir, kita akan menguji jendela konteks besar pada model GPT-4.1 dengan memberinya sebuah file Python sebagai masukan. File dikodekan dalam format Base64 dan dikirim ke model bersama instruksi pengguna.

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)

Model GPT-4.1 memberikan saran kontekstual untuk meningkatkan kode, menunjukkan kemampuannya menangani masukan yang besar.

Jika Anda mengalami kendala saat menjalankan kode di atas, silakan merujuk ke workbook DataLab: Bermain dengan GPT-4.1 API — DataLab.

Membangun Aplikasi Pencarian Kode Berbasis Kata Kunci 

Aplikasi Pencarian Kode Berbasis Kata Kunci dirancang untuk membantu pengembang menelusuri basis kode secara efisien untuk potongan kode relevan berdasarkan kata kunci tertentu, lalu menggunakan GPT-4.1 untuk memberikan penjelasan atau wawasan tentang kode tersebut. 

Aplikasi ini terdiri dari tiga bagian utama:

1. Menelusuri basis kode

Langkah pertama dalam aplikasi adalah menelusuri basis kode untuk potongan kode relevan yang cocok dengan kueri pengembang. Ini dicapai menggunakan fungsi search_codebase, yang memindai file di direktori tertentu untuk baris yang mengandung kata kunci yang ditentukan.

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. Kueri GPT 4.1

Setelah potongan kode relevan teridentifikasi, langkah selanjutnya adalah mengajukan kueri ke GPT-4.1 untuk menghasilkan penjelasan atau wawasan tentang kode tersebut. Fungsi query_gpt menerima pertanyaan pengembang dan potongan kode yang cocok sebagai masukan dan mengembalikan respons terperinci.

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. Aplikasi chat pencarian kode berbasis kata kunci

Bagian terakhir dari aplikasi adalah chatbot interaktif yang menggabungkan semuanya. Ini memungkinkan pengembang mengajukan pertanyaan tentang basis kodenya, mengekstrak kata kunci dari kueri, menelusuri basis kode untuk potongan yang relevan, dan mengirim semuanya bersama pertanyaan pengguna ke GPT-4.1 untuk menghasilkan respons.

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

Chatbot ini memberikan pengalaman yang mulus bagi pengembang, memungkinkan mereka berinteraksi dengan basis kodenya dan menerima wawasan yang didukung AI. 

Proyek ini juga mencakup repositori kode (kingabzpro/Keyword-Code-Search) yang berisi kode sumber dan instruksi cara menggunakannya. 

Menguji Aplikasi Pencarian Kode Berbasis Kata Kunci

Di bagian ini, kita akan menguji aplikasi Pencarian Kode Berbasis Kata Kunci dengan menjalankannya di terminal dan mengeksplorasi fiturnya. 

Untuk menjalankan aplikasi, Anda perlu memberikan path ke repositori kode yang ingin dianalisis. Pada contoh ini, kita akan menggunakan “proyek Redis ML.”

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

Anda akan melihat pesan sambutan dan instruksi. Cukup ketik pertanyaan Anda tentang kode atau minta perbaikan pada bagian tertentu dari basis kode.

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

Aplikasi akan menelusuri basis kode untuk potongan relevan dan mengajukan kueri ke GPT-4.1 untuk menghasilkan respons. 

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

Anda dapat mengajukan pertanyaan lanjutan untuk memahami keseluruhan proyek.

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

Penjelasan mendetail ini membantu pengembang memahami tujuan, fungsionalitas, dan struktur proyek.

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

Untuk keluar dari aplikasi, cukup ketik ‘quit’:

Enter your question about the codebase: quit

Exiting chatbot. Goodbye!

Aplikasi Pencarian Kode Berbasis Kata Kunci adalah alat kecil namun bertenaga yang memungkinkan pengembang mengobrol dengan repositori kodenya. Aplikasi ini menggabungkan penelusuran kode berbasis kata kunci yang efisien dengan kemampuan GPT-4.1 untuk menghasilkan respons yang peka konteks. Baik Anda ingin meningkatkan bagian spesifik dari basis kode atau memahami keseluruhan proyek, aplikasi ini memberikan pengalaman yang mulus dan intuitif.

Penutup

Seluruh lanskap AI bergerak menjauh dari hype dan tolok ukur yang dangkal, berfokus pada penyampaian nilai nyata alih-alih ilusi. Model GPT4.1 meningkatkan pengalaman pengembang dengan memungkinkan model bahasa besar menghasilkan kode yang sangat akurat dan dapat dijalankan langsung. Selain itu, model-model ini hadir dengan jendela konteks yang besar, memungkinkan pemahaman seluruh repositori kode sekaligus. 

Jika Anda ingin langsung praktik dengan OpenAI API, lihat kursus kami, Working with the OpenAI API untuk mulai mengembangkan aplikasi berbasis AI. Anda juga dapat melihat tutorial kami tentang Responses API dan pelajari lebih lanjut tentang model penalaran o4-mini yang baru.