Otomatisasi tugas repetitif pakai Python sudah umum. Sekarang, tambahkan integrasi API LLM. Skrip tidak hanya eksekusi perintah. Skrip bisa paham konteks, buat keputusan, dan hasilkan output natural. Artikel ini bahas cara membangun skrip otomatisasi Python dengan integrasi API LLM. Fokus praktis, langsung jalan.

Kenapa Python untuk Otomatisasi AI?

Python pilihan utama. Alasannya:

  • Library lengkap untuk API, file handling, dan proses sistem.
  • Sintaks sederhana. Skrip mudah dibaca dan dirawat.
  • Ekosistem AI kuat. Banyak SDK resmi dari provider LLM.

Python bukan bahasa tercepat. Tapi untuk otomatisasi, kecepatan development lebih penting daripada kecepatan eksekusi.

Persiapan Environment

Sebelum menulis skrip, siapkan environment. Gunakan virtual environment agar dependensi terisolasi.

python -m venv venv
source venv/bin/activate  # Linux/Mac
venv\Scripts\activate     # Windows
pip install requests openai python-dotenv

Library yang dibutuhkan:

  • openai - SDK resmi untuk API OpenAI. Bisa juga untuk provider lain yang kompatibel.
  • requests - HTTP client untuk API LLM non-OpenAI.
  • python-dotenv - Load kredensial dari file .env. Jangan hardcode API key di skrip.

Buat file .env:

OPENAI_API_KEY=sk-xxxxxxxxxxxx

Integrasi API LLM Dasar

Mulai dengan pemanggilan API sederhana. Contoh pakai OpenAI SDK.

import os
from dotenv import load_dotenv
from openai import OpenAI

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 asisten yang membantu."},
        {"role": "user", "content": "Ringkas teks berikut: ..."}
    ]
)

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

Struktur dasar sudah jalan. Sekarang tingkatkan ke skrip otomatisasi nyata.

Membangun Skrip Otomatisasi

Contoh kasus: skrip yang membaca file laporan, menganalisis isi, lalu menghasilkan ringkasan otomatis.

Langkah 1: Baca Input File

def baca_file(path):
    try:
        with open(path, "r", encoding="utf-8") as f:
            return f.read()
    except FileNotFoundError:
        print(f"File tidak ditemukan: {path}")
        return None

Langkah 2: Kirim ke LLM

def ringkas_teks(teks, api_key):
    client = OpenAI(api_key=api_key)
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "Kamu analis laporan. Ringkas dalam 3 poin."},
            {"role": "user", "content": teks}
        ],
        temperature=0.3
    )
    return response.choices[0].message.content

Langkah 3: Simpan Output

def simpan_output(teks, path):
    with open(path, "w", encoding="utf-8") as f:
        f.write(teks)
    print(f"Output tersimpan di {path}")

Langkah 4: Main Loop

def main():
    load_dotenv()
    api_key = os.getenv("OPENAI_API_KEY")
    
    input_file = "laporan.txt"
    output_file = "ringkasan.txt"
    
    teks = baca_file(input_file)
    if teks is None:
        return
    
    ringkasan = ringkas_teks(teks, api_key)
    simpan_output(ringkasan, output_file)

if __name__ == "__main__":
    main()

Skrip dasar selesai. Sekarang perkuat dengan pola yang lebih robust.

Pola Lanjutan untuk Skrip Otomatisasi

Retry Logic

API LLM bisa gagal karena rate limit atau timeout. Tambahkan retry dengan exponential backoff.

import time

def panggil_llm_dengan_retry(client, messages, max_retry=3):
    for attempt in range(max_retry):
        try:
            response = client.chat.completions.create(
                model="gpt-4o-mini",
                messages=messages
            )
            return response.choices[0].message.content
        except Exception as e:
            if attempt == max_retry - 1:
                raise
            wait = 2 ** attempt
            print(f"Gagal. Retry dalam {wait} detik.")
            time.sleep(wait)

Batch Processing

Untuk banyak file, proses secara batch. Hindari memanggil API satu per satu tanpa jeda.

from concurrent.futures import ThreadPoolExecutor

def proses_batch(list_file, max_workers=3):
    results = {}
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = {executor.submit(proses_satu_file, f): f for f in list_file}
        for future in futures:
            f = futures[future]
            try:
                results[f] = future.result()
            except Exception as e:
                print(f"Gagal proses {f}: {e}")
                results[f] = None
    return results

Perhatikan: max_workers jangan terlalu besar. Rate limit API bisa kena.

Structured Output

Gunakan JSON mode agar output LLM mudah diparsing. OpenAI mendukung response_format.

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages,
    response_format={"type": "json_object"}
)

import json
data = json.loads(response.choices[0].message.content)

Output terstruktur memudahkan integrasi ke database atau file config.

Best Practice

  • Simpan API key di environment variable. Jangan di hardcode atau commit ke git.
  • Buat fungsi terpisah. Satu fungsi satu tanggung jawab. Memudahkan testing.
  • Handle error eksplisit. Jangan biarkan exception mentah keluar tanpa pesan jelas.
  • Logging. Gunakan modul logging untuk melacak proses.
  • Batasi ukuran input. LLM punya token limit. Potong teks panjang sebelum dikirim.
import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

def proses_satu_file(path):
    logger.info(f"Memproses {path}")
    # ...

💡 Baca Juga & Rekomendasi Jaringan AI Network:

  • Gunakan racikan prompt profesional di SolusiAI.my.id (Rekomendasi Tools & Otomatisasi AI).
  • Pelajari tutorial skrip dan otomatisasi teknis di PromptHack.my.id (Kumpulan AI Prompt & Content Growth).

Kesimpulan

Membangun skrip otomatisasi Python dengan integrasi API LLM tidak sulit. Mulai dari pemanggilan API sederhana, lalu tambahkan retry, batch processing, dan structured output. Python menyediakan semua tool yang dibutuhkan. Kunci utamanya: pisahkan logika, handle error, dan jaga kredensial tetap aman. Skrip yang baik bukan yang paling kompleks, tapi yang paling andal. Coba bangun skrip kecil untuk kebutuhanmu sendiri. Kembangkan seiring kebutuhan. Otomatisasi AI bukan masa depan. Ini sekarang.

Post a Comment

Lebih baru Lebih lama