LangManus: Panduan dengan Proyek Demo

LangManus adalah kerangka kerja automasi AI sumber terbuka yang digerakkan komunitas, dirancang untuk membangun sistem multi-agen terstruktur menggunakan model bahasa. Dengan LangManus, Anda dapat membangun agen cerdas yang menggabungkan perencanaan, riset, pengodean, interaksi peramban, dan pelaporan ke dalam satu alur kerja yang padu.

Dalam tutorial ini, saya akan memandu Anda membangun demo yang berfungsi dengan LangManus yang:

• Menemukan repositori open-source yang sedang tren di GitHub
• Mengambil data aktivitas commit terbaru
• Menganalisis pembaruan fitur dan pola kontributor
• Menghasilkan laporan markdown
• Memvisualisasikan tren aktivitas menggunakan beberapa bagan

Apa itu LangManus?

Arsitektur LangManus mendukung kontrol terperinci, dapat diaudit, dan dapat diperluas. Ini dibangun di atas alat-alat andal seperti:

• LangGraph untuk orkestrasi agen.
• Browser-Use untuk interaksi web.
• LiteLLM untuk unifikasi model.

Dengan LangManus, Anda dapat membangun agen cerdas yang menggabungkan perencanaan, riset, pengodean, interaksi peramban, dan pelaporan ke dalam satu alur terpadu yang didukung oleh:

• YAML atau konfigurasi berbasis .env untuk model dan kunci.
• API LLM yang kompatibel dengan OpenAI (melalui LiteLLM).
• Integrasi dengan alat seperti Jina dan Tavily untuk pencarian.
• Dukungan untuk model visi, REPL, sesi peramban, dan pemformatan markdown.

Gambaran Proyek LangManus: Penganalisis Repositori GitHub 

Aplikasi yang akan kita bangun adalah asisten interaktif yang menggunakan kemampuan multi-agen LangManus untuk menganalisis sebuah repositori GitHub yang sedang tren. Untuk menyiapkan Agen LangManus, kita memerlukan struktur multi-berkas di mana setiap berkas memainkan peran berbeda dalam sistem multi-agen:

• planner.py: Mendefinisikan urutan tugas.
• agent.py: Mengoordinasikan agen dan menjaga konteks.
• agents/: Folder ini berisi agen khusus untuk riset, scraping, analisis, dan pelaporan.
• streamlit_app.py: Berisi lapisan UI untuk menjalankan pipeline dan memvisualisasikan hasil.

Mari kita implementasikan satu per satu.

Langkah 1: Prasyarat

Sebelum mulai, pastikan kita telah memasang alat dan pustaka berikut:

python3 --version  # Python 3.8+
pip install requests beautifulsoup4 matplotlib streamlitDidukung oleh

Periksa versi Python, minimal 3.8 atau lebih baru. Lalu, cukup pasang semua dependensi lain yang disebutkan di atas. Anda juga memerlukan token API GitHub untuk menghindari batas laju dan menyetelnya sebagai variabel lingkungan melalui terminal.

Untuk membuat token GitHub:

• Buka GitHub Tokens
• Klik Generate New Token dan pilih versi klasik. Jangan pilih yang lain.
• Klik Generate untuk membuat token.
• Salin dan simpan token dengan aman, karena akan digunakan untuk autentikasi dalam permintaan API.

Sekarang, jalankan perintah berikut:

export GITHUB_TOKEN=your_personal_token_hereDidukung oleh

Langkah 2: Membuat Perencana dan Pengendali Agen 

Sekarang semua dependensi telah terpasang, mari kita bangun perencana dan pengendali agen untuk aplikasi kita.

1. Membuat berkas planner.py

Berkas planner.py mendefinisikan rencana 4 langkah sederhana untuk mencakup setiap tugas yang dibutuhkan, seperti riset, penelusuran, analisis, dan pelaporan. 

def plan_task(user_query):
    return [
        {'agent': 'researcher', 'task': 'Find trending repo'},
        {'agent': 'browser', 'task': 'Scrape GitHub activity'},
        {'agent': 'coder', 'task': 'Analyze recent commits and features'},
        {'agent': 'reporter', 'task': 'Generate Markdown report'}
    ]Didukung oleh

Fungsi di atas mengembalikan rencana tugas langkah demi langkah untuk sistem, di mana setiap langkah:

• Menentukan agen yang bertanggung jawab (agent); dan
• Mendefinisikan apa yang harus dilakukan agen tersebut (task).

2. Membuat berkas agent.py

Berkas agen mendefinisikan kelas inti LangManusAgent, yang mengorkestrasi semua agen dan menjaga konteks bersama saat mereka menjalankan tugasnya.

from planner import plan_task
from agents.researcher import find_trending_repo
from agents.browser import scrape_github_activity
from agents.coder import analyze_code_activity
from agents.reporter import generate_report
class LangManusAgent:
    def __init__(self, task):
        self.task = task
        self.context = {}
    def run(self):
        steps = plan_task(self.task)
        for step in steps:
            agent = step['agent']
            task = step['task']
            if agent == 'researcher':
                self.context['repo'] = find_trending_repo()
            elif agent == 'browser':
                self.context['repo_data'] = scrape_github_activity(self.context['repo'])
            elif agent == 'coder':
                self.context['analysis'], self.context['chart_path'] = analyze_code_activity(self.context['repo_data'])
            elif agent == 'reporter':
                report = generate_report(
                    self.context['repo'],
                    self.context['repo_data'],
                    self.context['analysis'],
                    self.context['chart_path']
                )
                print(report)
    def run_and_return(self):
        self.run()
        report = generate_report(
            self.context['repo'],
            self.context['repo_data'],
            self.context['analysis'],
            self.context['chart_path']
        )
        return report, self.context['chart_path']Didukung oleh

Kode dimulai dengan memanggil fungsi plan_task() untuk mengambil daftar langkah (didefinisikan di planner.py). Lalu, menjalankan setiap langkah dengan memanggil agen khusus yang sesuai dalam urutan berikut:

• Agen researcher mengambil repositori GitHub yang sedang tren.
• Agen browser mengambil aktivitas commit repositori menggunakan GitHub API.
• Agen coder menganalisis data commit dan menghasilkan bagan.
• Agen reporter menyusun semuanya menjadi laporan markdown akhir.

Setiap agen menyimpan hasilnya dalam dictionary context, sehingga agen berikutnya dapat mengakses dan melanjutkan dari keluaran sebelumnya.

Langkah 3: Mengimplementasikan Agen LangManus

Sekarang fungsi inti sudah siap, mari kita bangun agen untuk aplikasi kita.

1. Membuat berkas agents/researcher.py

Agen ini mengidentifikasi proyek Python open-source populer dari GitHub dengan mengambil data dari halaman GitHub Trending.

import requests
from bs4 import BeautifulSoup
def find_trending_repo():
    url = "https://github.com/trending/python"
    res = requests.get(url)
    soup = BeautifulSoup(res.text, 'html.parser')
    repo = soup.select_one('article h2 a')['href'].strip()
    return f"https://github.com{repo}"Didukung oleh

Begini cara kerjanya:

• Agen mengirim permintaan GET ke repositori GitHub dan mengurai respons HTML yang dikembalikan menggunakan BeautifulSoup.
• Kemudian menemukan proyek pertama yang terdaftar di bawah tag trending menggunakan selektor CSS dan mengekstrak path URL repositori (mis., /user/repo)
• Terakhir, menyusun dan mengembalikan URL GitHub lengkap seperti “https://github.com/user/repo”

2. Membuat berkas agents/browser.py

Agen browser digunakan untuk mengambil aktivitas terbaru dari repositori GitHub yang dipilih. Agen ini menggunakan GitHub REST API untuk mengumpulkan riwayat commit dan metadata.

import requests
import os
def scrape_github_activity(repo_url):
    token = os.getenv("GITHUB_TOKEN")  # Set via environment or .env
    headers = {"Authorization": f"Bearer {token}"} if token else {}
    user_repo = "/".join(repo_url.split('/')[-2:])
    api_url = f"https://api.github.com/repos/{user_repo}/commits"
    res = requests.get(api_url, headers=headers)
    res.raise_for_status()
    data = res.json()
    commits = []
    commit_dates = []
    for item in data[:20]:  # optional: increase window for better activity chart
        message = item['commit']['message']
        author = item['commit']['author']['name']
        date = item['commit']['author']['date']
        sha = item['sha'][:7]
        commits.append(f"[{sha}] {message} — {author} @ {date}")
        commit_dates.append(date)  # in ISO 8601 format (perfect for parsing)
    return {
        'repo_url': repo_url,
        'commits': commits,
        'commit_dates': commit_dates
    }Didukung oleh

Berikut yang dilakukan fungsi di atas:

• Mengekstrak bagian user/repo dari URL GitHub dan membentuk permintaan ke GitHub API.
• Agen kemudian mengurai JSON yang dikembalikan untuk mengekstrak:
• Commit SHA
• Pesan commit
• Nama penulis
• Stempel waktu
• Nilai-nilai ini disimpan dalam dua daftar: commits dan commit_dates. 
• Terakhir, fungsi mengembalikan dictionary yang memuat keduanya, yang digunakan oleh agen berikutnya untuk analisis dan visualisasi lebih lanjut.

3. Membuat berkas agents/coder.py

Agen ini memproses dan menganalisis riwayat commit yang dikumpulkan dari GitHub dan menghasilkan ringkasan tekstual serta wawasan visual menggunakan matplotlib.

# agents/coder.py
import matplotlib.pyplot as plt
from collections import defaultdict, Counter
from datetime import datetime
import matplotlib.dates as mdates
import re
import os
def categorize_commit(message):
    message = message.lower()
    if any(kw in message for kw in ["fix", "bug"]):
        return "🐛 Bug Fixes"
    elif any(kw in message for kw in ["add", "feature", "implement"]):
        return "✨ Features"
    elif any(kw in message for kw in ["doc", "readme"]):
        return "📄 Documentation"
    elif any(kw in message for kw in ["remove", "delete"]):
        return "🔥 Removals"
    elif any(kw in message for kw in ["update", "upgrade"]):
        return "🔧 Updates"
    elif any(kw in message for kw in ["merge", "pull"]):
        return "🔀 Merges"
    else:
        return "📦 Others"
def analyze_code_activity(repo_data):
    commit_messages = repo_data['commits']
    commit_dates = repo_data.get('commit_dates', [])
    # Chart 1: Commits per day (last 30 days)
    commit_day_counts = defaultdict(int)
    for date in commit_dates:
        day = datetime.fromisoformat(date).date()
        commit_day_counts[day] += 1
    recent_days = sorted(commit_day_counts.keys())
    counts = [commit_day_counts[day] for day in recent_days]
    plt.figure(figsize=(10, 4))
    plt.plot(recent_days, counts, marker='o', linestyle='-', color='tab:blue', label='Commits per day')
    plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%b %d'))
    plt.gcf().autofmt_xdate()
    plt.xlabel("Date")
    plt.ylabel("Commits")
    plt.title("📈 Commits in Last 30 Days")
    plt.legend()
    path1 = "commit_chart.png"
    plt.tight_layout()
    plt.savefig(path1)
    plt.close()
    # Chart 2: Commits per category
    commit_categories = defaultdict(list)
    category_counter = Counter()
    for msg in commit_messages:
        short_msg = re.split(r'—|@', msg)[0].strip()
        category = categorize_commit(short_msg)
        commit_categories[category].append(short_msg)
        category_counter[category] += 1
    plt.figure(figsize=(8, 4))
    cats, values = zip(*category_counter.items())
    plt.bar(cats, values, color='tab:green')
    plt.ylabel("Commits")
    plt.title("🧩 Commits by Category")
    path2 = "category_chart.png"
    plt.tight_layout()
    plt.savefig(path2)
    plt.close()
    # Chart 3: Word frequency in commit messages (basic proxy for hot areas)
    word_freq = Counter()
    for msg in commit_messages:
        words = re.findall(r'\b\w{4,}\b', msg.lower())  # only words with length >= 4
        word_freq.update(words)
    most_common = word_freq.most_common(10)
    labels, freqs = zip(*most_common)
    plt.figure(figsize=(8, 4))
    plt.bar(labels, freqs, color='tab:purple')
    plt.ylabel("Frequency")
    plt.title("🔥 Most Mentioned Topics in Commits")
    path3 = "topics_chart.png"
    plt.tight_layout()
    plt.savefig(path3)
    plt.close()
    # Build markdown report
    analysis = ["## 🔍 Commit Highlights by Category"]
    for cat, msgs in commit_categories.items():
        analysis.append(f"\n### {cat}")
        for m in msgs[:3]:
            clean_msg = m.replace("\n", " ").strip()
            analysis.append(f"- {clean_msg[:100]}{'...' if len(clean_msg) > 100 else ''}")
    charts = [path1, path2, path3]
    return analysis, chartsDidukung oleh

Agen ini memproses riwayat commit GitHub dan menghasilkan ringkasan Markdown serta bagan visual menggunakan matplotlib. Agen mengategorikan commit ke dalam kelompok yang telah ditentukan seperti perbaikan bug, fitur, dokumentasi, dan lainnya menggunakan pencocokan kata kunci. Lalu menggunakan matplotlib untuk menghasilkan tiga bagan informatif yang menampilkan:

• Aktivitas commit selama 30 hari terakhir
• Commit berdasarkan kategori
• Kata kunci yang paling sering digunakan dalam pesan commit

Terakhir, agen membuat ringkasan markdown yang menyoroti commit penting di setiap kategori dan mengembalikan ringkasan serta path bagan untuk ditampilkan dalam laporan.

4. Membuat berkas agents/reporter.py

Agen reporter menghasilkan laporan Markdown akhir yang menggabungkan:

• Tautan repositori GitHub
• Daftar poin commit terbaru
• Ringkasan terkategori dari pesan commit (dari agen coder)

def generate_report(repo_url, repo_data, analysis, chart_path):
    md = f"""# 🧠 GitHub Repo Analysis
## 🔗 Repo: [{repo_url}]({repo_url})
## 📝 Recent Commits:
"""
    for c in repo_data['commits']:
        md += f"- {c}\n"
    md += "\n## 🔍 Analysis:\n"
    for line in analysis:
        md += f"- {line}\n"
    return mdDidukung oleh

Fungsi generate_report() menyusun laporan Markdown akhir menggunakan URL GitHub, data commit, analisis terkategori, dan path bagan. Fungsi ini mengembalikan satu string berformat markdown yang dapat ditampilkan di terminal atau dirender dalam UI seperti Streamlit. Fungsi ini mengembalikan satu string berformat markdown yang dapat dicetak ke konsol atau dirender di Streamlit.

Langkah 4: Membangun UI dengan Streamlit

Aplikasi Streamlit memungkinkan pengguna menjalankan seluruh pipeline dengan satu klik. Buat berkas streamlit_app.py dan tambahkan kode berikut: 

import streamlit as st
from agent import LangManusAgent
import os
from PIL import Image
st.set_page_config(page_title="LangManus GitHub Analyzer", layout="wide")
st.title("🧠 LangManus GitHub Repo Analyzer")
if st.button("🔍 Run Analysis on Trending Repo"):
    with st.spinner("Running LangManus agents..."):
        agent = LangManusAgent(task="Find a popular open-source project updated recently and summarize its new features with examples and charts.")
        report, chart_paths = agent.run_and_return()
        st.markdown(report)
        st.subheader("📊 Charts")
        for path in chart_paths:
            if os.path.exists(path):
                st.image(Image.open(path), caption=os.path.basename(path).replace('_', ' ').replace('.png', '').title(), use_container_width=True)
else:
    st.info("Click the button to run analysis on a trending GitHub Python repo.")Didukung oleh

Berikut yang dilakukan kode tersebut:

• Menggunakan pustaka streamlit untuk membuat dasbor minimal sehingga saat mengeklik tombol analisis, akan memicu fungsi LangManusAgent.run_and_return().
• Aplikasi menampilkan laporan Markdown menggunakan fungsi st.markdown() dan melakukan iterasi melalui setiap path bagan, lalu merendernya menggunakan fungsi st.image().

Struktur akhir proyek analisis GitHub bertenaga LangManus kita seharusnya seperti ini:

LangManus-GitHub-Demo/
├── main.py
├── agent.py
├── planner.py
├── streamlit_app.py
├── agents/
│   ├── researcher.py
│   ├── browser.py
│   ├── coder.py
│   └── reporter.py
├── commit_chart.png
├── category_chart.png
├── topics_chart.pngDidukung oleh

Langkah 5: Menguji Aplikasi StreamLit

Sekarang seluruh komponen sudah siap, mari jalankan aplikasi Streamlit kita. Jalankan perintah berikut di terminal:

streamlit run streamlit_app.pyDidukung oleh

Klik tombol "Run Analysis on Trending Repo" di peramban Anda, dan agen bertenaga LangManus akan mengambil, menganalisis, dan menyajikan wawasan repositori GitHub dalam hitungan detik.

Kesimpulan

LangManus memungkinkan kita membangun sistem multi-agen terstruktur yang berinteraksi dengan data dunia nyata. Dalam panduan ini, kita membuat penganalisis repositori GitHub yang sepenuhnya otomatis di mana kita:

• Meneliti repositori yang sedang tren.
• Mengambil riwayat commit.
• Memvisualisasikan tren dengan bagan
• Merangkum hasil dalam Markdown

LangManus memiliki potensi besar untuk membangun agen riset, dasbor, dan asisten berbasis data.