Guia GPT-4.1 com projeto de demonstração: Aplicativo de pesquisa de código por palavra-chave

Recentemente, a OpenAI apresentou a família GPT-4.1que inclui três variantes: GPT-4.1, GPT-4.1 Mini e GPT-4.1 Nano. Esses modelos foram projetados para se destacarem em tarefas de codificação e acompanhamento de instruções, oferecendo avanços significativos em relação aos seus antecessores. 

Um de seus recursos de destaque é uma janela de contexto expandida que suporta até 1 milhão de tokens, mais de oito vezes a capacidade da GPT-4. Esse aprimoramento permite que os modelos manipulem entradas extensas, como repositórios de códigos inteiros ou fluxos de trabalho com vários documentos. 

Neste tutorial, exploraremos os recursos do GPT-4.1 criando um projeto que permite aos usuários pesquisar um repositório de código inteiro usando palavras-chave de seus prompts. O conteúdo relevante do repositório será então fornecido ao modelo GPT-4.1, juntamente com o prompt do usuário. 

Como resultado, criaremos um aplicativo interativo que permite que os usuários conversem com seu repositório de código e usem o GPT-4.1 para analisar e melhorar todo o código-fonte.

Mantemos nossos leitores atualizados sobre as últimas novidades em IA enviando o The Median, nosso boletim informativo gratuito de sexta-feira que detalha as principais histórias da semana. Inscreva-se e fique atento em apenas alguns minutos por semana:

Primeiros passos com os modelos GPT-4.1

Antes de começar a criar o projeto, é essencial que você teste primeiro as várias versões dos modelos GPT-4.1 e explore a nova API responses. Essa API avançada permite interações com estado usando saídas anteriores como entradas, suporta entradas multimodais como texto e imagens e amplia os recursos do modelo com ferramentas integradas para pesquisa de arquivos, pesquisa na Web e integração de sistemas externos por meio de chamadas de funções.

Para começar, verifique se você tem a versão mais recente do cliente Python da OpenAI instalada. Você pode fazer isso executando o seguinte comando no terminal:

$ pip install -U openai -q

1. Usando o modelo GPT-4.1 Nano para geração de texto

Neste exemplo, usaremos o modelo GPT-4.1 Nano, que é otimizado para velocidade e economia, para gerar texto. 

Primeiro, inicializaremos o cliente OpenAI e o usaremos para acessar a API de resposta para gerar uma resposta.

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)

O modelo GPT-4.1 Nano forneceu uma resposta bem formatada e concisa.

2. Usando o modelo GPT-4.1 Mini para compreensão da imagem

Em seguida, testaremos o modelo GPT-4.1 Mini fornecendo a ele o URL de uma imagem e pedindo que descreva a imagem em um estilo filosófico.

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)

O modelo GPT-4.1 Mini forneceu uma descrição detalhada e criativa da imagem, demonstrando sua capacidade de interpretar o conteúdo visual.

3. Usando o modelo GPT-4.1 (completo) para geração de código

Agora, usaremos o modelo GPT-4.1 "completo" para gerar código. 

Neste exemplo, forneceremos ao modelo instruções do sistema e um prompt de usuário e habilitaremos a resposta do fluxo.

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

Usamos a saída em nível de sistema (sys.stdout) para exibir a resposta de streaming em tempo real.

4. Usando o modelo GPT-4.1 para geração de código com entradas de arquivo

Por fim, testaremos a grande janela de contexto do modelo GPT-4.1, fornecendo a ele um arquivo Python como entrada. O arquivo é codificado no formato Base64 e enviado ao modelo junto com as instruções do usuário.

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)

O modelo GPT-4.1 forneceu sugestões com reconhecimento de contexto para aprimorar o código, demonstrando sua capacidade de lidar com grandes entradas.

Se você tiver algum problema ao executar o código acima, consulte a pasta de trabalho do DataLab: Brincando com a API GPT-4.1 - DataLab.

Criação do aplicativo de pesquisa de código de palavras-chave 

O aplicativo Keyword Code Search foi projetado para ajudar os desenvolvedores a pesquisar com eficiência em uma base de código trechos relevantes com base em palavras-chave específicas e, em seguida, usar o GPT-4.1 para fornecer explicações ou insights sobre o código. 

O aplicativo consiste em três partes principais:

1. Pesquisar base de código

A primeira etapa do aplicativo é pesquisar a base de código em busca de trechos relevantes que correspondam à consulta do desenvolvedor. Isso é feito com a função search_codebase, que verifica os arquivos em um determinado diretório em busca de linhas que contenham as palavras-chave especificadas.

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

Depois que os trechos de código relevantes são identificados, a próxima etapa é consultar o GPT-4.1 para gerar explicações ou insights sobre o código. A função query_gpt recebe a pergunta do desenvolvedor e os trechos de código correspondentes como entrada e retorna uma resposta detalhada.

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. Aplicativo de bate-papo de pesquisa de código de palavras-chave

A parte final do aplicativo é o chatbot interativo, que combina tudo. Ele permite que os desenvolvedores façam perguntas sobre sua base de código, extraiam palavras-chave da consulta, pesquisem a base de código em busca de trechos relevantes e enviem tudo junto com a pergunta do usuário para o GPT-4.1 para a geração de respostas.

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

Esse chatbot oferece uma experiência perfeita para os desenvolvedores, permitindo que eles interajam com sua base de código e recebam insights com tecnologia de IA. 

O projeto também inclui um repositório de código (kingabzpro/Keyword-Code-Search) que contém o código-fonte e instruções sobre como usá-lo.

Teste do aplicativo de pesquisa de código de palavras-chave

Nesta seção, testaremos o aplicativo Keyword Code Search executando-o no terminal e explorando seus recursos. 

Para executar o aplicativo, você precisa fornecer o caminho para o repositório de código que deseja analisar. Para este exemplo, usaremos o "projeto Redis ML".

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

Você verá a mensagem de boas-vindas e as instruções. Basta digitar sua pergunta sobre seu código ou pedir que ele melhore uma determinada parte da base de código.

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

O aplicativo pesquisará a base de código em busca de trechos relevantes e consultará o GPT-4.1 para gerar uma resposta. 

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

Você pode fazer perguntas de acompanhamento para entender todo o projeto.

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

Essa explicação detalhada ajuda os desenvolvedores a entender a finalidade, a funcionalidade e a estrutura do projeto.

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

Para sair do aplicativo, basta digitar "quit":

Enter your question about the codebase: quit

Exiting chatbot. Goodbye!

O aplicativo Keyword Code Search é uma ferramenta pequena, mas poderosa, que permite que os desenvolvedores conversem com seus repositórios de código. Ele combina a pesquisa eficiente de código baseada em palavras-chave com a capacidade do GPT-4.1 de gerar respostas com reconhecimento de contexto. Se você precisa aprimorar uma parte específica da sua base de código ou entender o projeto como um todo, esse aplicativo oferece uma experiência intuitiva e perfeita.

Considerações finais

Todo o cenário da IA está se afastando do hype e dos benchmarks superficiais, concentrando-se em fornecer valor real em vez de meras ilusões. Os modelos GPT4.1 estão aprimorando as experiências dos desenvolvedores ao permitir que grandes modelos de linguagem gerem códigos altamente precisos e executáveis imediatamente. Além disso, esses modelos vêm com grandes janelas de contexto, o que permite que você entenda todo o repositório de código de uma só vez. 

Se você quiser colocar a mão na massa com a API OpenAI, confira nosso curso, Trabalhando com a API OpenAI para você começar a desenvolver aplicativos com tecnologia de IA. Você também pode conferir nosso tutorial sobre a API de respostas e saber mais sobre o novo o4-mini modelo de raciocínio.