OpenAI API: Panduan Developer

📋 Daftar Isi

Pengantar OpenAI API
Setup & Instalasi
Chat Completions API
Prompt Engineering
Embeddings API
Function Calling
Fine-tuning
Quiz Pemahaman

1. Pengantar OpenAI API

OpenAI API memberikan akses ke model bahasa (Large Language Models / LLM) tercanggih seperti GPT-4o, GPT-4, dan GPT-3.5 Turbo melalui REST API. Dengan API ini, developer bisa mengintegrasikan kemampuan AI generatif ke dalam aplikasi mereka — mulai dari chatbot, analisis teks, pembuatan konten, hingga coding assistant.

Fitur Utama OpenAI API

Fitur	Penjelasan	Contoh Penggunaan
Chat Completions	Generate teks berdasarkan percakapan	Chatbot, asisten virtual
Embeddings	Konversi teks ke vektor numerik	Pencarian semantik, rekomendasi
Function Calling	Mintai model memanggil fungsi Anda	Integrasi API, tool use
Fine-tuning	Kustomisasi model dengan data Anda	Domain spesifik, tone tertentu
Vision	Analisis dan deskripsi gambar	OCR, image captioning
Streaming	Response dikirim bertahap (real-time)	UX yang responsif

Model yang Tersedia

Model	Keunggulan	Harga (per 1M token)
GPT-4o	🟢 Multimodal, cepat, berkualitas tinggi	$2.50 input / $10 output
GPT-4o-mini	🟢 Murah, cepat, bagus untuk banyak kasus	$0.15 input / $0.60 output
GPT-4 Turbo	Konteks 128K, multimodal	$10 input / $30 output
GPT-3.5 Turbo	🟢 Termurah, cepat	$0.50 input / $1.50 output
o1 / o1-mini	Reasoning chains, problem solving	Variasi

2. Setup & Instalasi

Bash — Instalasi OpenAI SDK

# Instalasi Python SDK
pip install openai

# Verifikasi
python -c "import openai; print(openai.__version__)"

Konfigurasi API Key

Python — Setup API Key

import os
from openai import OpenAI

# ===== CARA 1: Environment Variable (RECOMMENDED) =====
# Di terminal:
# export OPENAI_API_KEY="sk-..." (Linux/Mac)
# set OPENAI_API_KEY=sk-... (Windows)

# Di Python:
client = OpenAI()  # Otomatis baca dari env var OPENAI_API_KEY

# ===== CARA 2: Langsung (untuk development/testing) =====
client = OpenAI(api_key="sk-your-api-key-here")

# ===== CARA 3: Dari .env file =====
# pip install python-dotenv
from dotenv import load_dotenv
load_dotenv()
client = OpenAI()

# Verifikasi koneksi
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Halo, bilang 'berhasil' saja"}],
    max_tokens=10
)
print(response.choices[0].message.content)

⚠️ Keamanan API Key

Jangan pernah commit API key ke Git / GitHub
Gunakan environment variable atau file .env (tambahkan ke .gitignore)
Untuk production, gunakan secret manager (AWS Secrets Manager, Google Secret Manager, dll.)
Set billing limit di dashboard OpenAI untuk mencegah tagihan tak terduga

3. Chat Completions API

Chat Completions adalah endpoint utama OpenAI API. Anda mengirim array messages (percakapan) dan model menghasilkan respons berikutnya. Setiap message memiliki role yang menentukan siapa yang berbicara.

Message Roles

Role	Fungsi	Contoh
`system`	Instruksi untuk AI — personality, aturan, batasan	"Kamu adalah asisten coding yang ramah"
`user`	Pesan dari pengguna manusia	"Jelaskan apa itu API"
`assistant`	Respons dari AI (termasuk riwayat)	"API adalah antarmuka..."

Basic Chat Completion

Python — Chat Completions Dasar

from openai import OpenAI
client = OpenAI()

# ===== BASIC CHAT =====
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Kamu adalah asisten AI yang ramah dan menjawab dalam Bahasa Indonesia."},
        {"role": "user", "content": "Apa itu Machine Learning dalam 2 kalimat?"}
    ],
    max_tokens=200,
    temperature=0.7
)

# Akses response
message = response.choices[0].message
print(f"Response: {message.content}")
print(f"\nToken usage:")
print(f"  Prompt tokens: {response.usage.prompt_tokens}")
print(f"  Completion tokens: {response.usage.completion_tokens}")
print(f"  Total tokens: {response.usage.total_tokens}")
print(f"  Model: {response.model}")

Parameters Penting

Parameter	Default	Penjelasan
`model`	-	Nama model (wajib): gpt-4o, gpt-4o-mini, gpt-3.5-turbo
`messages`	-	Array pesan percakapan (wajib)
`max_tokens`	inf	Max token yang di-generate
`temperature`	1.0	Kreativitas: 0 = deterministik, 2 = sangat kreatif
`top_p`	1.0	Alternative sampling — jangan campur dengan temperature
`stream`	False	True untuk streaming response
`response_format`	None	`{"type": "json_object"}` untuk JSON mode

Multi-turn Conversation

Python — Multi-turn Chat

from openai import OpenAI
client = OpenAI()

def chat(messages):
    """Kirim pesan dan dapatkan respons."""
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
        temperature=0.7,
        max_tokens=500
    )
    return response.choices[0].message.content

# Simulasi percakapan multi-turn
conversation = [
    {"role": "system", "content": "Kamu adalah mentor programming yang sabar. Jawab dalam Bahasa Indonesia."},
]

# Turn 1
conversation.append({"role": "user", "content": "Apa perbedaan list dan tuple di Python?"})
response1 = chat(conversation)
conversation.append({"role": "assistant", "content": response1})
print(f"Q1: {conversation[-2]['content']}")
print(f"A1: {response1}\n")

# Turn 2 (follow-up)
conversation.append({"role": "user", "content": "Kapan sebaiknya pakai tuple daripada list?"})
response2 = chat(conversation)
conversation.append({"role": "assistant", "content": response2})
print(f"Q2: {conversation[-2]['content']}")
print(f"A2: {response2}\n")

# Turn 3 (masih ingat konteks sebelumnya!)
conversation.append({"role": "user", "content": "Beri contoh kasus nyata masing-masing"})
response3 = chat(conversation)
print(f"Q3: {conversation[-2]['content']}")
print(f"A3: {response3}")

Streaming Response

Python — Streaming

from openai import OpenAI
client = OpenAI()

# Streaming — respons dikirim chunk by chunk
stream = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": "Jelaskan 5 konsep penting dalam OOP dengan contoh singkat"}
    ],
    stream=True,
    max_tokens=1000
)

print("Response (streaming):")
for chunk in stream:
    content = chunk.choices[0].delta.content
    if content is not None:
        print(content, end="", flush=True)
print("\n\n--- Selesai ---")

4. Prompt Engineering

Prompt Engineering adalah seni merancang instruksi untuk mendapatkan output terbaik dari LLM. Prompt yang baik bisa sangat meningkatkan kualitas respons tanpa perlu fine-tuning.

Teknik Prompt Engineering

Teknik	Penjelasan	Contoh
Role Setting	Tentukan persona AI di system message	"Kamu adalah senior Python developer"
Few-shot	Beri beberapa contoh input-output	"Input: bagus → Positif. Input: jelek → Negatif. Input: hebat → ?"
Chain of Thought	Minta AI berpikir langkah demi langkah	"Jelaskan langkah demi langkah..."
Output Format	Tentukan format output yang diinginkan	"Jawab dalam format JSON"
Constraints	Berikan batasan yang jelas	"Maksimal 3 kalimat, gunakan bahasa sederhana"

Python — Prompt Engineering Examples

from openai import OpenAI
client = OpenAI()

def ask(system, user, temp=0.7):
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": user}
        ],
        temperature=temp,
        max_tokens=500
    )
    return response.choices[0].message.content

# ===== 1. ROLE + FEW-SOT =====
system_sentiment = """Kamu adalah analis sentimen. Analisis sentimen teks berikut dan berikan label:
- Positif: teks menunjukkan perasaan senang, puas, atau suka
- Netral: teks tidak menunjukkan emosi kuat
- Negatif: teks menunjukkan kecewa, marah, atau tidak suka

Contoh:
Input: "Produk ini sangat bagus dan awet!" → Positif
Input: "Barangnya biasa saja" → Netral
Input: "Sangat kecewa, barang rusak!" → Negatif

Jawab HANYA dengan label: Positif, Netral, atau Negatif."""

texts = [
    "Pengiriman cepat dan kemasan rapi!",
    "Harganya segitu ya, oke lah",
    "Menyesal beli ini, kualitas sangat buruk!"
]

print("=== SENTIMENT ANALYSIS ===")
for text in texts:
    result = ask(system_sentiment, text, temp=0)
    print(f"  \"{text}\" → {result}")

# ===== 2. CHAIN OF THOUGHT =====
system_cot = """Kamu adalah tutor matematika. Saat menjawab soal:
1. Baca soal dengan cermat
2. Identifikasi apa yang ditanyakan
3. Tuliskan langkah penyelesaian satu per satu
4. Berikan jawaban akhir"""

result = ask(system_cot, "Sebuah toko memberikan diskon 25% untuk barang seharga Rp 240.000. Berapa harga setelah diskon?", temp=0)
print(f"\n=== CHAIN OF THOUGHT ===\n{result}")

# ===== 3. JSON OUTPUT =====
system_json = """Kamu adalah ekstraktor informasi. Ekstrak informasi dari teks dan berikan dalam format JSON yang valid dengan key:
- nama_produk (string)
- harga (number, tanpa 'Rp')
- rating (number, 1-5)
- kategori (string)
- tersedia (boolean)"""

text_produk = "iPhone 15 Pro Max 256GB dengan harga Rp 19.999.000, rating 4.8/5 dari 1200 review, kategori Smartphone, stok masih ada"

result = ask(system_json, text_produk, temp=0)
print(f"\n=== JSON EXTRACTION ===\n{result}")

5. Embeddings API

Embeddings adalah representasi teks dalam bentuk vektor numerik berdimensi tinggi. Vektor ini menangkap makna semantik teks — teks dengan makna mirip akan memiliki vektor yang berdekatan. Embeddings sangat berguna untuk pencarian semantik, clustering, dan rekomendasi.

Cara Kerja Embeddings

Teks	Vektor (simplified)	Keterangan
"Python adalah bahasa pemrograman"	[0.8, 0.2, -0.1, ...]	Terkait coding
"Java adalah bahasa programming"	[0.7, 0.2, -0.2, ...]	Mirip dengan di atas
"Resep nasi goreng"	[-0.1, 0.9, 0.3, ...]	Terkait masakan, jauh dari coding

Python — Embeddings API

from openai import OpenAI
import numpy as np
client = OpenAI()

def get_embedding(text, model="text-embedding-3-small"):
    """Dapatkan embedding untuk satu teks."""
    response = client.embeddings.create(
        input=text,
        model=model
    )
    return response.data[0].embedding

def cosine_similarity(a, b):
    """Hitung cosine similarity antara dua vektor."""
    a, b = np.array(a), np.array(b)
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# ===== CONTOH: SEMANTIC SEARCH =====
# Database dokumen
documents = [
    "Python adalah bahasa pemrograman populer untuk data science",
    "JavaScript digunakan untuk web development frontend dan backend",
    "Machine Learning membutuhkan data yang berkualitas untuk training",
    "Deep Learning menggunakan neural network dengan banyak layer",
    "Resep nasi goreng sederhana dan enak untuk makan malam",
    "Cara membuat kopi susu kekinian ala cafe",
    "Panduan belajar PyTorch untuk pemula dalam deep learning",
    "Tips meningkatkan performa website dengan optimasi database",
]

# Generate embeddings untuk semua dokumen
print("Generating embeddings...")
doc_embeddings = [get_embedding(doc) for doc in documents]

# Query pencarian
query = "bagaimana cara belajar AI dan machine learning"
query_embedding = get_embedding(query)

# Hitung similarity
print(f"\nQuery: \"{query}\"")
print(f"\nHasil pencarian (diurutkan berdasarkan relevansi):")
similarities = []
for i, (doc, emb) in enumerate(zip(documents, doc_embeddings)):
    sim = cosine_similarity(query_embedding, emb)
    similarities.append((sim, i, doc))

similarities.sort(reverse=True)
for rank, (sim, idx, doc) in enumerate(similarities[:5], 1):
    print(f"  {rank}. [{sim:.4f}] {doc}")

Embedding Models

Model	Dimensi	Keunggulan	Harga
text-embedding-3-small	1536	🟢 Murah, cepat, bagus untuk banyak kasus	$0.02 / 1M tokens
text-embedding-3-large	3072	Kualitas lebih tinggi	$0.13 / 1M tokens

6. Function Calling

Function Calling memungkinkan model GPT untuk memanggil fungsi yang Anda definisikan sebagai respons. Ini sangat powerful untuk menghubungkan AI dengan sistem eksternal — database, API, kalkulator, dan lainnya.

Python — Function Calling

from openai import OpenAI
import json
client = OpenAI()

# ===== 1. DEFINISIKAN FUNGSI YANG TERSEDIA =====
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Dapatkan informasi cuaca saat ini untuk lokasi tertentu",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Nama kota, contoh: Jakarta, Bandung"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Satuan suhu"
                    }
                },
                "required": ["location"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_products",
            "description": "Cari produk di database e-commerce",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Kata kunci pencarian produk"
                    },
                    "max_price": {
                        "type": "number",
                        "description": "Harga maksimum dalam Rupiah"
                    },
                    "category": {
                        "type": "string",
                        "description": "Kategori produk"
                    }
                },
                "required": ["query"]
            }
        }
    }
]

# ===== 2. IMPLEMENTASI FUNGSI =====
def get_weather(location, unit="celsius"):
    """Simulasi fungsi cuaca (di dunia nyata, panggil API cuaca)"""
    # Simulasi response
    weather_data = {
        "Jakarta": {"temp": 32, "condition": "Cerah berawan", "humidity": 75},
        "Bandung": {"temp": 24, "condition": "Hujan ringan", "humidity": 85},
        "Surabaya": {"temp": 34, "condition": "Panas terik", "humidity": 60},
    }
    data = weather_data.get(location, {"temp": 28, "condition": "Tidak diketahui", "humidity": 70})
    if unit == "fahrenheit":
        data["temp"] = data["temp"] * 9/5 + 32
    return json.dumps(data)

def search_products(query, max_price=None, category=None):
    """Simulasi pencarian produk"""
    products = [
        {"name": "Laptop ASUS VivoBook", "price": 8500000, "category": "Elektronik"},
        {"name": "iPhone 15 Pro", "price": 19999000, "category": "Elektronik"},
        {"name": "Sepatu Nike Air Max", "price": 1500000, "category": "Fashion"},
    ]
    results = [p for p in products if query.lower() in p["name"].lower()]
    if max_price:
        results = [p for p in results if p["price"] <= max_price]
    return json.dumps(results)

# ===== 3. CONVERSATION DENGAN FUNCTION CALLING =====
messages = [
    {"role": "system", "content": "Kamu adalah asisten yang membantu dengan informasi cuaca dan pencarian produk. Jawab dalam Bahasa Indonesia."},
    {"role": "user", "content": "Cuaca di Jakarta hari ini bagaimana? Dan carikan laptop di bawah 10 juta."}
]

# Kirim ke model
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

# Cek apakah model ingin memanggil fungsi
assistant_msg = response.choices[0].message

if assistant_msg.tool_calls:
    print("Model ingin memanggil fungsi:")
    for tool_call in assistant_msg.tool_calls:
        func_name = tool_call.function.name
        func_args = json.loads(tool_call.function.arguments)
        print(f"  → {func_name}({func_args})")

        # Panggil fungsi yang sebenarnya
        if func_name == "get_weather":
            result = get_weather(**func_args)
        elif func_name == "search_products":
            result = search_products(**func_args)
        else:
            result = '{"error": "Function not found"}"

        # Tambahkan hasil ke messages
        messages.append(assistant_msg)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": result
        })
        print(f"    Result: {result}")

    # Minta model generate final response
    final_response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
        tools=tools
    )
    print(f"\nFinal Response:\n{final_response.choices[0].message.content}")
else:
    print(f"Direct response: {assistant_msg.content}")

7. Fine-tuning

Fine-tuning adalah proses melatih model GPT dengan data khusus Anda untuk tugas spesifik. Ini berguna ketika prompt engineering tidak cukup — misalnya, jika Anda ingin model selalu merespons dengan format, gaya, atau domain tertentu.

Kapan Perlu Fine-tuning?

Situasi	Perlu Fine-tuning?	Alternatif
Ingin respons dengan format khusus	🟡 Coba prompt dulu	Structured output / JSON mode
Domain sangat spesifik (medis, hukum)	✅ Ya	RAG (Retrieval Augmented Generation)
Gaya penulisan konsisten	✅ Ya	Few-shot prompting
Mengurangi hallucination	🟡 Bantu	RAG + system prompt ketat
Klasifikasi sederhana	❌ Tidak perlu	Embeddings + classifier

Python — Fine-tuning OpenAI

from openai import OpenAI
import json
client = OpenAI()

# ===== 1. SIAPKAN DATA TRAINING =====
# Format: JSONL dengan messages
training_data = [
    {
        "messages": [
            {"role": "system", "content": "Kamu adalah customer service ramah untuk toko elektronik BeebaneStore."},
            {"role": "user", "content": "Laptop saya rusak, baru beli 2 hari yang lalu!"},
            {"role": "assistant", "content": "Mohon maaf atas ketidaknyamanan yang dialami. Untuk produk yang baru dibeli kurang dari 7 hari, Anda berhak mendapatkan penggantian unit baru. Silakan bawa laptop beserta nota pembelian ke cabang terdekat, atau hubungi hotline kami di 0800-1234-5678 untuk bantuan pickup. Apakah ada hal lain yang bisa saya bantu?"}
        ]
    },
    {
        "messages": [
            {"role": "system", "content": "Kamu adalah customer service ramah untuk toko elektronik BeebaneStore."},
            {"role": "user", "content": "Berapa lama garansi HP Samsung Galaxy S24?"},
            {"role": "assistant", "content": "Samsung Galaxy S24 di BeebaneStore dilengkapi dengan garansi resmi Samsung Indonesia selama 1 tahun untuk perangkat dan 6 bulan untuk aksesoris. Anda juga bisa menambahkan garansi perpanjangan 1 tahun tambahan dengan biaya Rp 500.000 saat pembelian. Apakah Anda tertarik dengan produk ini?"}
        ]
    },
    # ... tambahkan minimal 10-50 contoh untuk hasil yang baik
]

# Simpan ke file JSONL
with open('training_data.jsonl', 'w') as f:
    for item in training_data:
        f.write(json.dumps(item) + '\n')

print(f"Training data: {len(training_data)} contoh")
print("File saved: training_data.jsonl")

# ===== 2. UPLOAD TRAINING FILE =====
# Uncomment untuk menjalankan:

# training_file = client.files.create(
#     file=open('training_data.jsonl', 'rb'),
#     purpose='fine-tune'
# )
# print(f"File uploaded: {training_file.id}")

# ===== 3. MULAI FINE-TUNING =====
# job = client.fine_tuning.jobs.create(
#     training_file=training_file.id,
#     model="gpt-4o-mini-2024-07-18",
#     hyperparameters={
#         "n_epochs": 3,
#         "batch_size": "auto",
#         "learning_rate_multiplier": "auto"
#     },
#     suffix="beebane-cs"  # Nama model custom
# )
# print(f"Fine-tuning job: {job.id}")

# ===== 4. MONITOR PROGRESS =====
# status = client.fine_tuning.jobs.retrieve(job.id)
# print(f"Status: {status.status}")
# events = client.fine_tuning.jobs.list_events(job.id)
# for event in events.data[:5]:
#     print(f"  {event.message}")

# ===== 5. GUNAKAN MODEL HASIL FINE-TUNING =====
# response = client.chat.completions.create(
#     model="ft:gpt-4o-mini-2024-07-18:org:beebane-cs:xxxxx",
#     messages=[
#         {"role": "system", "content": "Kamu adalah customer service ramah untuk toko elektronik BeebaneStore."},
#         {"role": "user", "content": "Barang yang saya terima cacat!"}
#     ]
# )
# print(response.choices[0].message.content)

Tips Fine-tuning

Tips	Penjelasan
Minimal 10 contoh	Lebih banyak = lebih baik. 50-100 contoh untuk perbedaan signifikan
Konsistensi format	Semua data harus menggunakan format yang sama persis
Validasi	Sisihkan 10-20% data untuk validasi (test set)
Evaluasi	Bandingkan performa sebelum dan sesudah fine-tuning
Biaya	Fine-tuning bayar per token training. Mulai dari dataset kecil dulu