ChatGPT API: Podroben vodnik za razvijalce

Posted on by AI

ChatGPT API: Podroben vodnik za razvijalce

Umetna inteligenca (UI) je v zadnjih letih preoblikovala številna področja, od avtomatizacije do personalizacije. Eden najpomembnejših prebojev je bil razvoj velikih jezikovnih modelov (LLM), kot je GPT (Generative Pre-trained Transformer). OpenAI-jev ChatGPT je postal sinonim za pogovorno UI, ki je sposobna razumevati in generirati izjemno kompleksne in kontekstualno relevantne odgovore. Za razvijalce pa je najpomembnejše orodje ChatGPT API, ki omogoča integracijo te moči direktno v lastne aplikacije, sisteme in storitve.

Ta podroben vodnik je namenjen razvijalcem, ki želijo izkoristiti potencial ChatGPT API-ja. Pokrili bomo vse od osnovne nastavitve do naprednih tehnik, s poudarkom na praktičnih primerih in najboljših praksah.

Kaj je ChatGPT API in zakaj ga uporabiti?

ChatGPT API je programski vmesnik, ki razvijalcem omogoča dostop do zmogljivosti OpenAI-jevih jezikovnih modelov, kot so GPT-3.5 Turbo in GPT-4. Namesto da bi morali sami trenirati kompleksne modele, lahko preprosto pošljete zahteve na API in prejmete generirane odgovore. To odpira vrata za nešteto aplikacij:

  • Chatboti in virtualni asistenti: Ustvarite inteligentne pogovorne vmesnike za podporo strankam, prodajo ali notranjo komunikacijo.
  • Generiranje vsebine: Avtomatizirajte pisanje člankov, marketinškega besedila, opisov izdelkov, e-pošte in še več.
  • Povzemanje in ekstrakcija informacij: Hitro povzemite dolge dokumente ali izvlecite ključne podatke.
  • Prevod in lokalizacija: Izboljšajte procese prevajanja z UI.
  • Kreativno pisanje: Pomoč pri pisanju scenarijev, pesmi, zgodb.
  • Analiza sentimenta: Razumevanje čustvenega tona besedila.
  • Kodiranje in odpravljanje napak: Generiranje kode, razlaga kode, pomoč pri odpravljanju napak.

Glavne prednosti uporabe API-ja so hitrost razvoja, skalabilnost, robustnost in dostop do najnovejših modelov, ki jih OpenAI nenehno izboljšuje.

Začetek: Pridobitev API ključa in namestitev

Preden lahko začnete, potrebujete API ključ. Sledite tem korakom:

  1. Obiščite OpenAI Platform in se registrirajte ali prijavite.
  2. Na nadzorni plošči (dashboard) pojdite na ‘API keys’ in ustvarite nov ključ. Ključ shranite na varno mesto, saj ga po ustvarjanju ne boste mogli več videti.
  3. Poskrbite za plačilno metodo, saj ChatGPT API ni brezplačen (čeprav ima OpenAI pogosto začetni brezplačni kredit).

Za interakcijo z API-jem boste potrebovali programsko knjižnico. OpenAI ponuja uradne knjižnice za različne jezike. V tem vodniku se bomo osredotočili na Python, saj je zelo priljubljen v UI skupnosti.

Namestite OpenAI Python knjižnico:

pip install openai

Priporočljivo je, da API ključ shranite kot okoljsko spremenljivko (npr. OPENAI_API_KEY) namesto da ga kodirate direktno v kodo. To je dobra varnostna praksa.

import os
from openai import OpenAI

# API ključ se bo samodejno prevzel iz okoljske spremenljivke OPENAI_API_KEY
# Če ni nastavljena, lahko API ključ podate direktno:
# client = OpenAI(api_key="vaš_api_ključ_tukaj")
client = OpenAI()

Osnove interakcije z API-jem: Pogovori (Chat Completions)

Glavni vmesnik za ChatGPT je ‘Chat Completions’ API. Ta vmesnik je zasnovan za pogovore in omogoča določanje vloge vsakega sporočila (uporabnik, sistem, asistent).

Struktura zahteve

Zahteva API za pogovor običajno vključuje naslednje:

  • model: Ime modela, ki ga želite uporabiti (npr. gpt-3.5-turbo, gpt-4).
  • messages: Seznam sporočil, ki predstavljajo zgodovino pogovora. Vsako sporočilo ima role (vloga) in content (vsebina).
    • system: Določa splošno obnašanje asistenta. To je začetni kontekst.
    • user: Sporočilo uporabnika.
    • assistant: Odgovor modela.

Preprost primer v Pythonu

from openai import OpenAI
import os

client = OpenAI()

def get_completion(prompt, model="gpt-3.5-turbo"):
    messages = [
        {"role": "user", "content": prompt}
    ]
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        temperature=0.7 # Nadzoruje kreativnost/naključnost odgovora
    )
    return response.choices[0].message.content

# Primer uporabe
user_prompt = "Katero je glavno mesto Slovenije?"
response_text = get_completion(user_prompt)
print(response_text)

Vloga “System” za kontekst

Vloga system je ključna za usmerjanje obnašanja modela. Uporabite jo za določanje osebnosti, pravil ali navodil, ki jih mora model upoštevati skozi celoten pogovor.

def get_structured_completion(prompt, model="gpt-3.5-turbo"):
    messages = [
        {"role": "system", "content": "Ti si prijazen in koristen asistent, ki odgovarja na vprašanja o Sloveniji."},
        {"role": "user", "content": prompt}
    ]
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        temperature=0.5 # Manj kreativnosti za dejstva
    )
    return response.choices[0].message.content

print(get_structured_completion("Kateri je najvišji vrh v Sloveniji?"))
print(get_structured_completion("Opiši značilno slovensko jed."))

Vodenje pogovora (Memory)

Za resnične pogovorne izkušnje mora model “pomniti” prejšnja sporočila. To dosežemo tako, da v vsaki zahtevi API-ju pošljemo celotno zgodovino pogovora.

def chat_with_history(messages, model="gpt-3.5-turbo"):
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        temperature=0.7
    )
    return response.choices[0].message.content

# Začetek pogovora
conversation_history = [
    {"role": "system", "content": "Ti si inteligenten asistent. Odgovarjaj kratko in jedrnato."},
    {"role": "user", "content": "Živjo, kako si?"}
]

first_response = chat_with_history(conversation_history)
conversation_history.append({"role": "assistant", "content": first_response})
print(f"Asistent: {first_response}")

# Nadaljevanje pogovora
conversation_history.append({"role": "user", "content": "Kaj pa vreme danes?"})
second_response = chat_with_history(conversation_history)
conversation_history.append({"role": "assistant", "content": second_response})
print(f"Asistent: {second_response}")

# Prikaz celotne zgodovine za demonstracijo
# for msg in conversation_history:
#     print(f"[{msg['role'].capitalize()}]: {msg['content']}")

POZOR: Pošiljanje celotne zgodovine pogovora poveča porabo tokenov in s tem stroške. Za dolge pogovore boste morda morali implementirati strategije za povzemanje ali obrezovanje zgodovine.

Napredne tehnike in praktični nasveti

1. Prilagoditev parametrov

  • temperature: Določa kreativnost modela (0.0 – 2.0).
    • Nižja vrednost (npr. 0.2-0.5): Bolj predvidljivi, osredotočeni in dejstveni odgovori. Primerno za povzemanje, ekstrakcijo informacij, kodiranje.
    • Višja vrednost (npr. 0.7-1.0): Bolj raznoliki, kreativni in presenetljivi odgovori. Primerno za generiranje idej, kreativno pisanje.
  • max_tokens: Omejuje dolžino generiranega odgovora. Pomembno za nadzor nad stroški in strukturo odgovora.
  • top_p: Alternativa za temperature, določa kumulativno verjetnost, iz katere se izbira naslednja beseda. Običajno se uporablja le eden od teh dveh parametrov.
  • n: Število različnih odgovorov, ki jih želite generirati. Uporabno za a/b testiranje ali izbiro najboljšega odgovora.
  • stop: Seznam nizov, ob katerih se generiranje odgovora ustavi. Uporabno za strukturirane odgovore.

2. Uporaba funkcij (Function Calling)

Ena najmočnejših in novejših zmožnosti ChatGPT API-ja je Function Calling. Omogoča modelu, da zazna, kdaj mora poklicati določeno funkcijo, jo pokliče z ustreznimi argumenti in nato uporabi rezultat te funkcije za nadaljevanje pogovora ali izvedbo dejanj.

To omogoča, da ChatGPT API povežete z zunanjim svetom (baze podatkov, API-ji tretjih oseb, interni sistemi).

from openai import OpenAI
import os
import json

client = OpenAI()

# Primer preproste funkcije
def get_current_weather(location, unit="celsius"):
    """Dobi trenutno vreme za določeno lokacijo."""
    if location == "Ljubljana":
        return json.dumps({"location": "Ljubljana", "temperature": "15", "unit": unit, "forecast": "sončno"})
    elif location == "Maribor":
        return json.dumps({"location": "Maribor", "temperature": "12", "unit": unit, "forecast": "oblačno"})
    else:
        return json.dumps({"location": location, "temperature": "neznano", "unit": unit, "forecast": "neznano"})

def run_conversation():
    messages = [
        {"role": "user", "content": "Kakšno je vreme v Ljubljani?"}
    ]
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_current_weather",
                "description": "Dobi trenutno vreme za določeno lokacijo",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "Mesto, npr. Ljubljana, Maribor",
                        },
                        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
                    },
                    "required": ["location"],
                },
            },
        }
    ]
    
    response = client.chat.completions.create(
        model="gpt-3.5-turbo-0125",
        messages=messages,
        tools=tools,
        tool_choice="auto",
    )
    
    response_message = response.choices[0].message
    tool_calls = response_message.tool_calls

    if tool_calls:
        # Prikaz modelove odločitve o klicu funkcije:
        print(f"Model želi poklicati funkcijo: {tool_calls[0].function.name}")
        print(f"Argumenti: {tool_calls[0].function.arguments}")

        available_functions = {
            "get_current_weather": get_current_weather,
        }
        
        messages.append(response_message)
        
        for tool_call in tool_calls:
            function_name = tool_call.function.name
            function_to_call = available_functions[function_name]
            function_args = json.loads(tool_call.function.arguments)
            function_response = function_to_call(
                location=function_args.get("location"),
                unit=function_args.get("unit"),
            )
            messages.append(
                {
                    "tool_call_id": tool_call.id,
                    "role": "tool",
                    "name": function_name,
                    "content": function_response,
                }
            )
        
        second_response = client.chat.completions.create(
            model="gpt-3.5-turbo-0125",
            messages=messages,
        )
        return second_response.choices[0].message.content
    else:
        return response_message.content

print(run_conversation())

Ta funkcionalnost je izjemno močna za gradnjo kompleksnih UI agentov, ki lahko izvajajo dejanja.

3. Vzorčenje (Few-shot prompting)

Čeprav ChatGPT API dobro razume navodila, lahko njegovo delovanje bistveno izboljšate z vključitvijo nekaj primerov želenega vhoda/izhoda v prompt.

prompt_with_examples = """
    Pretvori naslednje stavke v pasivno obliko:

    Vhod: Pes je ugriznil poštarja.
    Izhod: Poštarja je ugriznil pes.

    Vhod: Otroci so pojedli vse piškote.
    Izhod: Vsi piškoti so bili pojedeni s strani otrok.

    Vhod: On piše knjigo.
    Izhod: Knjigo piše on.
    """
    print(get_completion(prompt_with_examples))

To modelu pomaga razumeti želeni format in slog odgovora.

4. Zmanjšanje stroškov in optimizacija uspešnosti

  • Izbira modela: Uporabite gpt-3.5-turbo za večino nalog, kjer je pomembna hitrost in cena. gpt-4 in gpt-4o sta zmogljivejša, a dražja in počasnejša. Uporabite ju za kompleksne naloge, ki zahtevajo globoko razumevanje.
  • Omejevanje tokenov: Z max_tokens preprečite preveč dolge odgovore.
  • Obdelava zgodovine pogovorov: Za dolge pogovore povzemite prejšnja sporočila ali ohranite le zadnjih N sporočil, da zmanjšate število poslanih tokenov.
  • Caching: Shranite pogoste odgovore, da se izognete ponovnim API klicem.
  • Asinhrone zahteve: Za visoko obremenitev razmislite o asinhronih klicih API-ja, da izboljšate prepustnost.

5. Obvladovanje napak in omejitev (Rate Limits)

API lahko vrne napake (npr. zaradi neveljavnega ključa, preobremenitve). Pomembno je implementirati robustno obravnavo napak.

from openai import OpenAI, OpenAIError
import os
import time

client = OpenAI()

def safe_completion(prompt, model="gpt-3.5-turbo", retries=3, delay=5):
    messages = [{"role": "user", "content": prompt}]
    for i in range(retries):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages,
                temperature=0.7
            )
            return response.choices[0].message.content
        except OpenAIError as e:
            print(f"Napaka pri API klicu: {e}")
            if i < retries - 1:
                print(f"Ponoven poskus ({i+1}/{retries}) po {delay} sekundah...")
                time.sleep(delay)
            else:
                return f"Napaka: Po več poskusih ni bilo mogoče dobiti odgovora. Napaka: {e}"
    return "Neznana napaka."

print(safe_completion("Povej mi šalo."))

OpenAI ima omejitve glede števila zahtev na minuto (RPM) in tokenov na minuto (TPM). Vedno upoštevajte te omejitve in uporabite eksponentni backoff pri ponovnih poskusih.

Varnost in etika

  • Zaupnost podatkov: Ne pošiljajte občutljivih, osebnih ali tajnih podatkov v API, razen če ste prepričani v varnostni protokol (ki ga OpenAI sicer ima, a previdnost ni odveč).
  • Filtri vsebine: OpenAI ima vgrajene filtre za preprečevanje generiranja škodljive ali neprimerne vsebine. Kljub temu je pomembno, da tudi sami implementirate mehanizme za preverjanje izhodov.
  • Previdnost pri “hallucinacijah”: LLM-ji lahko občasno generirajo napačne ali izmišljene informacije. Ključno je, da to upoštevate in po potrebi preverite dejstva, še posebej pri kritičnih aplikacijah.
  • Uporabniški vmesnik: Vedno obvestite uporabnike, da komunicirajo z UI, in ne s človekom.

Zaključek

ChatGPT API je izjemno močno orodje, ki razvijalcem omogoča integracijo naprednih zmožnosti generiranja naravnega jezika v njihove aplikacije. Od preprostih chatbotov do kompleksnih agentov, ki sodelujejo z zunanjimi sistemi, možnosti so skoraj neomejene.

Z razumevanjem osnovnih konceptov, kot so vloge sporočil, parametri modela in napredne tehnike, kot je Function Calling, lahko zgradite inteligentne in učinkovite rešitve. Ne pozabite na optimizacijo stroškov, obvladovanje napak in etične vidike, da zagotovite robustno in odgovorno implementacijo.

Nadaljujte z eksperimentiranjem, preučevanjem dokumentacije OpenAI in sodelovanjem s skupnostjo, saj se to področje nenehno razvija. Srečno kodiranje!

Related Posts