Parallel Processing

Dari Sequential ke Parallel

Three-agent chain kamu memproses satu konten dalam satu waktu. Agent 1 selesai, Agent 2 mulai, Agent 2 selesai, Agent 3 mulai. Buat satu konten, ini oke. Buat sepuluh konten, artinya nunggu ketiga agent selesai di konten 1 sebelum mulai konten 2. Itu sequential processing, dan ga scalable.

Parallel processing menjalankan beberapa chain secara bersamaan. Sementara Agent Riset ngerjain topik 5, Agent Penulis ngerjain topik 3, dan Agent Editor ngerjain topik 1. Kesepuluh konten bergerak lewat pipeline secara bersamaan, dibatasi hanya oleh API rate limit dan budget kamu.

Perbedaan Throughput

Asumsikan setiap panggilan agent butuh 10 detik. Three-agent chain butuh 30 detik per konten. Secara sequential, 10 konten butuh 300 detik (5 menit). Dengan full parallelism, kesepuluh konten menjalankan Agent Riset secara bersamaan, lalu kesepuluh Agent Penulis, lalu kesepuluh Agent Editor: total 90 detik.

Dalam praktiknya, kamu ga bisa menjalankan panggilan parallel tanpa batas. API punya rate limit. Budget kamu punya batas. Solusinya adalah controlled concurrency: jalankan N chain secara bersamaan, di mana N dibatasi oleh semaphore.

Mengimplementasi Concurrency

Library asyncio di Python menangani panggilan API secara concurrent. Polanya straightforward: definisikan fungsi async buat agent chain kamu, pake asyncio.Semaphore buat membatasi concurrency, dan jalankan semua chain dengan asyncio.gather.

Struktur konseptualnya kaya gini:

import asyncio

semaphore = asyncio.Semaphore(5)  # max 5 chain bersamaan

async def run_chain(topic):
    async with semaphore:
        research = await call_research_agent(topic)
        draft = await call_writing_agent(research)
        review = await call_editing_agent(draft)
        return review

async def main():
    topics = ["topic1", "topic2", ..., "topic10"]
    results = await asyncio.gather(*[run_chain(t) for t in topics])

asyncio.run(main())

AI coding assistant kamu bisa mengisi panggilan API yang sebenarnya, error handling, dan penyimpanan file. Pola struktural di atas adalah yang perlu kamu pahami. Sisanya detail implementasi.

Rate Limit dan Throttling

Setiap API provider menerapkan rate limit: request maksimum per menit, token maksimum per menit, atau keduanya. Melebihi limit ini mengembalikan error 429 (Too Many Requests). Script kamu harus menangani ini dengan graceful.

Dua strategi:

• Proactive throttling: Set semaphore count cukup rendah supaya kamu ga pernah kena rate limit. Kalo API mengizinkan 60 request/menit dan setiap chain bikin 3 request, set semaphore ke 15-18 buat tetap aman di bawah limit.
• Reactive retry: Waktu error 429 terjadi, tunggu sesuai durasi yang ditentukan di response header (biasanya Retry-After), lalu retry. Kombinasikan dengan exponential backoff: tunggu 1 detik, lalu 2, lalu 4, sampai maksimum.

Pendekatan proaktif lebih mulus. Pendekatan reaktif menangani edge case. Pake keduanya.

Isolasi Kegagalan

Waktu menjalankan 25 chain secara parallel, beberapa akan gagal. API timeout di chain 7 seharusnya ga menghancurkan chain 1 sampai 6 dan 8 sampai 25. Setiap chain berjalan secara independen. Kegagalan dicatat, dan chain yang gagal di-retry setelah semua chain yang sukses selesai.

Ini namanya failure isolation, dan ini perbedaan antara script yang menghasilkan 24 dari 25 konten dan script yang menghasilkan 0 karena satu kegagalan menumbangkan seluruh batch.

Bacaan Lanjutan

• Asynchronous LLM API Calls in Python: A Comprehensive Guide, Unite.AI
• Mastering asyncio.gather for LLM Processing, Instructor
• Python Asyncio for LLM Concurrency: Best Practices, Newline