Adaptive Agentic Intelligence Framework: AI Agent Irit Pakai Strands

Masalah Agen AI Tradisional dan Solusi Tiga Lapis AAIF

Menyerahkan seluruh alur kerja pada satu model frontier di cloud bikin sistem kamu rentan boros. Bayangkan skenario fasilitas operasional Internet of Things (IoT): jika setiap kali sensor meminta pembacaan suhu kamu harus memanggil model besar di cloud, saldo API kamu bakal habis dalam sekejap. Padahal, tugas semacam itu sama sekali nggak butuh penalaran tingkat dewa.

AAIF membagi beban pemrosesan ke dalam tiga lapisan terstruktur:

1. Smart Orchestration: Lapisan pengambil keputusan yang digerakkan oleh model SLM super ringan (llama3.2:1b). Orkestrator ini membaca dan mengelompokkan pesan masuk, lalu membagikannya ke jalur pemrosesan yang cocok tanpa perlu aturan kata kunci manual yang kaku.
2. Local Processing: Lapisan penanganan tugas rutin seperti penarikan telemetri perangkat atau analisis visual kamera menggunakan SLM lokal lewat Ollama. Proses ini tuntas dengan latensi sangat rendah tanpa bergantung pada koneksi internet.
3. Cloud Processing: Lapisan penalaran tingkat tinggi untuk analisis pola rumit dan pembuatan rekomendasi strategis menggunakan model frontier di Amazon Bedrock. Jalur ini hanya aktif jika permintaan memang butuh konteks luas dan penalaran multi-tahap yang nggak sanggup dikerjakan model kecil.

Bagan di atas memperlihatkan pembagian kerja yang rapi. Alih-alih membebani cloud terus-menerus, sebagian besar permintaan diselesaikan di batas tepi (edge). Hasilnya, aplikasi tetap responsif dan pengeluaran token cloud terkontrol ketat.

Arsitektur Strands Agents dan Persiapan Komponen Sistem

Di balik keandalan AAIF, pustaka Strands Agents menjadi pengendali utama yang menyatukan semua komponen. Agen ini bertindak sebagai jembatan yang menghubungkan runtime Ollama lokal dengan aneka alat (tools) operasional serta endpoint Amazon Bedrock.

Dari diagram arsitektur di atas, kamu bisa melihat bahwa agen Strands mengekspos tiga alat utama: get_device_telemetry untuk menarik telemetri sensor lokal, analyze_camera_feed untuk pemrosesan gambar via model penglihatan lokal, dan get_expert_insights yang memanggil Bedrock melalui pustaka Boto3. Rancangan ini fleksibel banget karena bisa berjalan di komputer mungil semacam Raspberry Pi berkapasitas memori 8 GB, server hybrid, hingga lingkungan full cloud.

Sebelum mulai mempraktikkan kodenya, pastikan beberapa syarat berikut sudah siap di komputermu:

• Akun AWS yang aktif dan sudah memiliki konfigurasi izin model di Amazon Bedrock pada region terkait.
• Python versi 3.10 ke atas yang sudah terpasang.
• Aplikasi Ollama yang berjalan lokal dengan dua model yang sudah diunduh: llama3.2:1b (buat orkestrator) dan llama3.2-vision (buat analisis gambar).
• Pustaka pendukung yang dipasang via terminal: pip install strands-agents strands-agents-tools boto3.
• AWS CLI yang sudah login dengan kredensial akses milikmu.

Persiapan ini mirip dengan fondasi yang sering diterapkan saat merancang multi-agent AI produksi arsitektur AWS, terutama dalam hal isolasi peran antar-komponen.

Untuk menyiapkan ruang kerja, buat direktori baru lalu jalankan server Ollama lokal:

mkdir aaif-demo && cd aaif-demo
ollama serve

Buka tab terminal baru di folder yang sama, lalu tarik kedua model yang dibutuhkan:

ollama pull llama3.2:1b
ollama pull llama3.2-vision

Bikin file skrip bernama aaif_agent.py untuk menampung seluruh logika program kita.

Panduan Membuat Tool Pemrosesan Lokal dan Cloud

Strands Agents memakai dekorator @tool untuk menandai fungsi-fungsi yang boleh dipanggil oleh agen. Pada tahap ini, kita akan merakit dua alat pemrosesan lokal dan satu alat pemrosesan cloud.

1. Menyiapkan Tool Telemetri dan Analisis Visual Lokal

Alat pertama bertugas menarik data telemetri sensor. Pada sistem produksi nyata, fungsi ini bakal tersambung langsung ke jaringan perangkat keras IoT. Di latihan ini, kita pakai data simulasi perangkat fasilitas gedung.

import random
import ollama
from strands import Agent, tool

DEVICE_TELEMETRY = {
    "sensor-001": {
        "device_type": "Temperature Sensor",
        "location": "Building A - Floor 2",
        "temperature": 72.5,
        "humidity": 45.2,
        "status": "normal"
    },
    "camera-001": {
        "device_type": "Security Camera",
        "location": "Main Entrance",
        "fps": 30,
        "resolution": "1080p",
        "status": "recording"
    },
    "hvac-001": {
        "device_type": "HVAC Controller",
        "location": "Building A - Central",
        "set_temp": 71.0,
        "current_temp": 72.5,
        "mode": "cooling",
        "status": "active"
    }
}

@tool
def get_device_telemetry() -> str:
    """Mengambil data telemetri terkini dari perangkat IoT yang terhubung."""
    device_id = random.choice(list(DEVICE_TELEMETRY.keys()))
    device_data = DEVICE_TELEMETRY[device_id]

    report = f"Device: {device_id} ({device_data['device_type']})\n"
    report += f"Location: {device_data['location']}\n"
    report += f"Status: {device_data['status']}\n"
    for key, value in device_data.items():
        if key not in ['device_type', 'location', 'status']:
            report += f"{key}: {value}\n"
    return report

@tool
def analyze_camera_feed(image_path: str) -> str:
    """Menganalisis data visual dari kamera memakai model vision lokal."""
    stream = ollama.chat(
        model='llama3.2-vision',
        messages=[{
            'role': 'user',
            'content': 'Describe this image in one sentence. What are the 3 most important things you see?',
            'images': [image_path]
        }],
        stream=True,
    )

    full_response = ""
    for chunk in stream:
        chunk_content = chunk['message']['content']
        print(chunk_content, end='', flush=True)
        full_response += chunk_content

    return f"Object Detection Report:\n{full_response}"

Keuntungan besar dari fungsi analyze_camera_feed ini adalah privasi visual. Rekaman kamera keamanan kantor atau rumah sakit diproses seutuhnya di mesin lokal, sehingga file video atau gambar sensitif nggak pernah keluar menembus jaringan publik.

2. Menyiapkan Tool Analisis Mendalam via Amazon Bedrock

Alat berikutnya adalah jembatan menuju cloud. Fungsi ini cuma dieksekusi bila orkestrator menyimpulkan bahwa pertanyaan pengguna membutuhkan penalaran tingkat tinggi yang melampaui kemampuan model kecil lokal.

import boto3

@tool
def get_expert_insights(context_data: str, question: str) -> str:
    """Mendapatkan analisis lanjutan dan rekomendasi ahli untuk pertanyaan rumit via Amazon Bedrock."""
    client = boto3.client("bedrock-runtime", region_name="us-east-1")

    conversation = [
        {
            "role": "user",
            "content": [
                {"text": f"Context: {context_data}\n\nQuestion: {question}"}
            ],
        }
    ]

    response = client.converse(
        modelId="amazon.nova-lite-v1:0",  # Masukkan model ID yang aktif di akun Bedrock kamu
        messages=conversation,
        inferenceConfig={
            "maxTokens": 512,
            "temperature": 0.5,
            "topP": 0.9
        }
    )

    response_text = response["output"]["message"]["content"][0]["text"]
    return f"Expert Analysis:\n{response_text}"

Fungsi converse dari API Bedrock Runtime memudahkan pengiriman riwayat percakapan beserta konteks telemetri yang terkumpul dari perangkat sensor lokal.

Konfigurasi Smart Orchestration dan Pengujian Agen AI

Inti kekuatan AAIF terletak pada konfigurasi agen Strands. Agen ini mempercayakan peran orkestrator kepada model lokal berukuran 1 miliar parameter (llama3.2:1b). Strands Agents mendukung banyak penyedia model, dan di sini kita menghubungkannya ke Ollama lokal:

from strands.models.ollama import OllamaModel

model = OllamaModel(
    model_id="llama3.2:1b",
    host="http://localhost:11434",
    params={
        "max_tokens": 300,
        "temperature": 0.3,
    },
)

system_prompt = """You are a monitoring assistant for operational facilities.
You have access to device telemetry tools, analysis capabilities,
and expert insights to help monitor operations effectively.

When users ask for:
- Device status or telemetry: use get_device_telemetry
- Image or data analysis: use analyze_camera_feed
- Expert advice or complex questions: use get_expert_insights

Always return the complete tool results directly to the user."""

agent = Agent(
    model=model,
    system_prompt=system_prompt,
    tools=[
        get_device_telemetry,
        analyze_camera_feed,
        get_expert_insights,
    ],
)

Orkestrator SLM langsung menganalisis maksud setiap kalimat pengguna dan mengarahkannya ke alat yang pas tanpa perlu kita buatkan logika pencocokan kata kunci manual.

Untuk menguji responsnya, kamu bisa mengeksekusi agen dengan berbagai variasi prompt:

# 1. Panggilan rutin lokal untuk telemetri
print(agent("What's the current status of our devices?"))

# 2. Panggilan analisis gambar lokal
print(agent("Analyze the camera feed from camera-001"))

# 3. Panggilan analisis strategis yang diteruskan ke cloud
print(agent(
    "Based on current telemetry patterns, "
    "what optimization strategies do you recommend?"
))

Kamu adalah asisten operasional cerdas. Jika pengguna menanyakan status sensor suhu, AC, atau kamera, panggil get_device_telemetry. Jika ada masukan gambar, panggil analyze_camera_feed. Hanya gunakan get_expert_insights jika pengguna meminta analisis anomali mendalam atau strategi penghematan energi jangka panjang.

Fleksibilitas Penerapan: Full Cloud, Hybrid, hingga Air-Gapped

AAIF dirancang menyesuaikan batasan infrastruktur yang kamu miliki, bukan sebaliknya. Fleksibilitas ini lahir karena logika perutean (orkestrator SLM) dipisahkan secara bersih dari alat-alat eksekusinya. Kamu bisa memilih satu dari tiga gaya penerapan:

1. Full Cloud: Kalau beban kerja berjalan sepenuhnya di cloud tanpa perangkat keras edge, kamu tinggal mengganti konfigurasi model Ollama menjadi BedrockModel. Seluruh inferensi akan ditangani langsung oleh layanan terkelola AWS, cocok buat tim yang punya koneksi internet prima dan bebas dari regulasi data residensi lokal.
2. Hybrid (Standar AAIF): Konfigurasi default ini mempertahankan orkestrator SLM lokal dan menyisipkan model cloud saat ada tugas yang melewati batas kemampuan model lokal. Opsi ini paling pas buat operasional yang mayoritas tugasnya berupa rutinitas harian, dengan potensi penghematan biaya API hingga sekitar 80 persen karena query rutin nggak menyentuh endpoint cloud.
3. Air-Gapped Penuh: Buat lingkungan yang mewajibkan isolasi total dari internet demi kedaulatan data rahasia, kamu bisa mencopot panggilan cloud dan menggantinya dengan model lokal yang sedikit lebih besar. Model 3 miliar parameter seperti llama3.2:3b sanggup memproses analisis bernalar moderat langsung di mesin lokal tanpa ada data yang bocor keluar.

# Contoh konfigurasi untuk mode air-gapped lokal penuh
model = OllamaModel(
    model_id="llama3.2:3b",
    host="http://localhost:11434",
)

Skalabilitas Multi-Agent Memakai Model Context Protocol (MCP)

Menuliskan fungsi tool secara langsung di dalam satu file skrip memang pas untuk tahap purwarupa. Tapi saat sistem mulai berkembang menjadi arsitektur multi-agen berskala besar, kamu perlu memisahkan fungsi-fungsi tersebut menjadi server independen berbasis Model Context Protocol (MCP).

Berdasarkan rancangan terdistribusi pada gambar di atas, sistem dibagi ke tiga perangkat terpisah:

• Device 1 (Hub Orkestrasi): Berfungsi sebagai otak utama yang menjalankan agen Strands bersama orkestrator SLM dan tool telemetri lokal.
• Device 2 (Server Edge Vision): Berperan sebagai penyedia layanan MCP yang mengeksekusi inferensi visual memakai llama3.2-vision.
• Device 3 (Gateway Analisis Cloud): Menjadi pintu gerbang MCP terpusat yang terhubung ke model analisis Amazon Bedrock.

Lewat standar MCP, seluruh alat eksternal tetap dikenali sebagai panggilan fungsi biasa oleh agen orkestrator di Device 1. Lapisan protokol MCP mengurus serialisasi data dan komunikasi jaringan secara otomatis. Pola ini sejalan dengan kemudahan yang pernah kita ulas tentang AWS Agent Registry untuk runtime tool discovery AI, di mana penemuan alat bisa berlangsung dinamis lintas server.

Tata Kelola Keamanan Terpadu dan Manfaatnya di Indonesia

Penerapan arsitektur hybrid membawa keuntungan nyata bagi developer maupun pelaku usaha di Indonesia. Banyak pabrik, perkebunan cerdas, atau cabang retail di berbagai daerah menghadapi tantangan koneksi internet yang fluktuatif. Dengan menempatkan pemrosesan rutin di mesin lokal, operasional bisnis tetap berjalan lancar meski internet sedang padam.

Namun, aspek kepatuhan data tetap menjadi prioritas penting. Mengingat aturan perlindungan data pribadi makin ketat di Indonesia, membiarkan data mentah seperti video keamanan atau data pribadi meluncur ke cloud jelas berisiko.

Kalau kamu ingin mengeksplorasi model cloud alternatif buat lapisan penalaran tinggi tanpa repot mengurus pembayaran kartu kredit luar negeri, kamu bisa menghubungkan alur kerjamu ke Classai Router. Tersedia pilihan model cerdas seperti DeepSeek V4.1 Flash (deepseek-v4.1-flash) dengan tarif Rp1.155 per 1 juta token input dan Rp4.200 per 1 juta token output, atau Kimi K3 (kimi-k3) seharga Rp2.925 per 1 juta token input dan Rp14.580 per 1 juta token output. Saldo bisa diisi mulai Rp10.000 saja lewat QRIS atau transfer bank lokal.

Setelah selesai bereksperimen dengan panduan ini, jangan lupa lakukan langkah bersih-bersih agar tagihan AWS kamu tetap aman:

1. Cabut akses model di konsol Amazon Bedrock melalui menu Model access (misalnya Amazon Nova Lite) seperti dipandu dalam dokumentasi kelola akses model AWS.
2. Matikan server Ollama dan hapus model lokal untuk membebaskan ruang penyimpanan sekitar 2 GB:

ollama stop
ollama rm llama3.2:1b
ollama rm llama3.2-vision

3. Hapus folder proyek demo jika sudah selesai diuji coba:

rm -rf aaif-demo

Lewat Adaptive Agentic Intelligence Framework, kamu sekarang bisa merancang arsitektur agen AI yang tangguh, cepat di level lokal, dan jauh lebih ramah terhadap anggaran operasional.