pip install openai python-dotenv requests

OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxxxxxxxxxx
WHATSAPP_TOKEN=token_dari_provider
WHATSAPP_PHONE_ID=phone_id_dari_meta

from openai import OpenAI
import os
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Kamu adalah customer service toko online yang ramah."},
        {"role": "user", "content": "Halo, apakah stoknya masih ada?"}
    ]
)

print(response.choices[0].message.content)

SYSTEM_PROMPT = """
Kamu adalah customer service dari Toko Gadget Murah, toko online yang jual 
aksesoris HP dan gadget. 

INFO TOKO:
- Jam buka: 09:00 - 21:00 WIB
- Lokasi: Jakarta Selatan
- Ongkir Jakarta: Rp 8.000 (Regular), Rp 12.000 (Instant)
- Ongkir luar Jakarta: sesuai JNE calculator
- Payment: QRIS, BCA, Mandiri, GoPay, OVO, DANA
- Return policy: 7 hari jika barang cacat
- Garansi: 1 bulan untuk aksesoris, 1 tahun untuk gadget

ATURAN:
1. Jawab dengan ramah, singkat, dan jelas
2. Jika ditanya stok dan kamu tidak tahu pasti, katakan: 
   "Untuk cek stok real-time, mohon tunggu admin kami balas ya kak 😊"
3. Jika ditanya hal di luar info toko, arahkan ke admin
4. Selalu pakai bahasa Indonesia santai
5. Jangan janji yang tidak bisa dipenuhi
6. Jika customer marah/complain serius, arahkan ke admin human
"""

from openai import OpenAI
import os
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Simpan riwayat percakapan per nomor customer
chat_history = {}

def generate_reply(phone_number: str, incoming_message: str) -> str:
    """Generate AI reply berdasarkan pesan masuk."""

    # Ambil atau init history chat
    if phone_number not in chat_history:
        chat_history[phone_number] = []

    # Tambah pesan customer ke history
    chat_history[phone_number].append({
        "role": "user",
        "content": incoming_message
    })

    # Batasi history ke 10 pesan terakhir (hemat token)
    recent_history = chat_history[phone_number][-10:]

    # Call OpenAI API
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT}
        ] + recent_history,
        max_tokens=200,
        temperature=0.7
    )

    reply = response.choices[0].message.content

    # Simpan reply AI ke history
    chat_history[phone_number].append({
        "role": "assistant",
        "content": reply
    })

    return reply

import requests
import os
from dotenv import load_dotenv

load_dotenv()

FONNTE_TOKEN = os.getenv("FONNTE_TOKEN")

def send_whatsapp_message(phone: str, message: str):
    """Kirim pesan WhatsApp via Fonnte API."""

    url = "https://api.fonnte.com/send"
    headers = {
        "Authorization": FONNTE_TOKEN
    }
    payload = {
        "target": phone,
        "message": message,
        "countryCode": "62"
    }

    response = requests.post(url, headers=headers, data=payload)
    return response.json()

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/webhook", methods=["POST"])
def webhook():
    """Terima pesan masuk dari WhatsApp."""

    data = request.json

    # Extract info (format tergantung provider)
    phone_number = data.get("sender")
    message = data.get("message")

    if not phone_number or not message:
        return jsonify({"status": "error"}), 400

    # Generate AI reply
    reply = generate_reply(phone_number, message)

    # Kirim balasan
    send_whatsapp_message(phone_number, reply)

    return jsonify({"status": "success"}), 200

if __name__ == "__main__":
    app.run(port=5000)

ngrok http 5000

def should_escalate_to_human(message: str, ai_reply: str) -> bool:
    """Cek apakah perlu eskalasi ke admin human."""

    escalation_keywords = [
        "komplain", "marah", "rusak", "refund", "scam",
        "manager", "admin", "manusia", "bukan bot"
    ]

    message_lower = message.lower()
    return any(keyword in message_lower for keyword in escalation_keywords)

@app.route("/webhook", methods=["POST"])
def webhook():
    data = request.json
    phone_number = data.get("sender")
    message = data.get("message")

    reply = generate_reply(phone_number, message)

    if should_escalate_to_human(message, reply):
        # Kirim notifikasi ke admin
        send_whatsapp_message(
            "6281234567890",  # nomor admin
            f"🚨 Eskalasi dari {phone_number}:\n\nPesan: {message}\n\nAI Reply: {reply}"
        )
        # Tetap kirim AI reply ke customer, tapi kasih tau admin akan follow up
        reply += "\n\n_Admin kami akan segera follow up pertanyaan kakak ya 😊_"

    send_whatsapp_message(phone_number, reply)
    return jsonify({"status": "success"}), 200

FAQ_CACHE = {
    "jam buka": "Jam buka kami 09:00 - 21:00 WIB kak 😊",
    "lokasi": "Kami di Jakarta Selatan kak. Bisa COD di area itu ya.",
    "payment": "Kami terima QRIS, BCA, Mandiri, GoPay, OVO, DANA kak."
}

def check_faq_cache(message: str) -> str | None:
    message_lower = message.lower()
    for keyword, answer in FAQ_CACHE.items():
        if keyword in message_lower:
            return answer
    return None

import logging
from datetime import datetime

logging.basicConfig(
    filename="whatsapp_bot.log",
    level=logging.INFO,
    format="%(asctime)s - %(message)s"
)

# Di fungsi webhook
logging.info(f"From: {phone_number} | Message: {message} | Reply: {reply}")