Corso
Lavorare con l'API di OpenAI
3 ore
184.8K
Di recente, OpenAI ha introdotto la famiglia GPT-4.1, che include tre varianti: GPT-4.1, GPT-4.1 Mini e GPT-4.1 Nano. Questi modelli sono progettati per eccellere nelle attività di coding e di esecuzione di istruzioni, offrendo progressi significativi rispetto ai predecessori.
Una delle caratteristiche più notevoli è una finestra di contesto ampliata che supporta fino a 1 milione di token, oltre otto volte la capacità di GPT-4. Questo miglioramento consente ai modelli di gestire input estesi, come interi repository di codice o flussi di lavoro con più documenti.
In questo tutorial, esploreremo le capacità di GPT-4.1 costruendo un progetto che consente agli utenti di cercare un intero repository di codice usando parole chiave presenti nei loro prompt. Il contenuto pertinente del repository verrà poi fornito al modello GPT-4.1 insieme al prompt dell’utente.
Il risultato sarà un’applicazione interattiva che permette agli utenti di chattare con il proprio repository di codice e usare GPT-4.1 per analizzare e migliorare l’intero sorgente.
Teniamo i nostri lettori aggiornati sulle ultime novità dell’IA con The Median, la nostra newsletter gratuita del venerdì che spiega le notizie chiave della settimana. Iscriviti e resta sul pezzo in pochi minuti a settimana:
Per iniziare con i modelli GPT-4.1
Prima di metterci a costruire il progetto, è essenziale testare le varie versioni dei modelli GPT-4.1 ed esplorare la nuova API responses. Questa API avanzata abilita interazioni stateful usando output precedenti come input, supporta input multimodali come testo e immagini ed estende le capacità del modello con strumenti integrati per ricerca di file, ricerca sul web e integrazione con sistemi esterni tramite function calling.
Per cominciare, assicurati di avere installata l’ultima versione del client Python di OpenAI. Puoi farlo eseguendo il seguente comando nel terminale:
$ pip install -U openai -q1. Uso del modello GPT-4.1 Nano per la generazione di testo
In questo esempio useremo il modello GPT-4.1 Nano, ottimizzato per velocità ed efficienza dei costi, per generare testo.
Per prima cosa inizializzeremo il client OpenAI e lo useremo per accedere alla response API e generare una risposta.
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)Il modello GPT-4.1 Nano ha fornito una risposta ben formattata e concisa.
2. Uso del modello GPT-4.1 Mini per la comprensione delle immagini
Successivamente testeremo il modello GPT-4.1 Mini fornendogli un URL di un’immagine e chiedendogli di descriverla in stile filosofico.
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)Il modello GPT-4.1 Mini ha fornito una descrizione dettagliata e creativa dell’immagine, dimostrando la sua capacità di interpretare contenuti visivi.
3. Uso del modello GPT-4.1 (completo) per la generazione di codice
Ora useremo il modello GPT-4.1 “completo” per generare codice.
In questo esempio forniremo al modello istruzioni di sistema e un prompt dell’utente e abiliteremo lo streaming della risposta.
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()Abbiamo usato l’output a livello di sistema (sys.stdout) per mostrare la risposta in streaming in tempo reale.
4. Uso del modello GPT-4.1 per generare codice con input da file
Infine, testeremo l’ampia finestra di contesto del modello GPT-4.1 fornendogli un file Python come input. Il file è codificato in formato Base64 e inviato al modello insieme alle istruzioni dell’utente.
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)Il modello GPT-4.1 ha fornito suggerimenti contestualizzati per migliorare il codice, dimostrando la sua capacità di gestire input di grandi dimensioni.
Se riscontri problemi nell’esecuzione del codice sopra, fai riferimento al workbook DataLab: Playing with GPT-4.1 API — DataLab.
Costruire l’applicazione di ricerca del codice per parole chiave
L’applicazione di ricerca del codice per parole chiave è pensata per aiutare gli sviluppatori a cercare in modo efficiente all’interno di una codebase gli snippet pertinenti in base a parole chiave specifiche e poi usare GPT-4.1 per fornire spiegazioni o approfondimenti sul codice.
L’applicazione è composta da tre parti principali:
1. Cercare nella codebase
Il primo passo dell’applicazione è cercare nella codebase gli snippet pertinenti che corrispondono alla query dello sviluppatore. Ciò avviene tramite la funzione search_codebase, che analizza i file in una directory data cercando righe contenenti le parole chiave specificate.
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 matches2. Query a GPT 4.1
Una volta identificati gli snippet di codice pertinenti, il passo successivo è interrogare GPT-4.1 per generare spiegazioni o approfondimenti sul codice. La funzione query_gpt prende in input la domanda dello sviluppatore e gli snippet trovati e restituisce una risposta dettagliata.
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. Chatbot per la ricerca del codice con parole chiave
La parte finale dell’applicazione è il chatbot interattivo che mette insieme tutto. Permette agli sviluppatori di fare domande sulla propria codebase, estrarre parole chiave dalla query, cercare nella codebase gli snippet pertinenti e inviare il tutto insieme alla domanda dell’utente a GPT-4.1 per generare la risposta.
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()Questo chatbot offre un’esperienza fluida per gli sviluppatori, consentendo loro di interagire con la codebase e ricevere approfondimenti potenziati dall’IA.
Il progetto include anche un repository di codice (kingabzpro/Keyword-Code-Search) che contiene il codice sorgente e le istruzioni per l’uso.
Test dell’applicazione di ricerca del codice per parole chiave
In questa sezione testeremo l’applicazione di ricerca del codice per parole chiave eseguendola nel terminale ed esplorandone le funzionalità.
Per eseguire l’applicazione devi fornire il percorso del repository di codice che vuoi analizzare. In questo esempio useremo il “Redis ML project”.
$ python main.py --path C:\Repository\GitHub\Redis-ml-project Vedrai il messaggio di benvenuto e le istruzioni. Digita semplicemente la tua domanda sul codice o chiedi di migliorare una certa parte della codebase.
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 scriptL’applicazione cercherà nella codebase gli snippet pertinenti e interrogherà GPT-4.1 per generare una risposta.
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...........Puoi fare domande di approfondimento per comprendere l’intero progetto.
Enter your question about the codebase: help me understand the projectQuesta spiegazione dettagliata aiuta gli sviluppatori a capire scopo, funzionalità e struttura del progetto.
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…………Per uscire dall’applicazione, digita semplicemente “quit”:
Enter your question about the codebase: quitExiting chatbot. Goodbye!L’applicazione di ricerca del codice per parole chiave è uno strumento piccolo ma potente che permette agli sviluppatori di chattare con i propri repository di codice. Combina una ricerca efficiente del codice basata su parole chiave con la capacità di GPT-4.1 di generare risposte consapevoli del contesto. Che tu debba migliorare una parte specifica della codebase o comprendere l’intero progetto, questa applicazione offre un’esperienza fluida e intuitiva.
Considerazioni finali
L’intero panorama dell’IA si sta allontanando dall’hype e dai benchmark superficiali, concentrandosi invece sulla creazione di valore reale piuttosto che su mere illusioni. I modelli GPT-4.1 stanno migliorando l’esperienza degli sviluppatori consentendo ai modelli linguistici di generare codice altamente accurato ed eseguibile subito. Inoltre, questi modelli offrono ampie finestre di contesto, permettendo di comprendere l’intero repository di codice in un’unica passata.
Se vuoi mettere le mani sull’API di OpenAI, dai un’occhiata al nostro corso Working with the OpenAI API per iniziare a sviluppare applicazioni alimentate dall’IA. Puoi anche consultare il nostro tutorial sulla Responses API e approfondire il nuovo modello di ragionamento o4-mini.
Argomenti
