Tutorial Lengkap CAMEL-AI: Framework Multi-Agent Communication untuk Membangun Sistem AI Kolaboratif
Penulis: Ruby Abdullah Tanggal: 20 September 2026Pendahuluan
Dalam dunia AI modern, satu model bahasa besar (LLM) saja seringkali tidak cukup untuk menyelesaikan tugas-tugas kompleks. Bayangkan jika Anda bisa membuat beberapa agen AI yang saling berkomunikasi, berdiskusi, dan berkolaborasi layaknya tim manusia. Inilah yang ditawarkan oleh CAMEL-AI (Communicative Agents for "Mind" Exploration of Large Language Model Society).
CAMEL-AI adalah framework open-source yang memungkinkan Anda membangun sistem multi-agent di mana agen-agen AI berinteraksi satu sama lain melalui percakapan terstruktur. Framework ini lahir dari riset akademis yang dipublikasikan oleh tim peneliti yang mengeksplorasi bagaimana agen berbasis LLM dapat bekerja sama secara otonom.
Mengapa CAMEL-AI?
Ada beberapa alasan mengapa CAMEL-AI layak dipelajari dan digunakan:
Apa yang Akan Anda Pelajari
Dalam tutorial ini, Anda akan mempelajari:
- Cara menginstal dan mengkonfigurasi CAMEL-AI
- Membangun agen dengan peran tertentu
- Menjalankan percakapan role-playing antar agen
- Membuat agen yang berorientasi tugas (task-oriented)
- Menggunakan tools dan integrasi eksternal
- Membangun workforce/society pattern untuk kolaborasi multi-agent
- Best practices dalam membangun sistem multi-agent
Instalasi dan Setup
Persyaratan Sistem
Sebelum memulai, pastikan Anda memiliki:
- Python 3.10 atau lebih baru
- pip (Python package manager)
- API key dari salah satu provider LLM (OpenAI, Anthropic, dll.)
Instalasi CAMEL-AI
Instalasi dasar CAMEL-AI sangat mudah menggunakan pip:
# Instalasi dasar
pip install camel-ai
Instalasi dengan semua dependensi opsional
pip install 'camel-ai[all]'
Instalasi dengan fitur spesifik
pip install 'camel-ai[tools]' # Untuk penggunaan tools
pip install 'camel-ai[rag]' # Untuk integrasi RAG
pip install 'camel-ai[openai]' # Untuk OpenAI backend
pip install 'camel-ai[anthropic]' # Untuk Anthropic Claude backend
Konfigurasi API Key
Setelah instalasi, Anda perlu mengkonfigurasi API key. Ada beberapa cara untuk melakukannya:
Cara 1: Environment Variable# Untuk OpenAI
export OPENAIAPIKEY="sk-your-api-key-here"
Untuk Anthropic Claude
export ANTHROPICAPIKEY="sk-ant-your-api-key-here"
Buat file .env di direktori proyek Anda:
OPENAIAPIKEY=sk-your-api-key-here
ANTHROPICAPIKEY=sk-ant-your-api-key-here
import os
os.environ["OPENAIAPIKEY"] = "sk-your-api-key-here"
Verifikasi Instalasi
Jalankan script berikut untuk memastikan instalasi berhasil:
import camel
print(f"CAMEL-AI versi: {camel.version}")
from camel.agents import ChatAgent
from camel.messages import BaseMessage
from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
print("Semua modul berhasil diimpor!")
Basic Usage: Membangun Agen Pertama Anda
Membuat ChatAgent Sederhana
ChatAgent adalah komponen dasar dalam CAMEL-AI. Setiap ChatAgent memiliki system message yang mendefinisikan peran dan perilakunya.
from camel.agents import ChatAgent
from camel.messages import BaseMessage
from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
Konfigurasi model
model = ModelFactory.create(
modelplatform=ModelPlatformType.OPENAI,
modeltype=ModelType.GPT4OMINI,
)
Definisikan system message untuk agen
systemmessage = """Kamu adalah seorang data scientist senior yang ahli dalam
machine learning dan deep learning. Kamu memberikan penjelasan yang jelas,
teknis, namun mudah dipahami. Kamu selalu menyertakan contoh kode Python
dalam jawabanmu."""
Buat agen
agent = ChatAgent(
systemmessage=systemmessage,
model=model,
)
Kirim pesan ke agen
usermsg = BaseMessage.makeusermessage(
rolename="User",
content="Jelaskan apa itu gradient descent dan berikan contoh implementasinya."
)
response = agent.step(usermsg)
print(response.msgs[0].content)
Role-Playing: Percakapan Antar Dua Agen
Fitur unggulan CAMEL-AI adalah role-playing session di mana dua agen berinteraksi satu sama lain. Satu agen berperan sebagai "AI Assistant" dan yang lain sebagai "AI User" yang memberikan instruksi.
from camel.societies import RolePlaying
from camel.types import ModelPlatformType, ModelType
from camel.models import ModelFactory
Konfigurasi model
model = ModelFactory.create(
modelplatform=ModelPlatformType.OPENAI,
modeltype=ModelType.GPT4OMINI,
)
Buat role-playing session
roleplaysession = RolePlaying(
assistantrolename="Python Developer",
userrolename="Project Manager",
taskprompt="""Mengembangkan REST API untuk sistem manajemen inventaris
menggunakan FastAPI. API harus mendukung CRUD operations untuk produk,
kategori, dan transaksi stok.""",
model=model,
)
Jalankan percakapan
print("=" 60)
print("ROLE-PLAYING SESSION DIMULAI")
print("=" 60)
Dapatkan pesan awal
inputmsg = roleplaysession.initchat()
Jalankan beberapa putaran percakapan
maxturns = 5
for turn in range(maxturns):
print(f"\n--- Putaran {turn + 1} ---")
# Assistant merespons
assistantresponse, userresponse = roleplaysession.step(inputmsg)
# Tampilkan respons assistant
print(f"\n[Python Developer]:")
print(assistantresponse.msg.content[:500])
# Tampilkan instruksi berikutnya dari user agent
print(f"\n[Project Manager]:")
print(userresponse.msg.content[:500])
# Cek apakah percakapan selesai
if assistantresponse.terminated or userresponse.terminated:
print("\nPercakapan selesai!")
break
# Siapkan input untuk putaran berikutnya
inputmsg = assistantresponse.msg
print("\n" + "=" 60)
print("SESSION SELESAI")
print("=" 60)
Task-Oriented Agents: Agen Berorientasi Tugas
Selain role-playing, Anda bisa membuat agen yang fokus pada penyelesaian tugas tertentu:
from camel.agents import ChatAgent
from camel.messages import BaseMessage
from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
Buat agen code reviewer
codereviewer = ChatAgent(
systemmessage="""Kamu adalah seorang senior code reviewer. Tugasmu adalah:
Menganalisis kode yang diberikan
Menemukan bug, security vulnerability, dan code smell
Memberikan saran perbaikan yang konkret
Menilai kualitas kode dari skala 1-10
Format review:
- BUGS: Daftar bug yang ditemukan
- SECURITY: Masalah keamanan
- IMPROVEMENTS: Saran perbaikan
- SCORE: Nilai kualitas (1-10)""",
model=ModelFactory.create(
modelplatform=ModelPlatformType.OPENAI,
modeltype=ModelType.GPT4OMINI,
),
)
Kode yang akan di-review
codetoreview = """
def login(username, password):
query = f"SELECT FROM users WHERE username='{username}' AND password='{password}'"
result = db.execute(query)
if result:
token = username + str(time.time())
return {"token": token, "status": "success"}
return {"status": "failed"}
"""
reviewmsg = BaseMessage.makeusermessage(
rolename="Developer",
content=f"Tolong review kode berikut:\n
"
)
response = codereviewer.step(reviewmsg)
print(response.msgs[0].content)
Advanced Usage
Multi-Agent Society: Workforce Pattern
CAMEL-AI menyediakan konsep Workforce yang memungkinkan Anda mengorganisir banyak agen ke dalam tim yang terstruktur. Setiap agen memiliki peran dan tanggung jawab sendiri, dan sistem akan mengarahkan tugas ke agen yang paling sesuai.
python
from camel.agents import ChatAgent
from camel.messages import BaseMessage
from camel.societies.workforce import Workforce
from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
Konfigurasi model
model = ModelFactory.create(
modelplatform=ModelPlatformType.OPENAI,
modeltype=ModelType.GPT4OMINI,
)
Buat agen-agen spesialis
backenddev = ChatAgent(
systemmessage="""Kamu adalah backend developer senior yang ahli dalam
Python, FastAPI, PostgreSQL, dan arsitektur microservices. Kamu bertanggung
jawab untuk mendesain dan mengimplementasikan backend system.""",
model=model,
)
frontenddev = ChatAgent(
systemmessage="""Kamu adalah frontend developer senior yang ahli dalam
React, TypeScript, dan Tailwind CSS. Kamu bertanggung jawab untuk
mendesain dan mengimplementasikan user interface.""",
model=model,
)
qaengineer = ChatAgent(
systemmessage="""Kamu adalah QA engineer senior yang ahli dalam testing
strategy, automated testing (pytest, Selenium, Cypress), dan quality
assurance. Kamu bertanggung jawab memastikan kualitas produk.""",
model=model,
)
devopsengineer = ChatAgent(
systemmessage="""Kamu adalah DevOps engineer yang ahli dalam Docker,
Kubernetes, CI/CD pipelines, dan cloud infrastructure (AWS/GCP).
Kamu bertanggung jawab untuk deployment dan infrastructure.""",
model=model,
)
Buat workforce
workforce = Workforce(
description="Tim Development untuk proyek e-commerce platform",
workers=[
(backenddev, "Backend Developer - handles API, database, business logic"),
(frontenddev, "Frontend Developer - handles UI/UX implementation"),
(qaengineer, "QA Engineer - handles testing and quality assurance"),
(devopsengineer, "DevOps Engineer - handles deployment and infrastructure"),
],
model=model,
)
Berikan tugas ke workforce
task = """Rancang arsitektur lengkap untuk platform e-commerce yang mendukung:
Katalog produk dengan pencarian dan filter
Keranjang belanja dan checkout
Sistem pembayaran (payment gateway integration)
Dashboard admin untuk manajemen produk dan pesanan
Notifikasi real-time untuk status pesanan
Setiap anggota tim harus memberikan kontribusi sesuai keahliannya."""
result = workforce.processtask(
BaseMessage.makeusermessage(rolename="CTO", content=task)
)
print("Hasil Kolaborasi Tim:")
print(result.msg.content)
Menggunakan Tools dengan Agen
CAMEL-AI mendukung penggunaan tools yang memperluas kemampuan agen. Agen dapat menggunakan tools untuk mengakses internet, menjalankan kode, membaca file, dan banyak lagi.
python
from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
from camel.toolkits import SearchToolkit, MathToolkit
Konfigurasi model
model = ModelFactory.create(
modelplatform=ModelPlatformType.OPENAI,
modeltype=ModelType.GPT4OMINI,
)
Siapkan tools
searchtools = SearchToolkit().gettools()
mathtools = MathToolkit().gettools()
Gabungkan semua tools
alltools = searchtools + mathtools
Buat agen research assistant dengan tools
researchagent = ChatAgent(
systemmessage="""Kamu adalah research assistant yang membantu pengguna
mencari informasi dan melakukan analisis. Gunakan tools yang tersedia
untuk mencari data terkini dan melakukan perhitungan yang diperlukan.
Selalu verifikasi informasi dari beberapa sumber.""",
model=model,
tools=alltools,
)
Gunakan agen
from camel.messages import BaseMessage
query = BaseMessage.makeusermessage(
rolename="Researcher",
content="Cari informasi terbaru tentang perkembangan AI agent frameworks di tahun 2026."
)
response = researchagent.step(query)
print(response.msgs[0].content)
Membuat Custom Tools
Anda juga bisa membuat tools sendiri untuk kebutuhan spesifik:
python
from camel.toolkits import FunctionTool
from camel.agents import ChatAgent
from camel.messages import BaseMessage
from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
import json
def analyzesentiment(text: str) -> str:
"""Menganalisis sentimen dari teks yang diberikan.
Args:
text (str): Teks yang akan dianalisis sentimennya.
Returns:
str: Hasil analisis sentimen dalam format JSON.
"""
# Simulasi analisis sentimen (di produksi, gunakan model ML)
positivewords = ["bagus", "hebat", "luar biasa", "senang", "puas", "baik"]
negativewords = ["buruk", "jelek", "kecewa", "marah", "gagal", "lambat"]
textlower = text.lower()
poscount = sum(1 for w in positivewords if w in textlower)
negcount = sum(1 for w in negativewords if w in textlower)
if poscount > negcount:
sentiment = "positif"
score = min(poscount / (poscount + negcount + 1), 1.0)
elif negcount > poscount:
sentiment = "negatif"
score = min(negcount / (poscount + negcount + 1), 1.0)
else:
sentiment = "netral"
score = 0.5
return json.dumps({
"sentiment": sentiment,
"confidence": round(score, 2),
"positiveindicators": poscount,
"negativeindicators": negcount
}, indent=2)
def calculatestatistics(numbers: str) -> str:
"""Menghitung statistik dasar dari kumpulan angka.
Args:
numbers (str): Angka-angka yang dipisahkan koma, contoh: '10,20,30,40,50'.
Returns:
str: Hasil perhitungan statistik dalam format JSON.
"""
nums = [float(n.strip()) for n in numbers.split(",")]
result = {
"count": len(nums),
"sum": sum(nums),
"mean": sum(nums) / len(nums),
"min": min(nums),
"max": max(nums),
"range": max(nums) - min(nums),
}
# Hitung median
sortednums = sorted(nums)
n = len(sortednums)
if n % 2 == 0:
result["median"] = (sortednums[n//2 - 1] + sortednums[n//2]) / 2
else:
result["median"] = sortednums[n//2]
return json.dumps(result, indent=2)
Buat FunctionTool dari fungsi kustom
sentimenttool = FunctionTool(analyzesentiment)
statstool = FunctionTool(calculatestatistics)
Buat agen dengan custom tools
analystagent = ChatAgent(
systemmessage="""Kamu adalah data analyst yang membantu menganalisis
data dan sentimen. Gunakan tools yang tersedia untuk melakukan analisis.""",
model=ModelFactory.create(
modelplatform=ModelPlatformType.OPENAI,
modeltype=ModelType.GPT4OMINI,
),
tools=[sentimenttool, statstool],
)
Uji agen
msg = BaseMessage.makeusermessage(
rolename="User",
content="""Tolong lakukan dua hal:
Analisis sentimen dari review ini: "Produk ini sangat bagus dan saya puas dengan kualitasnya"
Hitung statistik dari data penjualan berikut: 150, 200, 180, 220, 195, 210, 175"""
)
response = analystagent.step(msg)
print(response.msgs[0].content)
Integrasi RAG (Retrieval-Augmented Generation)
CAMEL-AI menyediakan modul RAG yang memungkinkan agen mengakses knowledge base eksternal. Ini sangat berguna ketika agen perlu menjawab pertanyaan berdasarkan dokumen atau data spesifik.
python
from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
from camel.retrievers import AutoRetriever
from camel.types import StorageType
Setup auto retriever
autoretriever = AutoRetriever(
vectorstoragelocalpath="./localstorage",
storagetype=StorageType.QDRANT,
)
Proses dan simpan dokumen ke vector store
autoretriever.runvectorretriever(
contents=[
"dokumen/panduanproduk.pdf",
"dokumen/faq.txt",
"dokumen/kebijakanperusahaan.md",
],
similaritytopk=5,
returndetailedinfo=True,
)
Buat agen customer support dengan RAG
model = ModelFactory.create(
modelplatform=ModelPlatformType.OPENAI,
modeltype=ModelType.GPT4OMINI,
)
supportagent = ChatAgent(
systemmessage="""Kamu adalah customer support specialist yang membantu
pelanggan dengan pertanyaan tentang produk dan layanan. Gunakan knowledge
base yang tersedia untuk memberikan jawaban yang akurat. Jika informasi
tidak tersedia di knowledge base, sampaikan dengan jujur.""",
model=model,
)
Fungsi helper untuk RAG-powered query
def askwithcontext(agent, retriever, question):
"""Mencari konteks relevan lalu menjawab pertanyaan."""
from camel.messages import BaseMessage
# Retrieve konteks relevan
retrieved = retriever.runvectorretriever(
query=question,
similaritytopk=3,
returndetailedinfo=True,
)
# Gabungkan konteks dengan pertanyaan
context = "\n".join([doc["text"] for doc in retrieved])
enhancedquery = f"""Berdasarkan konteks berikut:
{context}
Jawab pertanyaan ini: {question}"""
msg = BaseMessage.makeusermessage(
rolename="Customer",
content=enhancedquery,
)
response = agent.step(msg)
return response.msgs[0].content
Gunakan
answer = askwithcontext(
supportagent,
autoretriever,
"Bagaimana cara mengembalikan produk yang sudah dibeli?"
)
print(answer)
Multi-Agent Pipeline: Chaining Agents
Anda bisa membuat pipeline di mana output dari satu agen menjadi input untuk agen berikutnya. Pola ini sangat berguna untuk workflow yang kompleks.
python
from camel.agents import ChatAgent
from camel.messages import BaseMessage
from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
model = ModelFactory.create(
modelplatform=ModelPlatformType.OPENAI,
modeltype=ModelType.GPT4OMINI,
)
Agen 1: Requirements Analyst
requirementsagent = ChatAgent(
systemmessage="""Kamu adalah requirements analyst. Tugasmu:
Menganalisis kebutuhan bisnis dari deskripsi yang diberikan
Menghasilkan daftar user stories dalam format standar
Memprioritaskan fitur (Must Have, Should Have, Nice to Have)
Output dalam format terstruktur yang jelas.""",
model=model,
)
Agen 2: System Architect
architectagent = ChatAgent(
systemmessage="""Kamu adalah system architect. Berdasarkan requirements
yang diberikan, tugasmu:
Merancang arsitektur sistem (komponen, layanan, database)
Menentukan tech stack yang sesuai
Membuat diagram arsitektur dalam format text
Output berupa dokumen arsitektur teknis.""",
model=model,
)
Agen 3: Implementation Planner
planneragent = ChatAgent(
systemmessage="""Kamu adalah implementation planner. Berdasarkan
arsitektur yang diberikan, tugasmu:
Membuat sprint plan (2 minggu per sprint)
Mendefinisikan task breakdown per sprint
Estimasi effort dalam story points
Mengidentifikasi dependencies dan risiko
Output berupa rencana implementasi yang detail.""",
model=model,
)
Jalankan pipeline
def runpipeline(projectdescription: str):
print("=" 60)
print("TAHAP 1: ANALISIS REQUIREMENTS")
print("=" 60)
reqmsg = BaseMessage.makeusermessage(
rolename="PM",
content=f"Analisis requirements untuk proyek berikut:\n{projectdescription}"
)
reqresponse = requirementsagent.step(reqmsg)
requirements = reqresponse.msgs[0].content
print(requirements[:800])
print("\n" + "=" 60)
print("TAHAP 2: DESAIN ARSITEKTUR")
print("=" 60)
archmsg = BaseMessage.makeusermessage(
rolename="PM",
content=f"Rancang arsitektur berdasarkan requirements berikut:\n{requirements}"
)
archresponse = architectagent.step(archmsg)
architecture = archresponse.msgs[0].content
print(architecture[:800])
print("\n" + "=" 60)
print("TAHAP 3: RENCANA IMPLEMENTASI")
print("=" 60)
planmsg = BaseMessage.makeusermessage(
rolename="PM",
content=f"Buat rencana implementasi berdasarkan arsitektur:\n{architecture}"
)
planresponse = planneragent.step(planmsg)
plan = planresponse.msgs[0].content
print(plan[:800])
return {
"requirements": requirements,
"architecture": architecture,
"implementationplan": plan
}
Jalankan
result = runpipeline("""
Membangun platform pembelajaran online (LMS) untuk perusahaan yang mendukung:
- Video courses dengan progress tracking
- Quiz dan assessment otomatis
- Sertifikat digital setelah menyelesaikan kursus
- Dashboard analytics untuk HR dan manajer
- Integrasi dengan sistem HR existing (SAP)
- Mobile-friendly (responsive web app)
Target pengguna: 5000 karyawan di 10 cabang.
""")
Konfigurasi Model yang Fleksibel
CAMEL-AI mendukung berbagai provider LLM. Berikut cara mengkonfigurasi model dari provider yang berbeda:
python
from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
OpenAI GPT-4o
openaimodel = ModelFactory.create(
modelplatform=ModelPlatformType.OPENAI,
modeltype=ModelType.GPT4O,
modelconfigdict={
"temperature": 0.7,
"maxtokens": 4096,
}
)
Anthropic Claude
claudemodel = ModelFactory.create(
modelplatform=ModelPlatformType.ANTHROPIC,
modeltype=ModelType.CLAUDE35SONNET,
modelconfigdict={
"temperature": 0.7,
"maxtokens": 4096,
}
)
Model lokal via Ollama
ollamamodel = ModelFactory.create(
modelplatform=ModelPlatformType.OLLAMA,
modeltype="llama3.1:8b",
modelconfigdict={
"temperature": 0.7,
},
url="http://localhost:11434/v1",
)
Anda bisa menggunakan model berbeda untuk agen berbeda
from camel.agents import ChatAgent
fastagent = ChatAgent(
systemmessage="Kamu adalah assistant cepat untuk tugas sederhana.",
model=openaimodel, # Model cepat dan murah
)
smartagent = ChatAgent(
systemmessage="Kamu adalah assistant untuk analisis mendalam.",
model=claudemodel, # Model lebih capable untuk tugas kompleks
)
Memory dan State Management
CAMEL-AI menyediakan mekanisme memory yang memungkinkan agen mengingat konteks percakapan sebelumnya:
python
from camel.agents import ChatAgent
from camel.memories import ChatHistoryMemory, VectorDBMemory
from camel.messages import BaseMessage
from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
model = ModelFactory.create(
modelplatform=ModelPlatformType.OPENAI,
modeltype=ModelType.GPT4OMINI,
)
Agen dengan chat history memory
agentwithmemory = ChatAgent(
systemmessage="""Kamu adalah personal assistant yang mengingat
semua percakapan sebelumnya dengan pengguna. Gunakan konteks
dari percakapan sebelumnya untuk memberikan respons yang lebih
personal dan relevan.""",
model=model,
memory=ChatHistoryMemory(),
)
Percakapan multi-turn
conversations = [
"Halo, nama saya Budi. Saya bekerja sebagai data engineer di Jakarta.",
"Saya sedang belajar tentang Apache Spark untuk proyek big data.",
"Bisakah kamu merekomendasikan resources belajar berdasarkan background saya?",
]
for msgtext in conversations:
msg = BaseMessage.makeusermessage(
rolename="User",
content=msgtext,
)
response = agentwithmemory.step(msg)
print(f"User: {msgtext}")
print(f"Agent: {response.msgs[0].content}\n")
Best Practices
1. Desain System Message yang Jelas dan Spesifik
System message adalah fondasi dari setiap agen. Semakin jelas dan spesifik system message, semakin baik performa agen.
python
Kurang baik - terlalu umum
badsystemmsg = "Kamu adalah assistant yang membantu."
Lebih baik - spesifik dan terstruktur
goodsystemmsg = """Kamu adalah senior Python developer dengan keahlian di:
- Backend development (FastAPI, Django)
- Database design (PostgreSQL, MongoDB)
- API design (REST, GraphQL)
Panduan respons:
Selalu berikan kode yang production-ready dengan error handling
Sertakan docstring dan type hints
Jelaskan trade-off dari setiap keputusan teknis
Gunakan design patterns yang sesuai
Format output:
- Mulai dengan ringkasan singkat (2-3 kalimat)
- Berikan kode dengan komentar inline
- Akhiri dengan catatan penting atau potensi masalah"""
2. Batasi Jumlah Putaran Percakapan
Untuk menghindari loop tak terbatas dan penggunaan token yang berlebihan, selalu batasi jumlah putaran percakapan:
python
MAXTURNS = 10
EARLYSTOPKEYWORDS = ["TASKCOMPLETED", "CAMELTASKDONE"]
for turn in range(MAXTURNS):
response = agent.step(inputmsg)
content = response.msgs[0].content
# Cek kondisi berhenti
if any(keyword in content for keyword in EARLYSTOPKEYWORDS):
print(f"Tugas selesai pada putaran {turn + 1}")
break
if response.terminated:
print("Agen menandai percakapan selesai")
break
else:
print("Mencapai batas maksimum putaran")
3. Error Handling yang Robust
Selalu implementasikan error handling yang baik, terutama saat berinteraksi dengan API eksternal:
python
from camel.agents import ChatAgent
from camel.messages import BaseMessage
import time
def safeagentcall(agent, message, maxretries=3, retrydelay=2):
"""Memanggil agen dengan retry logic."""
for attempt in range(maxretries):
try:
response = agent.step(message)
if response and response.msgs:
return response.msgs[0].content
else:
print(f"Respons kosong pada percobaan {attempt + 1}")
except Exception as e:
print(f"Error pada percobaan {attempt + 1}: {e}")
if attempt < maxretries - 1:
time.sleep(retrydelay (attempt + 1))
else:
raise
return None
4. Gunakan Model yang Tepat untuk Tugas yang Tepat
Tidak semua tugas membutuhkan model terbesar dan termahal. Gunakan model yang sesuai:
| Tugas | Model yang Disarankan | Alasan |
|-------|----------------------|--------|
| Klasifikasi sederhana | GPT-4o-mini | Cepat dan murah |
| Code generation | GPT-4o / Claude Sonnet | Balance antara kualitas dan cost |
| Analisis kompleks | Claude Opus / GPT-4o | Kemampuan reasoning terbaik |
| Summarization | GPT-4o-mini | Cukup baik untuk tugas ini |
| Role-playing | GPT-4o / Claude Sonnet | Perlu kreativitas dan konsistensi |
5. Logging dan Monitoring
Selalu log interaksi agen untuk debugging dan monitoring:
python
import logging
import json
from datetime import datetime
logging.basicConfig(
filename="agentlogs.log",
level=logging.INFO,
format="%(asctime)s - %(levelname)s - %(message)s"
)
def logagentinteraction(agentname, inputmsg, outputmsg, metadata=None):
"""Log interaksi agen untuk monitoring."""
logentry = {
"timestamp": datetime.now().isoformat(),
"agent": agentname,
"input": inputmsg[:200],
"output": outputmsg[:200],
"inputlength": len(inputmsg),
"outputlength": len(outputmsg),
}
if metadata:
logentry.update(metadata)
logging.info(json.dumps(logentry, ensureascii=False))
6. Pemisahan Concern dengan Multi-Agent
Jangan membuat satu agen yang melakukan semuanya. Pecah tanggung jawab ke beberapa agen spesialis:
python
Pola yang baik: setiap agen punya tanggung jawab jelas
agents = {
"planner": ChatAgent(
systemmessage="Kamu merencanakan langkah-langkah penyelesaian tugas.",
model=model
),
"executor": ChatAgent(
systemmessage="Kamu mengeksekusi langkah-langkah teknis yang diberikan.",
model=model
),
"reviewer": ChatAgent(
systemmessage="Kamu mereview hasil kerja dan memberikan feedback.",
model=model
),
"reporter": ChatAgent(
system_message="Kamu menyusun laporan akhir dari seluruh proses.",
model=model
),
}
``
Troubleshooting Umum
Berikut beberapa masalah yang sering ditemui dan solusinya:
1. Rate Limit ErrorJika Anda mendapatkan rate limit error dari API provider, implementasikan backoff strategy dan kurangi frekuensi pemanggilan.
2. Token Limit ExceededJika pesan terlalu panjang, gunakan summarization atau chunking untuk memecah input menjadi bagian-bagian yang lebih kecil sebelum dikirim ke agen.
3. Agen Tidak Mengikuti InstruksiPerbaiki system message agar lebih eksplisit. Tambahkan contoh output yang diharapkan (few-shot prompting) langsung di system message.
4. Percakapan Role-Playing Berputar-putarTambahkan mekanisme pendeteksi repetisi dan batasi jumlah putaran percakapan. Gunakan task prompt yang lebih spesifik dan terukur.
Kesimpulan
CAMEL-AI adalah framework yang matang dan fleksibel untuk membangun sistem multi-agent. Dengan memahami konsep-konsep dasar seperti ChatAgent, Role-Playing, Workforce, dan integrasi tools, Anda sudah memiliki fondasi yang kuat untuk membangun sistem AI kolaboratif yang sophisticated.
Beberapa poin penting yang perlu diingat:
Dengan pendekatan yang tepat, CAMEL-AI dapat menjadi alat yang sangat powerful untuk mengotomasi workflow kompleks, membangun asisten AI yang kolaboratif, dan mengeksplorasi potensi penuh dari large language model dalam setting multi-agent.
Selamat mencoba dan membangun sistem multi-agent Anda sendiri!