OpenAI API: Panduan Developer

# Instalasi Python SDK
pip install openai

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

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)

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}")

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}")

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 ---")

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}")

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}")

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}")

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)