Belajar AI - AI Applications & Integration (API)

#Pendahuluan

Setelah di episode 13 kalian membangun pipeline RAG yang memindai dokumen dan menjawab dengan konteks, episode ini menutup kesenjangan terakhir: menghubungkan AI ke aplikasi kalian. RAG yang hebat tidak berguna jika tidak bisa dipanggil dari backend, mobile app, atau web app dengan API yang aman dan cepat.

Mengapa episode ini penting? Karena ini titik di mana "eksperimen notebook" menjadi "produk". Kalian akan belajar pola yang sama yang dipakai aplikasi AI di dunia nyata: memanggil model lewat API, mendapatkan output JSON yang bisa diproses program, memberikan kemampuan model memanggil fungsi kalian, dan streaming jawaban agar pengalaman pengguna terasa responsif.

#OpenAI-Compatible API

Pada 2026, hampir semua penyedia model — OpenAI, Anthropic (Claude), Google (Gemini), serta open-source (Ollama, vLLM) — menyediakan API dengan format OpenAI-compatible. Satu pola request chat/completions bisa dipakai untuk semua penyedia:

curl https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [
      {"role": "system", "content": "Kamu adalah asisten yang membantu."},
      {"role": "user", "content": "Apa itu RAG dalam satu kalimat?"}
    ]
  }'

Pola messages dengan peran system/user/assistant adalah kontrak universal: system menetapkan perilaku, user adalah permintaan, assistant adalah riwayat jawaban model. Dengan SDK Python:

from openai import OpenAI
 
client = OpenAI()   # membaca OPENAI_API_KEY dari env
 
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Jawab singkat dan jelas."},
        {"role": "user", "content": "Apa itu RAG?"},
    ],
)
print(response.choices[0].message.content)

#Praktik Amannya API Key

API key adalah kunci gerbang ke saldo kalian — bocor berarti uang keluar. Aturan wajib:

1. Simpan di environment variable / secret manager, jangan di kode.
2. Jangan pernah commit ke git; gunakan .env yang di-gitignore.
3. Di sisi frontend, jangan pernah memanggil LLM langsung dengan key — selalu lewat backend yang membatasi quota.

export OPENAI_API_KEY="sk-..."

#Structured Output (JSON)

LLM mengembalikan teks — tetapi aplikasi butuh data terstruktur. Structured output membuat model mengembalikan JSON yang valid sesuai skema yang kalian definisikan:

from pydantic import BaseModel
 
class Review(BaseModel):
    sentiment: str          # "positif" | "negatif" | "netral"
    score: int              # 1-5
    reasons: list[str]
 
completion = client.beta.chat.completions.parse(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": "Analisis: 'Produk bagus tapi pengiriman lambat'."}
    ],
    response_format=Review,
)
review = completion.choices[0].message.parsed
print(review.score, review.sentiment)

Dengan skema (Pydantic), model dijamin menghasilkan JSON yang cocok — dan kesalahan parsing terdeteksi otomatis. Pola ini menggantikan "regex untuk mem-parsing jawaban LLM" yang rapuh.

#Function / Tool Calling

Tool calling adalah kemampuan model memutuskan untuk memanggil fungsi yang kalian sediakan. Inilah fondasi agents (episode 15): model tidak hanya menjawab, ia bisa mengambil tindakan — query database, memanggil API, menghitung.

Alurnya dua langkah:

1. Definisikan fungsi dalam skema tool.
2. Loop: model meminta panggilan tool → kalian jalankan → hasilnya dikembalikan ke model → model menjawab.

tools = [{
    "type": "function",
    "function": {
        "name": "get_balance",
        "description": "Mengambil saldo akun pengguna.",
        "parameters": {
            "type": "object",
            "properties": {"account_id": {"type": "string"}},
            "required": ["account_id"],
        },
    },
}]
 
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Berapa saldo akun 12345?"}],
    tools=tools,
)
 
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name, tool_call.function.arguments)

Model tidak mengeksekusi apa pun sendiri — ia hanya meminta panggilan; eksekusi tetap di tangan kode kalian. Prinsip ini penting untuk keamanan (episode 16): model tidak pernah punya akses langsung; kalian yang memutuskan izin.

#Membangun Chatbot/Copilot dengan Streaming

#Streaming: Mengetik Saat Menjawab

Tanpa streaming, user menunggu seluruh jawaban selesai (detik-detik) dengan layar kosong. Dengan streaming, jawaban muncul token demi token — terasa instan dan lebih manusiawi.

def stream_chat(messages):
    stream = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
        stream=True,
    )
    for chunk in stream:
        delta = chunk.choices[0].delta.content
        if delta:
            yield delta
 
# backend: terima request -> stream ke client (SSE)
for token in stream_chat(history):
    print(token, end="", flush=True)

Pola produksinya adalah Server-Sent Events (SSE) atau WebSocket: backend mem-stream token ke frontend, frontend menampilkannya real-time. Ini standar de facto untuk semua chatbot 2026.

#Riwayat dan Konteks

Stateless API berarti setiap request tidak ingat percakapan. Kalian yang menyimpan message history (di database/session) dan mengirimnya kembali sebagai messages — termasuk ringkasan (summarization) saat percakapan panjang melebihi context window. Batasi history agar token tidak membengkak:

history = history[-10:]  # simpan 10 pesan terakhir

#Common Pitfalls

• API key di frontend: bocor ke siapa saja yang buka DevTools; selalu lewat backend.
• Tanpa structured output: parsing jawaban LLM dengan regex = rapuh.
• Mengirim seluruh riwayat tanpa batas: biaya token membengkak, model kehilangan fokus.
• Tool calling tanpa validasi izin: pastikan fungsi yang dipanggil tidak berbahaya dan argumennya divalidasi.
• Tanpa error handling: API bisa timeout/rate-limit; siapkan retry dan pesan fallback.

#Penutup

Inti yang harus dibawa pulang:

• Semua penyedia model 2026 punya API OpenAI-compatible — satu pola chat/completions untuk semua.
• Structured output (JSON schema) mengubah jawaban LLM menjadi data program yang andal.
• Tool calling memberi model kemampuan bertindak — tetapi eksekusi & izin tetap di tangan kode kalian.
• Streaming (SSE/WebSocket) membuat aplikasi AI terasa responsif; simpan riwayat pesan dengan batas yang wajar.

Di episode 15 selanjutnya kita naik level ke AI Agents & Tool Use — agent loop (perceive → think → act), tool-calling, multi-agent, dan framework seperti LangChain/LangGraph, LlamaIndex, serta MCP untuk menghubungkan AI ke tools dan data. Sampai jumpa di episode 15!