ChatGPT e Python - Crea il Tuo Assistente Personale

chatbotintelligenza-artificialechatgptopenai

Intelligenza artificiale, OpenAI, Large Language Models, ChatGPT: in questi mesi non si parla praticamente di nient'altro. Comprensibilmente.

In molti ci avete richiesto di parlarne, ed ora che OpenAI ha aperto l'API di ChatGPT al pubblico, il momento è finalmente arrivato.

Vedremo come utilizzare Python per connetterci all'API di OpenAI e utilizzare lo stesso modello che anima ChatGPT, chiamato gpt-3.5-turbo, integrandolo così all'interno delle nostre applicazioni per sfruttarne tutte le sue potenzialità.

Per poter integrare ChatGPT e altri modelli di OpenAI all’interno di un progetto Python via API dobbiamo anzitutto generare una chiave di accesso (secret key) all’interno del portale platform di OpenAI, selezionando la voce del menù API Keys.

Una volta ottenuta la chiave d'accesso possiamo iniziare con la scrittura del codice.

Di cosa avrete bisogno?

Per poter applicare al meglio quanto mostrato in questo tutorial dovreste conoscere almeno le basi di Python.

Come prima cosa, creiamo un nuovo ambiente virtuale tramite venv e installiamo il package openai tramite pip

pip install openai

Nella cartella del nostro progetto creiamo un nuovo script e un file .json chiamato secrets. Useremo il file json per salvare la nostra chiave di accesso

{
    "api_key": "la-vostra-secret-key"
}

Ricordiamoci di aggiungere il file secrets.json a .gitignore nel caso stessimo utilizzando un VCS come git.

Come integrare ChatGPT in Python

Nota: rispetto a quanto mostrato nel video, a partire dal 6 Novembre 2023, l'api di OpenAI è stata aggiornata e il codice risulta quindi differente.Sul repo relativo nel mio profilo GitHub potete trovare uno storico delle modifiche. In questo articolo vedremo assieme il codice aggiornato e funzionante.

Creiamo un file python ed importiamo i moduli json e openai. Assicuratevi di non chiamare il file su cui scriverete codice "openai.py" perché questo causerebbe dei conflitti con la libreria omonima appena importata! Noi chiameremo il nostro file semplicemente assistant.py

import json

from openai import OpenAI

Importiamo la nostra secret key per autenticarci leggendola dal file json tramite il modulo apposito. Nel fare ciò, assicuriamoci di gestire eventuali eccezioni che potrebbero manifestarsi:

try:
    with open("secrets.json") as f:
        secrets = json.load(f)
        api_key = secrets["api_key"]
except FileNotFoundError:
    print("Il file 'secrets.json' non è stato trovato.")
except KeyError:
    print("L'api_key non è stata trovata in 'secrets.json'.")

Per poterci autenticare ed essere quindi in grado di comunicare con il backend di OpenAI, avremo bisogno di creare un oggetto client e assegnare a questo la nostra api_key. Possiamo definire il client direttamente nel blocco try:

try:
    with open("secrets.json") as f:
        secrets = json.load(f)
        api_key = secrets["api_key"]
    client = OpenAI(api_key=api_key)
except FileNotFoundError:
    print("Il file 'secrets.json' non è stato trovato.")
except KeyError:
    print("L'api_key non è stata trovata in 'secrets.json'.")

Per poter dialogare con il modello AI possiamo ora utilizzare

client.chat.completions.create()

Definiamo una variabile response alla quale passare il response ottenuto dal backend di OpenAI. Passiamo a create 3 parametri: model, messages e temperature

response = client.chat.completions.create(
    model = "gpt-4",
    messages = [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Who won the world series in 2020?"},
        {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
        {"role": "user", "content": "Where was it played?"}
    ]
    temperature = 1.0
)

I parametri model, messages e temperature

OpenAI dispone di vari modelli di Intelligenza Artificiale utilizzabili tramite API.

Per questo motivo al primo parametro model passiamo il codename del modello che intendiamo utilizzare, ovvero del "sistema" vero e proprio con cui stiamo interagendo a livello testuale. Al momento stiamo utilizzando l'ultimo disponibile, gpt-4. In alternativa, possiamo usare gpt-3.5-turbo. Daremo una definizione di modello linguistico più avanti nella lezione.

Con temperature possiamo controllare il “livello di confidenza” del modello quando effettua queste previsioni. Un valore di temperatura basso determina previsioni più deterministiche e accurate, mentre l'aumento della temperatura si tradurrà in risposte più diversificate. Il valore di default per la temperature è 1.0 e accetta valori in range 0.0 - 2.0.

Infine, messages è lista di dizionari, dove ciascuno ha un ruolo (”sistema”, “utente” o “assistente”) e un contenuto. I messaggi con role system aiutano ad impostare il comportamento dell'assistente impostando il contesto iniziale, i messaggi user impartiscono le istruzioni all'assistente e possono essere generati dagli utenti, mentre i messaggi assistant rappresentano le risposte precedenti inviate da ChatGPT.

Per un elenco completo dei parametri potete dare uno sguardo alla pagina dedicata della documentazione sul sito ufficiale.

Come usare questo codice su più moduli?

Lo scopo di questo articolo è permettervi di integrare questo modello linguistico nei vostri progetti, e per fare ciò è necessario che il codice sia utilizzabile su più moduli. Possiamo quindi usare una funzione, da importare quando necessario.

La funzione accetterà come parametro una lista chiamata messages, che potremo quindi passare alla funzione create(). La notazione messages: list utilizza la nomenclature dei type hint di Python, ovvero il controllo del tipo passato alla variabile non è validato in runtime ma può essere da strumenti di sviluppo come IDEs, linters, type checkers ecc.

Notate il valore restituito da get_chat_response(): response.choices[0].message. Di tutto l'output restituito dal backend di OpenAI ci interessa solamente il messaggio restituito, così che possa essere aggiunto alla lista messages ed inviato assieme a tutti gli altri messaggi precedentemente scambiati nelle richieste successive.

def get_chat_response(messages:list):
    response = client.chat.completions.create(
        model = "gpt-4",
        messages=messages,
        temperature = 1.0 # 0.0 - 2.0
    )
    return response.choices[0].message

Il nostro assistente personale

Per creare il modello in modalità assistente personale è ora sufficiente creare un ciclo while infinito in cui richiedere input all'utente, fare richieste al backend per una risposta e mostrare tutto in output.

Utilizziamo if __name__ == "__main__" , per fare in modo di eseguire questo codice ogni qualvolta il file dove stiamo eseguendo questo codice (nel nostro caso assistant.py) venga eseguito come script, ad esempio lanciandolo da un terminale di sistema come mostrato nel video.

Definiamo inoltre messages e definiamo in questa un primo messaggio con role: system

import json
from openai import OpenAI


try:
    with open("secrets.json") as f:
        secrets = json.load(f)
        api_key = secrets["api_key"]
    client = OpenAI(api_key=api_key)
except FileNotFoundError:
    print("Il file 'secrets.json' non è stato trovato.")
except KeyError:
    print("L'api_key non è stata trovata in 'secrets.json'.")


def get_chat_response(messages: list[dict]):
    response = client.chat.completions.create(
        model = "gpt-4", # or "gpt-3.5-turbo"
        messages=messages,
        temperature = 1.0 # 0.0 - 2.0
    )
    return response.choices[0].message


if __name__ == "__main__":
    assistant_name = "Joi"
    messages = [
        {
            "role": "system", 
            "content": f"Sei un assistente virtuale chiamata {assistant_name} e parli italiano."
        }
    ]
    try:
        while True:
            user_input = input("\nTu: ")
            messages.append({"role": "user", "content": user_input})
            new_message = get_chat_response(messages=messages)
            print(f"\n{assistant_name}: {new_message.content}")
            messages.append(new_message)
    except KeyboardInterrupt:
        print("A presto!")

Repository GitHub

Preferite visionare il codice da un repository git, in modo magari da farci un fork? Potete trovarlo qui sul mio profilo GitHub con licenza MIT.

Errore di accesso all'API: che fare?

Un tempo, ogni nuovo account OpenAI riceveva del credito gratutio da poter utilizzare per impiegare l'API, ma ora non più. Per poter continuare ad utilizzare l'API dovremo quindi abbinare una carta al nostro account!

Tuttavia siamo fortunati perché il modello gpt-3.5-turbo è davvero economico: solo $0.002 per ogni 1K token!

Vediamo come ottenere dei crediti da usare con l'API di OpenAI:

OpenAI: come abbinare un metodo di pagamento

Dalla piattaforma di OpenAI, nel menu a tendina cliccate Manage Account / Billing / Payment Methods. Potrete quindi aggiungere come metodo di pagamento una carta di credito / debito. Potrete ora acquistare dei crediti dalla piattaforma.

Impostare dei limiti di utilizzo

Per quanto $0.002 ogni 1K token sia un costo davvero esiguo, vi consigliamo comunque di impostare dei limiti di utilizzo al vostro metodo di pagamento.

Hard Limit: la cifra massima utilizzabile ogni mese, dopo la quale ogni altra richiesta viene respinta. Default 120 $
Soft Limit: cifra che se superata in un mese comporta l'invio di una mail informativa, ma che permette ulteriori richieste. Default 96 $

Dalla stessa pagina potrete inoltre visionare la spesa attuale per il mese corrente dalla voce Current usage.