CrewAI - Framework AI Multi-Agen

Daftar Isi

Pendahuluan

CrewAI adalah framework mutakhir untuk mengorkestrasi agen AI otonom yang bekerja bersama sebagai tim kolaboratif. Terinspirasi dari dinamika tim di dunia nyata, framework ini memungkinkan pengembang membuat sistem multi-agen yang canggih di mana setiap agen memiliki peran, keahlian, dan seperangkat alat yang spesifik.

Fitur utama CrewAI:

• Agen berbasis peran: Definisikan agen dengan peran, tujuan, dan latar belakang spesifik
• Manajemen tugas: Buat tugas terstruktur dengan output yang diharapkan dan dependensi
• Orkestrasi fleksibel: Mode eksekusi sekuensial, paralel, dan hierarkis
• Ekosistem tool: Kumpulan tool bawaan yang kaya plus pembuatan tool kustom
• Sistem memori: Memori jangka pendek, jangka panjang, dan entitas untuk persistensi konteks
• Delegasi: Agen dapat mendelegasikan tugas ke agen lain saat diperlukan

Sistem multi-agen mengungguli pendekatan agen tunggal untuk tugas kompleks karena memungkinkan spesialisasi, pemrosesan paralel, dan pemecahan masalah kolaboratif — mirip seperti tim manusia.

Dalam tutorial ini, Anda akan belajar cara membuat agen, mendefinisikan tugas, mengorkestrasi crew, mengintegrasikan tool, dan membangun aplikasi multi-agen dunia nyata.

Prasyarat

• Python 3.10 atau lebih tinggi
• Kunci API OpenAI (atau penyedia LLM lain yang didukung)
• Pemahaman dasar tentang Large Language Models (LLM)
• Keakraban dengan pola async Python (untuk eksekusi paralel)

Instalasi dan Pengaturan

# Instal CrewAI dengan semua tool
pip install crewai[tools]

Atau instalasi minimal
pip install crewai

Atur variabel lingkungan
export OPENAIAPIKEY="kunci-openai-api-anda"

Opsional: untuk penyedia LLM lain
export ANTHROPICAPIKEY="kunci-anthropic-anda"

Verifikasi instalasi:

import crewai
print(f"Versi CrewAI: {crewai.version}")

from crewai import Agent, Task, Crew
print("Semua komponen inti berhasil diimpor")

Konsep Dasar

CrewAI dibangun di atas tiga abstraksi inti:

from crewai import Agent, Task, Crew, Process

Crew paling sederhana
agen = Agent(
    role="Agen Penyambut",
    goal="Menyambut pengguna dengan hangat",
    backstory="Anda adalah agen ramah yang menyambut pengguna.",
    verbose=True,
)

tugas = Task(
    description="Sambut pengguna dan doakan hari yang produktif.",
    expectedoutput="Pesan sambutan yang hangat dan personal.",

    agent=agen,
)

crew = Crew(
    agents=[agen],
    tasks=[tugas],
    process=Process.sequential,
    verbose=True,
)

hasil = crew.kickoff()
print(hasil)

from crewai import Agent
from crewaitools import SerperDevTool, WebsiteSearchTool

Agen analis riset
analisriset = Agent(

    role="Analis Riset Senior",
    goal="Menemukan dan menganalisis tren dan perkembangan terbaru "
         "dalam topik yang diberikan dengan perhatian teliti terhadap detail",
    backstory=(
        "Anda adalah analis riset veteran dengan pengalaman 15 tahun "
        "dalam riset teknologi dan pasar. Anda dikenal karena kemampuan "
        "menemukan informasi yang tersembunyi namun kritis dan "
        "menyintesisnya menjadi wawasan yang jelas dan dapat ditindaklanjuti. "
        "Anda selalu memverifikasi informasi dari berbagai sumber sebelum "
        "menarik kesimpulan."
    ),
    tools=[SerperDevTool(), WebsiteSearchTool()],
    verbose=True,
    allowdelegation=True,
    maxiter=10,

    maxrpm=15,  # Batas rate: permintaan maksimum per menit
)

Agen penulis teknis
penulisteknis = Agent(

    role="Penulis Teknis Senior",
    goal="Mengubah temuan riset yang kompleks menjadi konten teknis "
         "yang jelas, menarik, dan terstruktur dengan baik",
    backstory=(
        "Anda adalah penulis teknis berprestasi yang telah menulis "
        "banyak artikel untuk publikasi teknologi terkemuka. Anda ahli "
        "dalam membuat topik kompleks dapat diakses oleh audiens luas "
        "sambil mempertahankan akurasi teknis. Tulisan Anda dikenal "
        "karena kejelasan, alur logis, dan contoh praktisnya."
    ),
    verbose=True,
    allowdelegation=False,
    maxiter=5,

)

Agen penjaminan kualitas
penjaminkualitas = Agent(
    role="Peninjau Penjaminan Kualitas",
    goal="Memastikan semua konten memenuhi standar tertinggi dalam "
         "akurasi, kelengkapan, dan keterbacaan",
    backstory=(
        "Anda adalah spesialis QA yang teliti dan telah meninjau ribuan "
        "dokumen teknis. Anda memiliki mata tajam untuk detail dan dapat "
        "menemukan kesalahan faktual, inkonsistensi logis, dan penjelasan "
        "yang tidak jelas. Anda memberikan umpan balik konstruktif yang "
        "membantu meningkatkan kualitas keseluruhan deliverable."
    ),
    verbose=True,
    allowdelegation=True,

    maxiter=5,
)

Mengonfigurasi LLM Agen

from crewai import Agent, LLM

Gunakan LLM berbeda untuk agen berbeda
gpt4llm = LLM(

    model="openai/gpt-4o",
    temperature=0.7,
)

claudellm = LLM(
    model="anthropic/claude-sonnet-4-20250514",
    temperature=0.5,
)

Agen hemat biaya untuk tugas sederhana
agensederhana = Agent(

    role="Pemformat Data",
    goal="Memformat data mentah menjadi output terstruktur",
    backstory="Anda efisien dalam pemformatan data.",
    llm=LLM(model="openai/gpt-4o-mini", temperature=0.1),
)

Agen premium untuk penalaran kompleks
agenpenalaran = Agent(
    role="Penasihat Strategis",
    goal="Memberikan analisis strategis yang mendalam",
    backstory="Anda adalah pemikir strategis kelas dunia.",
    llm=gpt4llm,

)

from crewai import Task

Tugas riset dengan instruksi detail
tugasriset = Task(
    description=(
        "Lakukan analisis riset komprehensif tentang '{topik}'. "
        "Riset Anda harus mencakup:\n"
        "1. Keadaan terkini dari teknologi/bidang tersebut\n"
        "2. Pemain utama dan kontribusi mereka\n"
        "3. Terobosan dan perkembangan terbaru (6 bulan terakhir)\n"
        "4. Ukuran pasar dan proyeksi pertumbuhan\n"
        "5. Tantangan dan keterbatasan\n"
        "6. Prospek masa depan dan prediksi\n\n"
        "Gunakan setidaknya 5 sumber berbeda. Verifikasi silang klaim "
        "di berbagai sumber untuk akurasi."
    ),
    expectedoutput=(

        "Laporan riset detail dalam format markdown dengan:\n"
        "- Ringkasan eksekutif (200 kata)\n"
        "- Temuan yang diorganisir berdasarkan 6 area di atas\n"
        "- Tabel data jika memungkinkan\n"
        "- Sitasi sumber\n"
        "- Peringkat kepercayaan untuk setiap temuan (Tinggi/Sedang/Rendah)"
    ),
    agent=analisriset,
    outputfile="laporanriset.md",
)

Tugas penulisan yang bergantung pada riset
tugaspenulisan = Task(

    description=(
        "Menggunakan temuan riset yang diberikan, tulis artikel teknis "
        "komprehensif tentang '{topik}'. Artikel harus:\n"
        "- Sepanjang 2000-3000 kata\n"
        "- Termasuk pendahuluan yang menarik\n"
        "- Menyajikan informasi dalam alur logis\n"
        "- Termasuk contoh praktis dan potongan kode jika memungkinkan\n"
        "- Diakhiri dengan kesimpulan yang dapat ditindaklanjuti\n"
        "- Cocok untuk audiens blog teknis"
    ),
    expectedoutput=(
        "Artikel teknis yang dipoles dan siap terbit dalam format "
        "markdown, dengan heading yang tepat, blok kode, dan alur alami."
    ),
    agent=penulisteknis,

    context=[tugasriset],  # Tugas ini menggunakan output dari tugasriset

    outputfile="artikel.md",
)

Tugas tinjauan
tugastinjauan = Task(

    description=(
        "Tinjau artikel teknis untuk:\n"
        "1. Akurasi faktual terhadap laporan riset\n"
        "2. Konsistensi dan alur logis\n"
        "3. Tata bahasa dan keterbacaan\n"
        "4. Kelengkapan cakupan\n"
        "5. Akurasi teknis contoh kode\n\n"
        "Berikan tinjauan detail dengan saran perbaikan spesifik."
    ),
    expectedoutput=(
        "Dokumen tinjauan terstruktur dengan:\n"
        "- Skor kualitas keseluruhan (1-10)\n"
        "- Daftar masalah yang ditemukan (dikategorikan berdasarkan tingkat keparahan)\n"
        "- Saran perbaikan spesifik\n"
        "- Rekomendasi akhir (Setuju/Revisi/Tolak)"
    ),
    agent=penjaminkualitas,

    context=[tugasriset, tugaspenulisan],

    outputfile="tinjauan.md",
)

Tugas dengan Callback

def saattugasselesai(output):
    """Callback yang dipanggil ketika tugas selesai."""
    print(f"Tugas selesai!")
    print(f"Panjang output: {len(str(output))} karakter")

    # Simpan metrik, kirim notifikasi, dll.
    with open("logtugas.txt", "a") as f:

        f.write(f"Selesai pada: {output.metadata.get('timestamp', 'N/A')}\n")

tugasriset = Task(
    description="Riset topik secara menyeluruh.",
    expectedoutput="Laporan riset komprehensif.",

    agent=analisriset,
    callback=saattugasselesai,
)

Orkestrasi Crew

Crew menyatukan agen dan tugas serta mengelola eksekusi.

from crewai import Crew, Process

Crew sekuensial: tugas berjalan satu per satu secara berurutan
crewsekuensial = Crew(

    agents=[analisriset, penulisteknis, penjaminkualitas],
    tasks=[tugasriset, tugaspenulisan, tugastinjauan],

    process=Process.sequential,
    verbose=True,
    memory=True,           # Aktifkan memori
    maxrpm=20,            # Batas rate global
    sharecrew=False,      # Jangan bagikan data dengan CrewAI

)

Mulai crew dengan variabel input
hasil = crewsekuensial.kickoff(
    inputs={"topik": "Agen Large Language Model di 2026"}
)

print(f"Output akhir:\n{hasil}")
print(f"Penggunaan token: {hasil.tokenusage}")



Crew hierarkis: agen manajer mengkoordinasikan yang lain
crewhierarkis = Crew(
    agents=[analisriset, penulisteknis, penjaminkualitas],

    tasks=[tugasriset, tugaspenulisan, tugastinjauan],
    process=Process.hierarchical,
    managerllm=LLM(model="openai/gpt-4o"),

    verbose=True,
)

hasil = crewhierarkis.kickoff(
    inputs={"topik": "Sistem Multi-Agen untuk Perusahaan"}
)

Menjalankan Crew secara Asinkron

import asyncio

async def jalankanbanyakcrew():
    """Jalankan beberapa crew secara bersamaan."""
    topiklist = [

        "AI dalam Kesehatan 2026",
        "Aplikasi Komputasi Kuantum",
        "Tren Robotika Otonom",
    ]

    tugasasync = []
    for topik in topiklist:

        crew = Crew(
            agents=[analisriset, penulisteknis],

            tasks=[tugasriset, tugaspenulisan],

            process=Process.sequential,
            verbose=False,
        )
        tugasasync.append(
            crew.kickoffasync(inputs={"topik": topik})

        )

    hasillist = await asyncio.gather(tugasasync)


    for topik, hasil in zip(topiklist, hasillist):

        print(f"\n{topik}: {len(str(hasil))} karakter dihasilkan")

    return hasillist

Jalankan
hasillist = asyncio.run(jalankanbanyakcrew())

from crewaitools import (
    SerperDevTool,
    WebsiteSearchTool,
    FileReadTool,
    DirectoryReadTool,
    CodeInterpreterTool,
)
from crewai.tools import BaseTool
from pydantic import BaseModel, Field
from typing import Type


Tool bawaan
toolpencarian = SerperDevTool()              # Pencarian Google

toolwebsite = WebsiteSearchTool()            # Pencarian dalam website
toolfile = FileReadTool()                    # Baca file

tooldirektori = DirectoryReadTool()          # Baca direktori
toolkode = CodeInterpreterTool()             # Eksekusi kode Python



Tool kustom: Query Database
class InputQueryDatabase(BaseModel):
    """Skema input untuk tool query database."""
    query: str = Field(..., description="Query SQL yang akan dieksekusi")
    database: str = Field(default="utama", description="Nama database")


class ToolQueryDatabase(BaseTool):
    name: str = "Tool Query Database"
    description: str = (
        "Eksekusi query SQL terhadap database. Gunakan ini untuk mengambil "
        "data, statistik, atau informasi terstruktur yang tersimpan "
        "di database kita."
    )
    argsschema: Type[BaseModel] = InputQueryDatabase

    def run(self, query: str, database: str = "utama") -> str:

        """Eksekusi query database dan kembalikan hasil."""
        import sqlite3

        conn = sqlite3.connect(f"{database}.db")
        cursor = conn.cursor()

        try:
            cursor.execute(query)
            hasil = cursor.fetchall()
            kolom = [desc[0] for desc in cursor.description] if cursor.description else []

            if not hasil:
                return "Query tidak mengembalikan hasil."

            # Format sebagai tabel markdown
            header = "| " + " | ".join(kolom) + " |"
            pemisah = "| " + " | ".join(["---"]  len(kolom)) + " |"
            baris = []
            for row in hasil:
                baris.append("| " + " | ".join(str(v) for v in row) + " |")

            return f"{header}\n{pemisah}\n" + "\n".join(baris)

        except Exception as e:
            return f"Error query: {str(e)}"
        finally:
            conn.close()


Tool kustom: Klien API
class ToolKlienAPI(BaseTool):
    name: str = "Klien API"
    description: str = "Membuat permintaan HTTP ke API eksternal."

    def run(self, url: str, metode: str = "GET", payload: str = None) -> str:
        import requests
        import json

        try:
            if metode.upper() == "GET":
                response = requests.get(url, timeout=30)
            elif metode.upper() == "POST":
                data = json.loads(payload) if payload else {}
                response = requests.post(url, json=data, timeout=30)
            else:
                return f"Metode tidak didukung: {metode}"

            return json.dumps(response.json(), indent=2)

        except Exception as e:
            return f"Permintaan API gagal: {str(e)}"


Tetapkan tool ke agen
analisdata = Agent(

    role="Analis Data",
    goal="Menganalisis data dari database dan API untuk mengekstrak wawasan",
    backstory="Anda adalah analis data ahli yang terampil dalam SQL dan interpretasi data.",
    tools=[ToolQueryDatabase(), ToolKlienAPI(), toolkode],
    verbose=True,
)

Eksekusi Sekuensial vs Paralel

CrewAI mendukung beberapa pola eksekusi untuk kasus penggunaan yang berbeda.

from crewai import Crew, Process, Agent, Task

Sekuensial: tugas berjalan berurutan, setiap langkah membangun dari sebelumnya
def buatpipelinesekuensial():
    """Pipeline di mana setiap langkah bergantung pada yang sebelumnya."""
    peneliti = Agent(
        role="Peneliti",
        goal="Mengumpulkan informasi yang komprehensif",
        backstory="Peneliti ahli dengan perhatian terhadap detail.",
    )

    analis = Agent(
        role="Analis",
        goal="Menganalisis data dan mengekstrak pola",
        backstory="Analis data senior dengan keahlian statistik.",
    )

    penulis = Agent(
        role="Penulis Laporan",
        goal="Membuat laporan yang jelas dan terstruktur dengan baik",
        backstory="Penulis teknis dengan pengalaman publikasi.",
    )

    tugas1 = Task(
        description="Riset {topik} secara menyeluruh.",
        expectedoutput="Data dan temuan riset mentah.",

        agent=peneliti,
    )

    tugas2 = Task(
        description="Analisis temuan riset untuk pola dan wawasan kunci.",
        expectedoutput="Ringkasan analitis dengan wawasan kunci.",
        agent=analis,
        context=[tugas1],
    )

    tugas3 = Task(
        description="Tulis laporan akhir yang menggabungkan riset dan analisis.",
        expectedoutput="Laporan akhir yang dipoles.",

        agent=penulis,
        context=[tugas1, tugas2],
    )

    crew = Crew(
        agents=[peneliti, analis, penulis],
        tasks=[tugas1, tugas2, tugas3],
        process=Process.sequential,
        verbose=True,
    )

    return crew


Mirip paralel: tugas independen yang tidak saling bergantung
def buatcrewrisetparalel():
    """Beberapa peneliti bekerja pada sub-topik berbeda secara bersamaan."""
    penelitipasar = Agent(

        role="Peneliti Pasar",
        goal="Menganalisis dinamika pasar dan lanskap kompetitif",
        backstory="Spesialis riset pasar.",
    )

    penelititeknis = Agent(
        role="Peneliti Teknis",
        goal="Menganalisis kemampuan teknis dan inovasi",
        backstory="Spesialis riset teknologi mendalam.",
    )

    penyintesis = Agent(
        role="Penyintesis Riset",
        goal="Menggabungkan beberapa aliran riset menjadi laporan kohesif",
        backstory="Ahli dalam menyintesis berbagai sumber informasi.",
    )

    tugaspasar = Task(

        description="Riset lanskap pasar untuk {topik}.",
        expectedoutput="Laporan analisis pasar.",
        agent=penelitipasar,

    )

    tugasteknis = Task(
        description="Riset aspek teknis dari {topik}.",
        expectedoutput="Laporan analisis teknis.",

        agent=penelititeknis,
    )

    tugassintesis = Task(

        description="Sintesis riset pasar dan teknis menjadi satu laporan.",
        expectedoutput="Laporan gabungan komprehensif.",
        agent=penyintesis,
        context=[tugaspasar, tugasteknis],
    )

    crew = Crew(
        agents=[penelitipasar, penelititeknis, penyintesis],
        tasks=[tugaspasar, tugasteknis, tugassintesis],

        process=Process.sequential,
        verbose=True,
    )

    return crew

from crewai import Crew, Process

Aktifkan semua tipe memori
crewdenganmemori = Crew(

    agents=[analisriset, penulisteknis],

    tasks=[tugasriset, tugaspenulisan],

    process=Process.sequential,
    memory=True,              # Aktifkan sistem memori
    embedder={                # Konfigurasi model embedding untuk memori
        "provider": "openai",
        "config": {
            "model": "text-embedding-3-small",
        }
    },
    verbose=True,
)

Penjelasan tipe memori:
1. Memori jangka pendek: Konteks dalam satu eksekusi crew
- Otomatis berbagi konteks relevan antar agen
- Melacak output tugas untuk tugas yang bergantung

2. Memori jangka panjang: Bertahan di beberapa eksekusi
- Menyimpan pola dan strategi yang berhasil
- Membantu agen meningkat seiring waktu

3. Memori entitas: Melacak informasi tentang entitas tertentu
- Mengingat detail tentang orang, perusahaan, konsep
- Membangun grafik pengetahuan seiring waktu


Menggunakan memori dalam skenario multi-eksekusi
def risetiteratif(topik, jumlahiterasi=3):

    """Jalankan crew beberapa kali, membangun dari pengetahuan sebelumnya."""
    crew = Crew(
        agents=[analisriset, penulisteknis],

        tasks=[tugasriset, tugaspenulisan],

        process=Process.sequential,
        memory=True,
        verbose=True,
    )

    hasillist = []
    for i in range(jumlahiterasi):

        print(f"\n{'='50}")

        print(f"Iterasi {i+1}/{jumlahiterasi}")
        print(f"{'='50}")

        topikdiperhalus = f"{topik} - Iterasi {i+1}: "

        if i == 0:
            topikdiperhalus += "Riset awal yang luas"
        elif i == 1:
            topikdiperhalus += "Pendalaman temuan utama"

        else:
            topikdiperhalus += "Sintesis akhir dan rekomendasi"

        hasil = crew.kickoff(inputs={"topik": topikdiperhalus})

        hasillist.append(hasil)

    return hasillist

# Aktifkan delegasi untuk pemecahan masalah kolaboratif
manajerproyek = Agent(
    role="Manajer Proyek",
    goal="Mengkoordinasikan tim untuk memberikan hasil berkualitas tinggi tepat waktu",
    backstory=(
        "Anda adalah manajer proyek berpengalaman yang unggul dalam "
        "memecah proyek kompleks menjadi tugas yang dapat dikelola. "
        "Anda tahu kapan harus mendelegasikan pekerjaan ke spesialis "
        "dan kapan harus menangani sendiri."
    ),
    allowdelegation=True,  # Dapat mendelegasikan ke agen lain

    verbose=True,
)

devfrontend = Agent(
    role="Pengembang Frontend",
    goal="Membangun antarmuka pengguna yang responsif dan aksesibel",
    backstory="Pengembang React/TypeScript ahli dengan 8 tahun pengalaman.",
    allowdelegation=False,  # Spesialis: menangani pekerjaan sendiri

    verbose=True,
)

devbackend = Agent(
    role="Pengembang Backend",
    goal="Merancang dan mengimplementasikan API dan sistem data yang kokoh",
    backstory="Pengembang Python/FastAPI senior dengan keahlian sistem terdistribusi.",
    allowdelegation=False,

    verbose=True,
)

Manajer proyek dapat mendelegasikan bagian dari tugas kompleks ke spesialis
tugasperencanaan = Task(
    description=(
        "Rencanakan dan koordinasikan pengembangan fitur baru: {fitur}. "
        "Pecah menjadi komponen frontend dan backend. "
        "Delegasikan desain teknis ke spesialis yang sesuai. "
        "Sintesis masukan mereka menjadi rencana implementasi komprehensif."
    ),
    expectedoutput=(

        "Rencana implementasi detail dengan:\n"
        "- Gambaran arsitektur\n"
        "- Komponen frontend dan spesifikasinya\n"
        "- Endpoint API backend dan model data\n"
        "- Titik integrasi\n"
        "- Estimasi timeline"
    ),
    agent=manajerproyek,
)

crew = Crew(
    agents=[manajerproyek, devfrontend, devbackend],

    tasks=[tugasperencanaan],
    process=Process.sequential,
    verbose=True,
)

hasil = crew.kickoff(
    inputs={"fitur": "Editor dokumen kolaboratif real-time"}
)

Studi Kasus: Tim Agen Riset

Tim riset lengkap yang dapat menginvestigasi topik apa pun dan menghasilkan laporan siap terbit.

from crewai import Agent, Task, Crew, Process
from crewaitools import SerperDevTool, WebsiteSearchTool



def buattimriset(topik: str):

    """Buat tim riset lengkap untuk analisis topik komprehensif."""

    # Tool
    pencarian = SerperDevTool()
    web = WebsiteSearchTool()

    # Agen
    ketuapeneliti = Agent(
        role="Kepala Ilmuwan Riset",
        goal=f"Melakukan riset primer menyeluruh tentang {topik}",
        backstory=(
            "Anda memimpin tim riset di lembaga think tank terkemuka. "
            "Anda dikenal karena metodologi riset yang komprehensif "
            "dan kemampuan menemukan sumber primer."
        ),
        tools=[pencarian, web],
        allowdelegation=True,

        maxiter=15,
        verbose=True,
    )

    pemeriksafakta = Agent(

        role="Pemeriksa Fakta",
        goal="Memverifikasi semua klaim dan statistik dengan sumber otoritatif",
        backstory=(
            "Anda adalah pemeriksa fakta profesional yang telah bekerja "
            "untuk organisasi berita besar. Anda tidak pernah membiarkan "
            "klaim yang belum diverifikasi lolos."
        ),
        tools=[pencarian, web],
        verbose=True,
    )

    editor = Agent(
        role="Editor Senior",
        goal="Menghasilkan laporan riset yang dipoles dan siap terbit",
        backstory=(
            "Anda adalah editor senior di publikasi riset terkemuka. "
            "Anda mengubah riset mentah menjadi narasi yang jelas dan menarik."
        ),
        verbose=True,
    )

    # Tugas
    tugasriset = Task(
        description=(
            f"Lakukan riset komprehensif tentang: {topik}\n\n"
            "Persyaratan:\n"
            "- Identifikasi setidaknya 10 sumber relevan\n"
            "- Cakup konteks historis, keadaan saat ini, dan prospek masa depan\n"
            "- Sertakan data kuantitatif (statistik, angka pasar)\n"
            "- Catat sudut pandang yang bertentangan dan perdebatan di bidang ini\n"
            "- Tandai klaim yang perlu pemeriksaan fakta"
        ),
        expectedoutput="Catatan riset detail dengan sitasi sumber.",

        agent=ketuapeneliti,
    )

    tugascekfakta = Task(
        description=(
            "Tinjau semua klaim dalam temuan riset. Untuk setiap klaim:\n"
            "1. Verifikasi dengan minimal satu sumber independen tambahan\n"
            "2. Beri peringkat kepercayaan: Terkonfirmasi / Kemungkinan / Belum Diverifikasi / Diperdebatkan\n"
            "3. Catat koreksi yang diperlukan\n"
            "4. Tambahkan konteks yang hilang jika perlu"
        ),
        expectedoutput="Laporan pemeriksaan fakta dengan status verifikasi untuk setiap klaim.",

        agent=pemeriksafakta,
        context=[tugasriset],

    )

    tugasediting = Task(
        description=(
            "Menggunakan riset yang terverifikasi, buat laporan akhir dengan:\n"
            "1. Ringkasan Eksekutif (300 kata)\n"
            "2. Pendahuluan dan Latar Belakang\n"
            "3. Temuan Utama (diorganisir secara tematik)\n"
            "4. Analisis dan Implikasi\n"
            "5. Prospek Masa Depan\n"
            "6. Referensi\n\n"
            "Pastikan semua klaim yang diperdebatkan atau belum diverifikasi "
            "dihapus atau ditandai dengan jelas."
        ),
        expectedoutput="Laporan riset siap terbit dalam format markdown.",

        agent=editor,
        context=[tugasriset, tugascekfakta],
        outputfile=f"riset{topik.replace(' ', '').lower()}.md",

    )

    crew = Crew(
        agents=[ketuapeneliti, pemeriksafakta, editor],

        tasks=[tugasriset, tugascekfakta, tugasediting],

        process=Process.sequential,
        memory=True,
        verbose=True,
    )

    return crew


Penggunaan
crewriset = buattimriset("Agen AI dalam Otomasi Perusahaan 2026")
hasil = crewriset.kickoff()

print(f"Laporan dihasilkan: {len(str(hasil))} karakter")

from crewai import Agent, Task, Crew, Process
from crewaitools import CodeInterpreterTool, FileReadTool, DirectoryReadTool


def buattimpemrograman(deskripsiproyek: str):

    """Buat tim pemrograman untuk tugas pengembangan perangkat lunak."""

    toolkode = CodeInterpreterTool()
    toolfile = FileReadTool()

    tooldir = DirectoryReadTool()

    # Arsitek
    arsitek = Agent(
        role="Arsitek Perangkat Lunak",
        goal="Merancang arsitektur perangkat lunak yang skalabel dan mudah dipelihara",
        backstory=(
            "Anda adalah arsitek perangkat lunak utama dengan 20 tahun "
            "pengalaman. Anda merancang sistem yang elegan, berkinerja tinggi, "
            "dan mudah dipelihara. Anda mengutamakan prinsip SOLID, arsitektur "
            "bersih, dan keputusan desain pragmatis."
        ),
        verbose=True,
        allowdelegation=True,

    )

    # Pengembang
    pengembang = Agent(
        role="Pengembang Perangkat Lunak Senior",
        goal="Menulis kode yang bersih, efisien, dan teruji dengan baik",
        backstory=(
            "Anda adalah pengembang senior yang menulis kode berkualitas "
            "produksi. Anda mengikuti TDD, menulis docstring komprehensif, "
            "dan menangani edge case. Anda lebih memilih kode yang sederhana "
            "dan mudah dibaca daripada abstraksi yang rumit."
        ),
        tools=[toolkode, toolfile],

        verbose=True,
    )

    # Peninjau kode
    peninjau = Agent(
        role="Peninjau Kode",
        goal="Memastikan kualitas kode, keamanan, dan kepatuhan terhadap praktik terbaik",
        backstory=(
            "Anda adalah tech lead yang dikenal karena tinjauan kode yang "
            "menyeluruh. Anda menangkap bug, kerentanan keamanan, dan masalah "
            "performa. Tinjauan Anda konstruktif dan edukatif."
        ),
        tools=[toolkode],
        verbose=True,
    )

    # Tugas
    tugasdesain = Task(

        description=(
            f"Rancang arsitektur untuk: {deskripsiproyek}\n\n"
            "Berikan:\n"
            "1. Diagram arsitektur tingkat tinggi (berbasis teks)\n"
            "2. Struktur modul/paket\n"
            "3. Interface kunci dan model data\n"
            "4. Pilihan teknologi dengan justifikasi\n"
            "5. Strategi penanganan error\n"
            "6. Strategi pengujian"
        ),
        expectedoutput="Dokumen desain arsitektur dengan semua bagian yang ditentukan.",

        agent=arsitek,
    )

    tugasimplementasi = Task(
        description=(
            "Implementasikan sistem berdasarkan desain arsitektur.\n\n"
            "Persyaratan:\n"
            "- Ikuti arsitektur dengan tepat\n"
            "- Tulis kode Python lengkap yang dapat dijalankan\n"
            "- Sertakan type hint pada semua fungsi\n"
            "- Tulis docstring untuk semua API publik\n"
            "- Sertakan unit test untuk fungsionalitas inti\n"
            "- Tangani error dengan baik"
        ),
        expectedoutput="Implementasi lengkap dengan kode sumber dan pengujian.",

        agent=pengembang,
        context=[tugasdesain],
    )

    tugastinjauan = Task(

        description=(
            "Tinjau implementasi untuk:\n"
            "1. Kepatuhan terhadap desain arsitektur\n"
            "2. Kualitas kode (keterbacaan, DRY, SOLID)\n"
            "3. Kerentanan keamanan\n"
            "4. Masalah performa\n"
            "5. Cakupan dan kualitas pengujian\n"
            "6. Kelengkapan penanganan error\n\n"
            "Berikan saran kode spesifik untuk setiap masalah yang ditemukan."
        ),
        expectedoutput=(
            "Laporan tinjauan kode dengan masalah, tingkat keparahan, "
            "dan saran perbaikan spesifik."
        ),
        agent=peninjau,
        context=[tugasdesain, tugasimplementasi],
    )

    crew = Crew(
        agents=[arsitek, pengembang, peninjau],
        tasks=[tugasdesain, tugasimplementasi, tugastinjauan],

        process=Process.sequential,
        memory=True,
        verbose=True,
    )

    return crew


Penggunaan
crewkoding = buattimpemrograman(
    "REST API untuk sistem manajemen tugas dengan autentikasi pengguna, "
    "operasi CRUD tugas, kolaborasi tim, dan notifikasi real-time "
    "menggunakan FastAPI dan SQLAlchemy"
)

hasil = crewkoding.kickoff()

print(f"Output pengembangan: {len(str(hasil))} karakter")

# BURUK: Peran yang samar
agen = Agent(
    role="Pembantu",
    goal="Membantu berbagai hal",
    backstory="Anda membantu orang.",
)

BAIK: Peran yang spesifik dan terdefinisi dengan baik
agen = Agent(
    role="Analis Data Keuangan",
    goal="Menganalisis dataset keuangan untuk mengidentifikasi tren, "
         "anomali, dan wawasan investasi yang dapat ditindaklanjuti",
    backstory=(
        "Anda memiliki sertifikasi CFA dan 10 tahun pengalaman "
        "di perusahaan investasi terkemuka. Anda berspesialisasi dalam "
        "analisis kuantitatif dan memiliki rekam jejak mengidentifikasi "
        "peluang pasar yang menguntungkan melalui pendekatan berbasis data."
    ),
)

# BURUK: Tugas yang samar
tugas = Task(