Membuat Multi-Agent AI yang Bisa Bekerja Sama

Sistem multi‑agent AI memungkinkan beberapa model LLM (Large Language Model) berinteraksi, berbagi konteks, dan menyelesaikan tugas kompleks secara kolaboratif. Tutorial ini membahas arsitektur, persiapan, implementasi dengan LangChain, serta best practice produksi.

Pendahuluan

Masalah yang diselesaikan:
- Fragmentasi pengetahuan: Satu LLM tidak selalu memiliki keahlian lengkap.
- Skalabilitas: Membagi beban kerja ke beberapa agen meningkatkan throughput.
- Koordinasi: Agen dapat saling memberi umpan balik untuk menghasilkan output yang lebih akurat.

Arsitektur ringkas

+-------------------+        +-------------------+        +-------------------+
|   Agent A (ChatGPT Plus)  |   |   Agent B (Claude Pro)   |   |   Agent C (Gemini Advanced) |
+-------------------+        +-------------------+        +-------------------+
          \                         |                         /
           \________________________|________________________/
                                    |
                              Orchestrator (LangChain)
                                    |
                              User / API Endpoint

Orchestrator mengatur alur kerja, menyimpan memori bersama, dan menyeimbangkan beban.

Prasyarat & Persiapan

Instalasi Lingkungan

# 1. Buat virtual environment
python3 -m venv venv
source venv/bin/activate

# 2. Upgrade pip
pip install --upgrade pip

# 3. Install dependensi utama
pip install langchain openai anthropic google-generativeai python-dotenv

Buat file .env di root proyek:

# .env
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=claude-...
GOOGLE_API_KEY=AIza...

Langkah Demi Langkah

Step 1 – Inisialisasi Proyek & Struktur Direktori

mkdir multi_agent_ai && cd multi_agent_ai
mkdir agents orchestrator utils
touch main.py

Struktur akhir:

multi_agent_ai/
├─ agents/
│  ├─ chatgpt_agent.py
│  ├─ claude_agent.py
│  └─ gemini_agent.py
├─ orchestrator/
│  └─ coordinator.py
├─ utils/
│  └─ logger.py
├─ .env
└─ main.py

Step 2 – Membuat Agent Wrapper

agents/chatgpt_agent.py

import os
from langchain.llms import OpenAI
from dotenv import load_dotenv

load_dotenv()

class ChatGPTAgent:
    def __init__(self, temperature: float = 0.7):
        self.llm = OpenAI(
            temperature=temperature,
            openai_api_key=os.getenv("OPENAI_API_KEY")
        )

    def run(self, prompt: str) -> str:
        return self.llm(prompt)

agents/claude_agent.py

import os
from langchain.llms import Anthropic
from dotenv import load_dotenv

load_dotenv()

class ClaudeAgent:
    def __init__(self, temperature: float = 0.7):
        self.llm = Anthropic(
            temperature=temperature,
            anthropic_api_key=os.getenv("ANTHROPIC_API_KEY")
        )

    def run(self, prompt: str) -> str:
        return self.llm(prompt)

agents/gemini_agent.py

import os
from langchain.llms import GooglePalm
from dotenv import load_dotenv

load_dotenv()

class GeminiAgent:
    def __init__(self, temperature: float = 0.7):
        self.llm = GooglePalm(
            temperature=temperature,
            google_api_key=os.getenv("GOOGLE_API_KEY")
        )

    def run(self, prompt: str) -> str:
        return self.llm(prompt)

Step 3 – Orchestrator (Coordinator)

orchestrator/coordinator.py

import json
from typing import List, Dict
from agents.chatgpt_agent import ChatGPTAgent
from agents.claude_agent import ClaudeAgent
from agents.gemini_agent import GeminiAgent
from utils.logger import get_logger

logger = get_logger(__name__)

class Coordinator:
    def __init__(self):
        self.agents = {
            "chatgpt": ChatGPTAgent(),
            "claude": ClaudeAgent(),
            "gemini": GeminiAgent()
        }
        self.shared_memory: List[Dict] = []

    def broadcast(self, prompt: str) -> Dict[str, str]:
        """Kirim prompt ke semua agen secara paralel."""
        results = {}
        for name, agent in self.agents.items():
            try:
                response = agent.run(prompt)
                results[name] = response
                self.shared_memory.append({"agent": name, "prompt": prompt, "response": response})
                logger.info(f"[{name}] response captured")
            except Exception as e:
                logger.error(f"[{name}] error: {e}")
                results[name] = f"Error: {e}"
        return results

    def aggregate(self, responses: Dict[str, str]) -> str:
        """Gabungkan jawaban menjadi satu output terstruktur."""
        summary_prompt = (
            "Berikan ringkasan singkat (max 150 kata) dari semua jawaban berikut. "
            "Gunakan format markdown dengan heading untuk tiap agen.\n\n"
        )
        for agent, text in responses.items():
            summary_prompt += f"### {agent.capitalize()}\n{text}\n\n"

        # Gunakan ChatGPT sebagai aggregator
        aggregator = ChatGPTAgent(temperature=0.3)
        return aggregator.run(summary_prompt)

    def process(self, user_prompt: str) -> str:
        """Alur lengkap: broadcast → aggregate → return."""
        logger.info(f"Processing user prompt: {user_prompt}")
        raw = self.broadcast(user_prompt)
        final = self.aggregate(raw)
        return final

utils/logger.py

import logging

def get_logger(name: str) -> logging.Logger:
    logger = logging.getLogger(name)
    if not logger.handlers:
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(
            "%(asctime)s | %(levelname)s | %(name)s | %(message)s"
        )
        handler.setFormatter(formatter)
        logger.addHandler(handler)
    return logger

Step 4 – Entry Point

main.py

import sys
from orchestrator.coordinator import Coordinator

def main():
    if len(sys.argv) < 2:
        print("Usage: python main.py \"<prompt>\"")
        sys.exit(1)

    user_prompt = sys.argv[1]
    coordinator = Coordinator()
    result = coordinator.process(user_prompt)

    print("\n=== Aggregated Multi‑Agent Response ===\n")
    print(result)

if __name__ == "__main__":
    main()

Menjalankan contoh

python main.py "Buatkan rencana konten 5 hari untuk blog teknologi dengan fokus AI."

Output akan menampilkan ringkasan dari tiga agen, masing‑masing memberikan perspektif unik, lalu digabungkan menjadi satu dokumen markdown.

Step 5 – Integrasi dengan Tool Writing (Opsional)

Jika ingin memperkaya prompt secara otomatis, gunakan Notion AI atau Jasper untuk menghasilkan kerangka kerja. Contoh dengan Notion AI (via API) dapat dipanggil sebelum Coordinator.process.

# utils/notion_helper.py (pseudo‑code)
import requests, os

def generate_prompt(topic: str) -> str:
    url = "https://api.notion.com/v1/ai/generate"
    headers = {
        "Authorization": f"Bearer {os.getenv('NOTION_API_KEY')}",
        "Notion-Version": "2022-06-28",
        "Content-Type": "application/json"
    }
    payload = {"prompt": f"Buatkan outline blog tentang {topic}"}
    resp = requests.post(url, json=payload, headers=headers)
    return resp.json()["generated_text"]

Kemudian di main.py:

from utils.notion_helper import generate_prompt
...
topic = sys.argv[1]
user_prompt = generate_prompt(topic)
...

Step 6 – Menyimpan Hasil ke Notion atau Google Docs (Opsional)

Gunakan API Notion atau Google Drive untuk menyimpan output secara otomatis. Ini mempercepat workflow tim konten.

Tips Optimasi & Keamanan

Contoh Dockerfile

FROM python:3.11-slim

WORKDIR /app
COPY . /app
RUN pip install --no-cache-dir -r requirements.txt

ENV PYTHONUNBUFFERED=1
CMD ["python", "main.py"]

Troubleshooting Error Umum

Kesimpulan

Dengan LangChain sebagai orchestrator dan tiga LLM terkemuka (ChatGPT Plus, Claude Pro, Gemini Advanced), Anda dapat membangun sistem multi‑agent AI yang:

1. Kolaboratif – masing‑masing agen menyumbang keahlian khusus.
2. Skalabel – mudah di‑containerize dan di‑deploy pada Kubernetes.
3. Terukur – caching, rate‑limit, dan observability siap produksi.

Integrasi opsional dengan tool AI writing (Notion AI, Jasper) dan AI image (Midjourney, Canva Pro) memperkaya konten yang dihasilkan, menjadikan solusi end‑to‑end untuk tim konten, riset, atau automasi bisnis.

Selamat mencoba, dan jangan ragu untuk menyesuaikan arsitektur sesuai kebutuhan domain Anda!