Come usare le API LLM ⭐— OpenAI, Claude, Google
Interrogare i modelli di linguaggio di grandi dimensioni (LLM) è diventato un must per la maggior parte delle aziende per sopravvivere durante l’attuale boom dell’IA.
Ottimizzo e analizzo quotidianamente applicazioni basate su LLM e ho visto e testato la maggior parte dei modelli là fuori — open source o meno.
In questo articolo, spiegherò come interrogare queste API di LLM utilizzando Python.
OpenAI — GPT-4o
La prima cosa che devi fare è ottenere una chiave API da OpenAI.
Questo si fa creando un account e generando una chiave utilizzando il loro generatore GUI di chiavi API: https://platform.openai.com/api-keys.
Quando progetti applicazioni utilizzando chiamate API, devi decidere se utilizzare chiamate API sincrone o asincrone.
Questo dipende dal caso d’uso della tua applicazione. Per un principiante, utilizzare il client sincrono è sicuramente il più semplice.
Raccomando di utilizzare il client ufficiale di OpenAI openai, vedi PyPI openai.
pip install openai
L’esempio qui sotto è il modo più semplice per utilizzare il client di OpenAI:
from openai import OpenAI
client = OpenAI(api_key=OPENAI_API_KEY)
response = client.chat.completions.create(
model="gpt-4o-2024-05-13",
messages=[{'role': 'user', 'content': "Hello!"}],
temperature=0.5,
max_tokens=250,
)
answer = response.choices[0].message.content
print(answer) # prints: "Hello! How can I assist you today?"
Tuttavia, utilizzare il client direttamente può diventare rapidamente complicato quando lo usi in più punti.
Quando inizio a codificare usando un client come questo, preferisco implementare una funzione di fetch e una funzione di resolve per avvolgere la logica del client. A volte implemento anche una classe wrapper.
Nota che l’esempio di codice sopra implementa il client sincrono di OpenAI, che blocca la tua applicazione fino a quando la richiesta non ritorna dai server di OpenAI.
Dato che la maggior parte delle applicazioni del mondo reale richiede chiamate asincrone, ho pensato che sarebbe utile fornire anche del codice per questo. Vedi il codice qui sotto:
import asyncio
from openai import AsyncOpenAI
def openai_chat_resolve(response: dict, strip_tokens = None) -> str:
if strip_tokens is None:
strip_tokens = []
if response and response.choices and len(response.choices) > 0:
content = response.choices[0].message.content.strip()
if content is not None or content != '':
if strip_tokens:
for token in strip_tokens:
content = content.replace(token, '')
return content
raise Exception(f'Cannot resolve response: {response}')
async def openai_chat_request(prompt: str, model_name: str, temperature=0.0):
message = {'role': 'user', 'content': prompt}
async with AsyncOpenAI(api_key=OPENAI_API_KEY) as client:
return await client.chat.completions.create(
model=model_name,
messages=[message],
temperature=temperature,
max_tokens=256,
)
# Usage
response = asyncio.run(
openai_chat_request(prompt="Hello!", model_name="gpt-4o-2024-05-13")
)
answer = openai_chat_resolve(response)
print(answer) # prints: "Hello! How can I assist you today?"
Nota che usiamo asyncio per await la funzione di richiesta asincrona.
Nota l’uso di async with AsyncOpenAI per assicurarci di chiudere il client prevenendo problemi di loop di eventi. I problemi di loop di eventi sono comuni per gli sviluppatori che cercano di usare funzioni asincrone per la prima volta.
Il codice fornito utilizza l’API di completamento chat di OpenAI, che supporta vari modelli, come gpt-4-turbo e gpt-4.
Vedi la panoramica dettagliata dei modelli di OpenAI qui.
Vedi i prezzi di OpenAI qui.
Anthropic — Claude 3 Opus
Il processo per Anthropic è molto simile a quello di OpenAI.
- Crea un account e accedi alla dashboard di Anthropic
- Richiedi alcuni crediti gratuiti (credo che tu debba fornire il tuo numero di telefono per questo)
- Genera una chiave API
Raccomando di utilizzare il client ufficiale di Anthropic anthropic, vedi PyPI anthropic.
pip install anthropic
Di seguito è riportato un esempio di codice su come utilizzare il client direttamente (sincrono).
from anthropic import Anthropic
from anthropic.types.message import Message
client = Anthropic(api_key=ANTHROPIC_API_KEY)
response: Message = client.messages.create(
max_tokens=256,
messages=[{'role': 'user', 'content': 'Hello!'}],
model="claude-3-opus-20240229",
temperature=0.5,
)
answer = response.content[0].text
print(answer) # Hello! How can I assist you today?
Ora, vediamo come utilizzare il client LLM di Anthropic asincrono.
import asyncio
from anthropic import AsyncAnthropic
from anthropic.types.message import Message
def anthropic_chat_resolve(response: Message) -> str:
return response.content[0].text
async def anthropic_chat_request(prompt: str, model_name: str, temperature=0.0):
async with AsyncAnthropic(api_key=ANTHROPIC_API_KEY) as client:
response: Message = await client.messages.create(
max_tokens=256,
messages=[
{
"role": "user",
"content": prompt,
}
],
model=model_name,
temperature=temperature,
)
return response
response = asyncio.run(
anthropic_chat_request(prompt="Hello!", model_name="claude-3-opus-20240229")
)
answer = anthropic_chat_resolve(response)
print(answer) # prints: Hello! How can I assist you today?
Come puoi vedere, stiamo usando di nuovo la sintassi async with AsyncAnthropic per assicurarci di chiudere correttamente il client prevenendo problemi di loop di eventi.
Nota che questo script viene eseguito in modo asincrono e usiamo asyncio per await la richiesta asincrona.
Se vuoi usare altri modelli di Anthropic, come claude-3-sonnet e claude-3-haiku, vedi l’elenco dei modelli supportati qui.
Vedi i prezzi di Anthropic qui.
Google — Gemini
Google concentra la sua offerta principale su Vertex AI con controllo degli accessi tramite Google Cloud Platform.
Tuttavia, forniscono anche un client con accesso tramite chiave API simile a OpenAI e Anthropic utilizzando Google AI Studio.
- Accedi a Google AI Studio
- Genera una chiave API
Raccomando di utilizzare il client ufficiale di Google Generative AI, vedi PyPI google-generativeai.
pip install google-generativeai
Di seguito è riportato un esempio di codice su come utilizzare il client direttamente (sincrono).
import google.generativeai as genai
genai.configure(api_key=GOOGLE_API_KEY)
model = genai.GenerativeModel('gemini-1.5-pro')
response = model.generate_content("Hello!")
print(response.text)
Vedi l’elenco dei modelli di AI generativa di Google qui.
Per applicazioni del mondo reale, non consiglio di utilizzare Google AI Studio. Dovresti piuttosto utilizzare Google Vertex AI.
Tuttavia, Google Vertex AI non utilizza chiavi API normali. Invece, si basano su Identity and Access Management in quanto è più sicuro.
Configurare la gestione degli accessi è un processo piuttosto complicato, quindi non entrerò nei dettagli su come farlo per ora.
Ma il codice per utilizzare Vertex AI è simile a questo:
import vertexai
from vertexai.generative_models import GenerativeModel
# Make sure permission is set up
vertexai.init(project="your-project-id", location="us-central1")
model = GenerativeModel(model_name="gemini-1.5-pro-001")
response = model.generate_content("Hello!")
print(response.text)
Memorizzazione delle Chiavi API — Best practice
Prima di iniziare a codificare, affrontiamo un errore comune che le persone fanno — inserire le chiavi API direttamente nel codice.
Idealmente, i segreti e le configurazioni per la tua applicazione NON dovrebbero essere memorizzati nel codice, ma piuttosto inseriti dall’esterno.
Per i tuoi progetti locali, potresti memorizzare le chiavi API nelle variabili d’ambiente caricate dal tuo file .env.
Assicurati anche che il tuo file .env sia incluso nel tuo file .gitignore in modo che la chiave API non entri mai nel tuo repository di codice. Questo ti permette di caricare le chiavi API localmente e di inviare il tuo codice a GitHub senza esporre le tue chiavi API.
Quando hai creato il tuo file .env e lo hai aggiunto a .gitignore, puoi caricare i tuoi ambienti utilizzando os.environ.get("API_KEY").
Una buona pratica è caricare tutti gli ambienti all’interno di un singolo file, ad esempio, denominato settings.py.
import os
from dotenv import load_dotenv
# Install with: "pip install python-dotenv"
load_dotenv() # This will load the .env file at the project root
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY")
GOOGLE_API_KEY = os.environ('GOOGLE_API_KEY')
Tutti gli altri moduli e script Python possono caricare la chiave API dal tuo file di impostazioni.
Nota: a seconda del tuo gestore di ambienti, il file .env potrebbe essere caricato automaticamente, il che significa che non è necessario importare load_dotenv. Ad esempio, Pipenv lo carica automaticamente, mentre Poetry no.
Riepilogo
Interrogare i LLM è diventato essenziale per le aziende che sfruttano la tecnologia AI.
Questo articolo ha fornito istruzioni dettagliate su come interrogare GPT-4o di OpenAI, Claude 3 Opus di Anthropic e Gemini 1.5 di Google utilizzando Python.
Ogni LLM richiede l’ottenimento di una chiave API, l’installazione della rispettiva libreria client e l’implementazione della gestione delle richieste sincrone o asincrone.
Gestire correttamente le chiavi API memorizzandole in variabili d’ambiente e caricandole tramite un file di impostazioni è la pratica consigliata.
Grazie per aver letto!
Gabriele Ferrari
Via Cesare Costa,88
41123 – Modena
Nato il 10/06/1968
Tel. +39 3357682392
P.IVA 03615520362
E-mail: gabriele@gabrieleferrari.net
Web Designer, Digital Project Manager, Esperto di WordPress, Sviluppatore Web, Esperto Certificato di Google Ads, Social Media Manager e Graphic Designer attualmente lavora come libero professionista. Fornisce servizi quali consulenza, sviluppo di siti web, SEO e pubblicità online, marketing sui social media, grafica e sviluppo di app mobile per aziende e privati. Precedente esperienza come Web Project Manager e Social Marketing Manager in importanti agenzie web, nonché Family Banker e Team Manager nel settore dei giochi. Laureato presso la facoltà di Ingegneria Elettronica dell’Università di Bologna.
