AI Engineering Academy · Pelajaran

Anggaran Batas Waktu dan Penurunan Layanan yang Terkendali

Anggaran Batas Waktu dan Penurunan Layanan yang Terkendali adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Engineering Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Apa Itu Anggaran Batas Waktu?

Anggaran batas waktu adalah waktu total maksimum yang dialokasikan agar sebuah permintaan selesai di seluruh tahapan alur kerja Anda. Alih-alih menetapkan batas waktu sembarang untuk setiap panggilan API, Anda menentukan anggaran menyeluruh untuk operasi yang dihadapi pengguna, lalu membaginya ke tahapan pengambilan, pembuatan oleh LLM, dan pemrosesan pascapembuatan. Dengan demikian, Anda selalu merespons dalam waktu yang dapat diterima, meskipun beberapa tahapan berjalan lambat.

Membagi Anggaran di Seluruh Tahapan Alur Kerja

Alur kerja percakapan RAG biasanya memiliki tiga tahapan: pengambilan, pembuatan oleh LLM, dan pemformatan respons. Tetapkan jatah waktu untuk masing-masing berdasarkan durasi normalnya dan seberapa banyak kelonggaran yang dapat ditoleransi pengguna. Kelonggaran yang tersisa adalah penyangga penurunan kualitas — jika suatu tahapan menggunakan seluruh jatahnya, Anda mulai menyederhanakan tahapan berikutnya agar tetap berada dalam anggaran keseluruhan.

# Total user-facing SLA: 8000ms
BUDGET_TOTAL_MS = 8000

BUDGET_STAGES = {
    'retrieval':   1500,  # vector search + rerank
    'llm_call':    5500,  # token streaming
    'formatting':  500,   # post-processing
    'slack':       500,   # buffer for overhead
}

assert sum(BUDGET_STAGES.values()) == BUDGET_TOTAL_MS

Melacak Penggunaan Anggaran

Gunakan BudgetTracker yang mencatat waktu mulai dan memeriksa sisa anggaran pada setiap perpindahan tahapan. Sebelum memulai suatu tahapan, pastikan anggaran yang tersisa mencukupi. Dengan demikian, tahapan berikutnya dapat menyesuaikan diri — langkah pengambilan yang menggunakan 1200ms dari anggaran 1500ms hanya menyisakan kelonggaran 300ms, sehingga seharusnya memicu perintah LLM yang lebih sederhana atau melewati langkah pemeringkatan ulang.

import time

class BudgetTracker:
    def __init__(self, total_ms: float):
        self.start = time.perf_counter()
        self.total_ms = total_ms

    def elapsed_ms(self) -> float:
        return (time.perf_counter() - self.start) * 1000

    def remaining_ms(self) -> float:
        return self.total_ms - self.elapsed_ms()

    def check(self, stage: str, required_ms: float = 0) -> bool:
        remaining = self.remaining_ms()
        if remaining < required_ms:
            print(f'Budget exhausted before {stage}: {remaining:.0f}ms left, need {required_ms}ms')
            return False
        return True

Definisi Penurunan Kualitas Secara Anggun

Penurunan kualitas secara anggun berarti memberikan respons yang kualitasnya lebih rendah tetapi tetap berguna ketika alur kerja lengkap tidak dapat selesai dalam anggaran waktu, alih-alih mengembalikan kesalahan. Contohnya meliputi: mengembalikan respons yang tersimpan di tembolok, melewati pemeringkatan ulang, memotong jendela konteks, menggunakan model yang lebih cepat tetapi kurang akurat, atau mengembalikan pesan cadangan yang telah ditulis sebelumnya. Tujuannya selalu memberikan sesuatu kepada pengguna, bukan tidak memberikan apa pun.

# Degradation ladder for a RAG chat endpoint:
# Level 0 (normal):  retrieve 10 chunks + rerank + GPT-4o   -- 8000ms budget
# Level 1 (fast):    retrieve 5 chunks + skip rerank + GPT-4o -- 5000ms budget
# Level 2 (minimal): retrieve 3 chunks + GPT-4o-mini          -- 3000ms budget
# Level 3 (cached):  return semantic cache hit                 -- 100ms
# Level 4 (sorry):   return static 'Try again in a moment'    -- 1ms

Menerapkan Tangga Penurunan Kualitas

Pada setiap titik pengambilan keputusan dalam alur kerja, periksa sisa anggaran dan pilih tingkat kualitas yang sesuai. Kode di bawah ini memilih kedalaman pengambilan dan model berdasarkan sisa anggaran. Artinya, dalam beban normal pengguna mendapatkan kualitas terbaik, sedangkan selama periode latensi tinggi mereka tetap menerima respons yang berguna, bukan kesalahan batas waktu.

async def smart_rag_query(question: str, budget_ms: float = 8000) -> str:
    tracker = BudgetTracker(budget_ms)

    # Retrieval stage
    if tracker.remaining_ms() > 5000:
        chunks = await retrieve_and_rerank(question, top_k=10)
    elif tracker.remaining_ms() > 3000:
        chunks = await retrieve(question, top_k=5)  # skip rerank
    elif tracker.remaining_ms() > 1500:
        chunks = await retrieve(question, top_k=3)  # minimal retrieval
    else:
        return await get_cached_or_static(question)

    # LLM stage
    if tracker.remaining_ms() > 4000:
        model = 'gpt-4o'
    else:
        model = 'gpt-4o-mini'  # faster fallback

    timeout = tracker.remaining_ms() / 1000 - 0.5
    return await generate_answer(question, chunks, model, timeout)

Menetapkan Batas Waktu pada Tingkat Panggilan API

Selalu tetapkan batas waktu eksplisit pada setiap panggilan API eksternal. SDK Python OpenAI menerima parameter timeout dalam satuan detik. Tetapkan nilainya sedikit lebih kecil daripada anggaran yang tersisa agar Anda memiliki waktu untuk menangani pengecualian dan, jika perlu, menurunkan kualitas secara anggun sebelum batas waktu keseluruhan respons tercapai. Jangan pernah mengandalkan batas waktu bawaan SDK — nilainya mungkin terlalu lama untuk permintaan yang dihadapi pengguna.

async def generate_answer(question: str, chunks: list, model: str, timeout_sec: float) -> str:
    context = '\n\n'.join(chunks)
    prompt = f'Answer using this context:\n{context}\n\nQuestion: {question}'
    try:
        resp = await client.chat.completions.create(
            model=model,
            messages=[{'role': 'user', 'content': prompt}],
            max_tokens=500,
            timeout=max(timeout_sec, 1.0)  # minimum 1 second
        )
        return resp.choices[0].message.content
    except openai.APITimeoutError:
        return 'I was unable to generate a response in time. Please try again.'

Mengembalikan Respons Streaming Sebagian

Dengan streaming, Anda dapat mengembalikan respons sebagian yang telah dibuat sebelum anggaran waktu habis. Ketika batas waktu terjadi di tengah streaming, berhentilah membaca token baru, tambahkan elipsis atau perintah lanjutan singkat, lalu tutup streaming tersebut. Pengguna melihat respons yang terhenti dengan rapi, bukan kesalahan kosong. Hal ini hanya mungkin dilakukan dengan streaming — panggilan tanpa streaming bersifat sepenuhnya berhasil atau sepenuhnya gagal.

async def stream_with_budget(question: str, budget_ms: float):
    tracker = BudgetTracker(budget_ms)
    collected = []
    stream = await client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': question}],
        stream=True
    )
    async for chunk in stream:
        if tracker.remaining_ms() < 200:  # 200ms safety margin
            collected.append(' [response truncated]')
            break
        delta = chunk.choices[0].delta.content or ''
        collected.append(delta)
        yield delta
    # Ensure stream is closed even if budget exceeded
    await stream.close()

Tembolok Semantik sebagai Lapisan Penurunan Kualitas

Tembolok semantik merupakan lapisan penurunan kualitas yang sangat baik karena latensinya hampir nol. Sebelum memanggil LLM, kueri tembolok semantik Anda untuk mencari pertanyaan sebelumnya yang serupa. Jika ditemukan kecocokan tembolok dengan kemiripan tinggi (di atas kemiripan kosinus 0.92), segera kembalikan jawaban yang tersimpan di tembolok. Hal ini mempercepat respons sekaligus menyediakan cadangan seketika ketika LLM lambat atau tidak tersedia.

async def query_with_cache_fallback(question: str, budget_ms: float = 8000) -> str:
    # Try semantic cache first (fast)
    cached = await semantic_cache.lookup(question, threshold=0.92)
    if cached:
        return cached.response

    tracker = BudgetTracker(budget_ms)
    # Try full pipeline
    if tracker.remaining_ms() > 3000:
        try:
            return await smart_rag_query(question, tracker.remaining_ms())
        except Exception:
            pass  # fall through to static response

    # Last resort
    return 'I am experiencing high load right now. Please try again in a moment.'

Mencatat Peristiwa Penurunan Kualitas

Setiap kali alur kerja Anda turun ke tingkat kualitas yang lebih rendah, catatlah sebagai peristiwa terstruktur. Sertakan tingkat penurunan kualitas yang dicapai, sisa anggaran pada setiap tahapan, dan latensi akhir. Menganalisis catatan ini memberi tahu Anda seberapa sering setiap tingkat penurunan kualitas dipicu, sehingga membantu Anda menyetel anggaran, mengidentifikasi tahapan yang secara konsisten melampaui anggaran, dan memberikan dasar untuk investasi infrastruktur.

import structlog

log = structlog.get_logger()

def log_degradation(level: int, stage: str, remaining_ms: float, total_ms: float):
    log.warning(
        'pipeline_degradation',
        degradation_level=level,
        triggered_at_stage=stage,
        remaining_budget_ms=round(remaining_ms),
        total_budget_ms=total_ms,
        budget_consumed_pct=round((total_ms - remaining_ms) / total_ms * 100)
    )

Menetapkan Ekspektasi Pengguna dengan Sinyal Antarmuka

Saat memberikan respons yang kualitasnya diturunkan, beri tahu pengguna bahwa kualitasnya mungkin lebih rendah daripada biasanya. Untuk antarmuka percakapan, tampilkan indikator halus seperti 'Mode respons cepat — beberapa detail mungkin terbatas.' Untuk API ekstraksi, sertakan bidang degraded: true dalam respons JSON agar konsumen berikutnya dapat menangani hasil yang kualitasnya diturunkan secara berbeda. Transparansi menjaga kepercayaan pengguna bahkan saat terjadi gangguan.

from pydantic import BaseModel
from typing import Optional

class ChatResponse(BaseModel):
    content: str
    degraded: bool = False
    degradation_level: Optional[int] = None  # 0=full, 1=fast, 2=minimal, 3=cached
    latency_ms: int

# API response when degraded:
# {
#   'content': 'Here is a brief answer...',
#   'degraded': true,
#   'degradation_level': 2,
#   'latency_ms': 2800
# }

Menyetel Alokasi Anggaran Seiring Waktu

Alokasi anggaran awal hanyalah perkiraan. Setelah berjalan di lingkungan produksi selama seminggu, analisis distribusi waktu yang dihabiskan pada setiap tahapan menggunakan data pelacakan Anda. Jika pengambilan secara konsisten memerlukan 800ms, bukan 1500ms yang dianggarkan, alokasikan kembali kelonggaran tersebut ke tahapan LLM agar lebih banyak token keluaran atau jendela konteks yang lebih besar dapat digunakan. Penyetelan anggaran adalah kegiatan operasional yang berkelanjutan, bukan konfigurasi satu kali.

# Budget tuning based on production p95 data:
ACTUAL_P95 = {
    'retrieval': 780,    # vs budget 1500ms -> 720ms headroom
    'llm_call':  4200,   # vs budget 5500ms -> 1300ms headroom
    'formatting': 120,   # vs budget 500ms  -> 380ms headroom
}

TOTAL_HEADROOM = sum(
    BUDGET_STAGES[k] - ACTUAL_P95[k] for k in ACTUAL_P95
)
print(f'Total headroom: {TOTAL_HEADROOM}ms')
# Reallocate headroom to allow longer LLM responses

Pemeriksaan Singkat

Uji pemahaman Anda tentang anggaran batas waktu dan penurunan kualitas secara anggun.

Rangkuman Pelajaran

Dalam pelajaran ini, Anda mempelajari bahwa anggaran batas waktu membagi waktu di seluruh tahapan alur kerja agar Anda selalu merespons sebelum tenggat yang dapat diterima, tangga penurunan kualitas memberikan respons dengan kualitas yang semakin rendah, bukan kesalahan, ketika waktu habis, dan pencatatan peristiwa penurunan kualitas membantu Anda mengidentifikasi serta memperbaiki hambatan yang terus-menerus. Selanjutnya, kita akan mempelajari pola LLM-sebagai-penilai untuk evaluasi kualitas otomatis.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Anggaran Batas Waktu dan Penurunan Layanan yang Terkendali” gratis?

Ya — teks lengkap “Anggaran Batas Waktu dan Penurunan Layanan yang Terkendali” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Engineering Academy, upgrade ke CoddyKit PRO. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Anggaran Batas Waktu dan Penurunan Layanan yang Terkendali”?

Tetapkan anggaran batas waktu yang ketat pada setiap lapisan alur pemrosesan Anda, lalu implementasikan penurunan layanan yang terkendali untuk menyajikan respons tersimpan atau yang disederhanakan k… Kamu berlatih AI Engineering Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai AI Engineering Academy?

Tidak diperlukan pengalaman sebelumnya. AI Engineering Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Anggaran Batas Waktu dan Penurunan Layanan yang Terkendali” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Engineering Academy ini?

Ya. Setiap pelajaran AI Engineering Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Mengukur Latensi LLM: TTFT dan TPOT
Penyeimbangan Beban dan Strategi Banyak Kunci
Penyedia Cadangan dan Pemutus Sirkuit
Anggaran Batas Waktu dan Penurunan Layanan yang Terkendali

← Kembali ke AI Engineering Academy