Guía GPT-4.1 con Proyecto Demo: Aplicación de búsqueda de códigos por palabras clave

Recientemente, OpenAI introdujo la familia GPT-4.1que incluye tres variantes: GPT-4.1, GPT-4.1 Mini y GPT-4.1 Nano. Estos modelos están diseñados para sobresalir en tareas de codificación y seguimiento de instrucciones, ofreciendo avances significativos respecto a sus predecesores. 

Una de sus características más destacadas es una ventana de contexto ampliada que admite hasta 1 millón de fichas, más de ocho veces la capacidad de GPT-4. Esta mejora permite a los modelos manejar entradas extensas, como repositorios enteros de código o flujos de trabajo multidocumento. 

En este tutorial, exploraremos las capacidades de GPT-4.1 construyendo un proyecto que permita a los usuarios buscar en todo un repositorio de código utilizando palabras clave de sus indicaciones. El contenido relevante del repositorio se proporcionará entonces al modelo GPT-4.1, junto con la petición del usuario. 

Como resultado, crearemos una aplicación interactiva que permita a los usuarios chatear con su repositorio de código y utilizar GPT-4.1 para analizar y mejorar todo el código fuente.

Mantenemos a nuestros lectores al día de lo último en IA enviándoles The Median, nuestro boletín gratuito de los viernes que desglosa las noticias clave de la semana. Suscríbete y mantente alerta en sólo unos minutos a la semana:

Primeros pasos con los modelos GPT-4.1

Antes de sumergirte en la construcción del proyecto, es esencial probar primero las distintas versiones de los modelos GPT-4.1 y explorar la nueva API responses. Este API avanzada permite interacciones con estado utilizando salidas anteriores como entradas, admite entradas multimodales como texto e imágenes, y amplía las capacidades del modelo con herramientas incorporadas para la búsqueda de archivos, la búsqueda en la web y la integración de sistemas externos mediante llamadas a funciones.

Para empezar, asegúrate de que tienes instalada la última versión del cliente OpenAI Python. Puedes hacerlo ejecutando el siguiente comando en el terminal:

$ pip install -U openai -q

1. Utilizar el modelo GPT-4.1 Nano para generar texto

En este ejemplo, utilizaremos el modelo GPT-4.1 Nano, optimizado para la velocidad y la rentabilidad, para generar texto. 

En primer lugar, inicializaremos el cliente OpenAI y lo utilizaremos para acceder a la API de respuesta para generar una respuesta.

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)

El modelo GPT-4.1 Nano proporcionó una respuesta bien formateada y concisa.

2. Utilización del modelo GPT-4.1 Mini para la comprensión de imágenes

A continuación, pondremos a prueba el modelo GPT-4.1 Mini proporcionándole la URL de una imagen y pidiéndole que la describa con un 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)

El modelo GPT-4.1 Mini proporcionó una descripción detallada y creativa de la imagen, mostrando su capacidad para interpretar el contenido visual.

3. Utilización del modelo GPT-4.1 (Completo) para la generación de código

Ahora, utilizaremos el modelo "completo" GPT-4.1 para generar código. 

En este ejemplo, proporcionaremos al modelo instrucciones del sistema y una pregunta al usuario y habilitaremos la respuesta del flujo.

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

Hemos utilizado la salida a nivel de sistema (sys.stdout) para mostrar la respuesta de flujo en tiempo real.

4. Utilizar el modelo GPT-4.1 para la generación de código con entradas de archivo

Por último, probaremos la gran ventana de contexto del modelo GPT-4.1 proporcionándole un archivo Python como entrada. El archivo se codifica en formato Base64 y se envía al modelo junto con las instrucciones del usuario.

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)

El modelo GPT-4.1 proporcionó sugerencias conscientes del contexto para mejorar el código, demostrando su capacidad para manejar grandes entradas.

Si tienes algún problema al ejecutar el código anterior, consulta el libro de trabajo DataLab: Jugando con la API GPT-4.1 - DataLab.

Construir la aplicación de búsqueda de códigos de palabras clave 

La Aplicación de Búsqueda de Código por Palabras Clave está diseñada para ayudar a los desarrolladores a buscar eficazmente en una base de código fragmentos relevantes basados en palabras clave específicas y, a continuación, utilizar GPT-4.1 para proporcionar explicaciones o conocimientos sobre el código. 

La aplicación consta de tres partes principales:

1. Buscar en el código base

El primer paso de la aplicación es buscar en el código base fragmentos relevantes que coincidan con la consulta del desarrollador. Para ello se utiliza la función search_codebase, que busca en los archivos de un directorio determinado líneas que contengan las palabras clave 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

Una vez identificados los fragmentos de código relevantes, el siguiente paso es consultar GPT-4.1 para generar explicaciones o ideas sobre el código. La función query_gpt toma la pregunta del programador y los fragmentos de código coincidentes como entrada y devuelve una respuesta detallada.

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. Aplicación de chat de búsqueda de código de palabras clave

La parte final de la aplicación es el chatbot interactivo, que lo combina todo. Permite a los desarrolladores hacer preguntas sobre su base de código, extraer palabras clave de la consulta, buscar en la base de código fragmentos relevantes y enviar todo junto con la pregunta del usuario a GPT-4.1 para que genere la respuesta.

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

Este chatbot proporciona una experiencia fluida a los desarrolladores, permitiéndoles interactuar con su código base y recibir información basada en IA. 

El proyecto también incluye un repositorio de código (kingabzpro/Keyword-Buscar-Código) que contiene el código fuente e instrucciones sobre cómo utilizarlo.

Probar la aplicación de búsqueda de código de palabras clave

En esta sección, probaremos la aplicación Búsqueda de código por palabra clave ejecutándola en el terminal y explorando sus funciones. 

Para ejecutar la aplicación, tienes que proporcionar la ruta al repositorio de código que quieres analizar. Para este ejemplo, utilizaremos el "proyecto Redis ML".

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

Verás el mensaje de bienvenida y las instrucciones. Sólo tienes que escribir tu pregunta sobre tu código o pedirle que mejore una determinada parte del código base.

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

La aplicación buscará en el código base fragmentos relevantes y consultará GPT-4.1 para generar una respuesta. 

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

Puedes hacer preguntas de seguimiento para comprender todo el proyecto.

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

Esta explicación detallada ayuda a los desarrolladores a comprender la finalidad, funcionalidad y estructura del proyecto.

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 salir de la aplicación, simplemente escribe "salir":

Enter your question about the codebase: quit

Exiting chatbot. Goodbye!

La Aplicación de Búsqueda de Código por Palabras Clave es una pequeña pero potente herramienta que permite a los desarrolladores chatear con sus repositorios de código. Combina una eficaz búsqueda de código basada en palabras clave con la capacidad de GPT-4.1 de generar respuestas conscientes del contexto. Tanto si necesitas mejorar una parte concreta de tu base de código como comprender el proyecto en su conjunto, esta aplicación proporciona una experiencia fluida e intuitiva.

Reflexiones finales

Todo el panorama de la IA se está alejando de las exageraciones y los puntos de referencia superficiales, centrándose en cambio en aportar valor real en lugar de meras ilusiones. Los modelos GPT4.1 están mejorando la experiencia de los desarrolladores al permitir que grandes modelos lingüísticos generen código altamente preciso y ejecutable nada más sacarlo de la caja. Además, estos modelos vienen con grandes ventanas contextuales, lo que les permite comprender todo el repositorio de código de una sola vez. 

Si quieres ponerte manos a la obra con la API OpenAI, consulta nuestro curso, Trabajar con la API OpenAI para empezar a desarrollar aplicaciones basadas en IA. También puedes consultar nuestro tutorial sobre la API de respuestas y aprender más sobre el nuevo o4-mini modelo de razonamiento.