Prompt Engineering Advanced — Chain-of-Thought, Few-Shot, Self-Consistency, Tree-of-Thought, ReAct

# =============================================
# Zero-Shot Prompting
# =============================================
from openai import OpenAI
client = OpenAI()

# Contoh 1: Zero-shot sederhana (buruk)
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "Klasifikasikan sentiment dari: 'Produk ini bagus sekali!'"}
    ]
)
# Output: "Positif"  ← Cukup baik untuk tugas sederhana

# Contoh 2: Zero-shot dengan role & instruksi (lebih baik)
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": """Anda adalah analis sentimen profesional.
Klasifikasikan teks ke dalam salah satu kategori:
- Positif
- Negatif
- Netral

Berikan jawaban dalam format:
Kategori: [kategori]
Confidence: [tinggi/sedang/rendah]
Alasan: [alasan singkat]"""},
        {"role": "user", "content": "Produk ini bagus sekali!"}
    ]
)
# Output lebih terstruktur dan informatif!

# =============================================
# Few-Shot Prompting
# =============================================

# Contoh 1: Few-shot klasifikasi
few_shot_prompt = """Klasifikasikan sentimen dari ulasan pelanggan.

Contoh:
Ulasan: "Pengiriman cepat, produk sesuai deskripsi!"
Sentimen: Positif

Ulasan: "Barang rusak saat sampai, sangat kecewa."
Sentimen: Negatif

Ulasan: "Biasa saja, tidak ada yang istimewa."
Sentimen: Netral

Sekarang klasifikasikan:
Ulasan: "Kualitas bagus tapi harga terlalu mahal untuk ukuran segitu."
Sentimen:"""

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": few_shot_prompt}]
)

# Contoh 2: Few-shot untuk ekstraksi informasi
extraction_prompt = """Ekstrak informasi dari teks berikut ke format JSON.

Contoh 1:
Teks: "John, usia 25 tahun, bekerja di Google sebagai Software Engineer di Mountain View."
Output: {"nama": "John", "usia": 25, "perusahaan": "Google", "posisi": "Software Engineer", "lokasi": "Mountain View"}

Contoh 2:
Teks: "Sarah, 30 tahun, Data Scientist di Tokopedia, Jakarta."
Output: {"nama": "Sarah", "usia": 30, "perusahaan": "Tokopedia", "posisi": "Data Scientist", "lokasi": "Jakarta"}

Sekarang ekstrak:
Teks: "Budi, 28 tahun, Backend Engineer di Gojek, berlokasi di Jakarta Selatan."
Output:"""

# Contoh 3: Few-shot untuk code generation
code_prompt = """Ubah deskripsi menjadi Python function.

Contoh:
Deskripsi: "Fungsi untuk menghitung luas lingkaran dari jari-jari"
```python
import math
def luas_lingkaran(r):
    return math.pi * r ** 2
```

Contoh:
Deskripsi: "Fungsi untuk cek apakah bilangan prima"
```python
def is_prima(n):
    if n < 2: return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0: return False
    return True
```

Sekarang buat:
Deskripsi: "Fungsi untuk menghitung BMI dari berat(kg) dan tinggi(m)"
```python"""

# =============================================
# Chain-of-Thought (CoT) Prompting
# =============================================

# ----- Zero-Shot CoT -----
# Cukup tambahkan "Let's think step by step"
cot_zero_shot = """Sebuah toko punya 150 apel. Hari pertama terjual 40%, 
hari kedua terjual sisa 30%. Berapa apel yang tersisa?

Mari kita pikirkan langkah demi langkah."""

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": cot_zero_shot}]
)
# LLM akan menjawab:
# 1. Hari pertama: 150 × 40% = 60 terjual, sisa 90
# 2. Hari kedua: 90 × 30% = 27 terjual, sisa 63
# Jawaban: 63 apel

# ----- Few-Shot CoT (dengan contoh reasoning) -----
cot_few_shot = """Jawab soal matematika berikut dengan menunjukkan langkah penyelesaian.

Contoh:
Soal: Jika 5 orang bisa menyelesaikan pekerjaan dalam 10 hari, berapa hari jika 10 orang?
Pikirkan: Semakin banyak orang, semakin sedikit hari. Ini proporsi terbalik.
Langkah: 5 × 10 = 10 orang × x hari → x = 50/10 = 5 hari
Jawaban: 5 hari

Sekarang:
Soal: Sebuah kolam bisa diisi oleh pipa A dalam 6 jam dan pipa B dalam 4 jam. Jika keduanya dibuka bersamaan, berapa jam untuk mengisi penuh?
Pikirkan:"""

# ----- CoT dengan XML Tags (struktur lebih jelas) -----
cot_structured = """Anda adalah matematikawan. Selesaikan soal berikut.


Sebuah mobil berangkat dari A ke B (jarak 240 km) dengan kecepatan 60 km/jam. 
Setelah 2 jam, kecepatan ditambah 20 km/jam. Berapa total waktu perjalanan?



Analisis soal langkah demi langkah:
1. Identifikasi apa yang diketahui dan ditanya
2. Hitung jarak tempuh di fase pertama
3. Hitung sisa jarak
4. Hitung waktu untuk sisa jarak
5. Totalkan


"""

# =============================================
# Self-Consistency Prompting
# =============================================
from collections import Counter

def self_consistency(client, question, n_samples=5):
    """
    Generate n_samples jawaban dengan CoT, 
    pilih jawaban yang paling konsisten (mayoritas).
    """
    prompt = f"""{question}

Pikirkan langkah demi langkah, lalu berikan jawaban akhir 
di baris terakhir dengan format: "Jawaban: [jawaban Anda]"
"""
    
    answers = []
    reasonings = []
    
    for i in range(n_samples):
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.7,  # Harus > 0 untuk variasi
        )
        
        text = response.choices[0].message.content
        reasonings.append(text)
        
        # Extract jawaban akhir
        if "Jawaban:" in text:
            answer = text.split("Jawaban:")[-1].strip()
            answers.append(answer)
    
    # Majority voting
    answer_counts = Counter(answers)
    most_common = answer_counts.most_common(1)[0]
    
    return {
        "final_answer": most_common[0],
        "confidence": f"{most_common[1]}/{n_samples}",
        "all_answers": answers,
        "all_reasonings": reasonings
    }

# Contoh penggunaan
result = self_consistency(
    client,
    "Sebuah lift kapasitas 500kg. Ada 3 orang (70kg, 80kg, 90kg) "
    "dan 10 kardus masing-masing 25kg. Apakah semua bisa masuk?",
    n_samples=5
)
print(f"Jawaban: {result['final_answer']}")
print(f"Confidence: {result['confidence']}")
# Jawaban: Tidak, total 600kg > 500kg
# Confidence: 5/5 ← sangat yakin!

# =============================================
# Tree-of-Thought (ToT) — Simplified
# =============================================

def tree_of_thought(client, problem, n_branches=3):
    """
    Implementasi ToT sederhana:
    1. Generate multiple jalur pemikiran
    2. Evaluasi setiap jalur
    3. Pilih yang terbaik
    """
    
    # Step 1: Generate multiple approaches
    branch_prompt = f"""Masalah: {problem}

Pikirkan {n_branches} pendekatan berbeda untuk menyelesaikan masalah ini.
Untuk setiap pendekatan:
1. Jelaskan strategi
2. Tunjukkan langkah penyelesaian
3. Berikan jawaban

Format output:
## Pendekatan 1: [nama strategi]
[langkah-langkah]
Jawaban: [jawaban]

## Pendekatan 2: [nama strategi]
..."""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "Anda adalah problem solver ahli."},
            {"role": "user", "content": branch_prompt}
        ],
        temperature=0.8
    )
    
    approaches = response.choices[0].message.content
    
    # Step 2: Evaluate & pick best
    eval_prompt = f"""Berikut beberapa pendekatan untuk menyelesaikan masalah:

Masalah: {problem}

Pendekatan yang dihasilkan:
{approaches}

Evaluasi setiap pendekatan:
1. Apakah logikanya benar?
2. Apakah ada kesalahan perhitungan?
3. Apakah ada edge case yang terlewat?

Pilih pendekatan terbaik dan berikan jawaban final yang pasti."""

    final_response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "Anda adalah evaluator yang kritis dan teliti."},
            {"role": "user", "content": eval_prompt}
        ],
        temperature=0.2  # Rendah untuk jawaban final yang konsisten
    )
    
    return final_response.choices[0].message.content

# Contoh
result = tree_of_thought(
    client,
    "Ada 100 tahanan dan 100 kunci. Setiap tahanan bisa membuka kunci "
    "secara acak. Berapa probabilitas minimal SATU tahanan menemukan "
    "kuncinya sendiri?"
)

# =============================================
# ReAct Pattern dengan LangChain
# =============================================
from langchain_openai import ChatOpenAI
from langchain.agents import tool, AgentExecutor, create_react_agent
from langchain import hub

# Definisikan tools
@tool
def search_knowledge_base(query: str) -> str:
    """Mencari informasi dari knowledge base perusahaan."""
    # Di production, ini akan query vector DB
    knowledge = {
        "refund": "Kebijakan refund: pengembalian dalam 7 hari, syarat kemasan utuh.",
        "pengiriman": "Waktu pengiriman: 2-3 hari Jawa, 5-7 hari luar Jawa.",
        "garansi": "Garansi produk 1 tahun, claim via email support@beebane.com"
    }
    for key, value in knowledge.items():
        if key in query.lower():
            return value
    return "Informasi tidak ditemukan di knowledge base."

@tool
def calculate(expression: str) -> str:
    """Menghitung ekspresi matematika."""
    try:
        return str(eval(expression))
    except:
        return "Error: ekspresi tidak valid"

@tool  
def get_current_date() -> str:
    """Mendapatkan tanggal hari ini."""
    from datetime import datetime
    return datetime.now().strftime("%d %B %Y, %H:%M WIB")

# Setup ReAct Agent
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
prompt = hub.pull("hwchase17/react")
agent = create_react_agent(llm, [search_knowledge_base, calculate, get_current_date], prompt)

agent_executor = AgentExecutor(
    agent=agent,
    tools=[search_knowledge_base, calculate, get_current_date],
    verbose=True,
    handle_parsing_errors=True,
    max_iterations=5
)

# Jalankan agent
result = agent_executor.invoke({
    "input": "Saya mau tanya, kalau saya beli produk kemarin dan mau refund, "
             "sampai kapan batas waktunya?"
})
print(result["output"])

# =============================================
# Structured Output — JSON Mode dengan Pydantic
# =============================================
from pydantic import BaseModel
from openai import OpenAI

client = OpenAI()

class ProductReview(BaseModel):
    sentiment: str        # "positif" | "negatif" | "netral"
    rating: int           # 1-5
    summary: str          # Ringkasan singkat
    keywords: list[str]   # Kata kunci
    confidence: float     # 0-1

# Gunakan response_format untuk JSON
response = client.beta.chat.completions.parse(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Analisis ulasan produk dan berikan output terstruktur."},
        {"role": "user", "content": "Produk ini sangat bagus! Pengiriman cepat, "
         "kemasan rapi. Sayang harganya agak mahal. Rating 4/5 lah."}
    ],
    response_format=ProductReview
)

review = response.choices[0].message.parsed
print(f"Sentiment: {review.sentiment}")
print(f"Rating: {review.rating}")
print(f"Summary: {review.summary}")
print(f"Keywords: {review.keywords}")

# System Prompt Patterns
system_prompts = {
    "persona": """Anda adalah Dr. AI, asisten medis yang berpengalaman 20 tahun.
Selalu berikan disclaimer bahwa ini bukan pengganti konsultasi dokter.
Gunakan bahasa yang mudah dipahami pasien.""",

    "constraint": """ATURAN KETAT:
1. Hanya jawab pertanyaan tentang programming
2. Jangan berikan saran investasi atau medis
3. Selalu sertakan contoh kode
4. Jika tidak tahu, katakan tidak tahu""",

    "output_format": """Format jawaban SELALU:
## Ringkasan
[1-2 kalimat]

## Penjelasan Detail
[paragraf]

## Contoh Kode
```python
[code]
```

## Referansi
[link atau sumber]"
"""
}