LangManus: Hướng dẫn kèm dự án demo

LangManus là một framework tự động hóa AI mã nguồn mở, do cộng đồng đóng góp, được thiết kế để xây dựng các hệ thống đa tác tử có cấu trúc dựa trên mô hình ngôn ngữ. Với LangManus, bạn có thể xây dựng các tác tử thông minh kết hợp lập kế hoạch, nghiên cứu, viết mã, tương tác trình duyệt và lập báo cáo vào một quy trình thống nhất.

Trong hướng dẫn này, tôi sẽ hướng dẫn bạn xây dựng một bản demo hoạt động với LangManus để:

• Tìm kho mã nguồn mở đang thịnh hành trên GitHub
• Thu thập hoạt động commit gần đây
• Phân tích các cập nhật tính năng và mô hình đóng góp
• Tạo báo cáo markdown
• Trực quan hóa xu hướng hoạt động bằng nhiều biểu đồ

LangManus là gì?

Kiến trúc của LangManus hỗ trợ kiểm soát chi tiết, khả năng kiểm toán và khả năng mở rộng. Nó được xây dựng dựa trên các công cụ mạnh mẽ như:

• LangGraph để điều phối tác tử.
• Browser-Use để tương tác web.
• LiteLLM để hợp nhất mô hình.

Với LangManus, bạn có thể xây dựng các tác tử thông minh kết hợp lập kế hoạch, nghiên cứu, viết mã, tương tác trình duyệt và lập báo cáo vào một quy trình thống nhất, được vận hành bởi:

• YAML hoặc cấu hình dựa trên .env cho mô hình và khóa.
• API LLM tương thích OpenAI (thông qua LiteLLM).
• Tích hợp với các công cụ như Jina và Tavily để tìm kiếm.
• Hỗ trợ các mô hình thị giác, REPL, phiên trình duyệt và định dạng markdown.

Tổng quan dự án LangManus: Trình phân tích kho GitHub 

Ứng dụng chúng ta sẽ xây dựng là một trợ lý tương tác sử dụng khả năng đa tác tử của LangManus để phân tích một kho GitHub đang thịnh hành. Để thiết lập các Tác tử LangManus, chúng ta cần một cấu trúc nhiều tệp, trong đó mỗi tệp đảm nhiệm một vai trò riêng trong hệ thống đa tác tử:

• planner.py: Định nghĩa trình tự các tác vụ.
• agent.py: Điều phối các tác tử và duy trì ngữ cảnh.
• agents/: Thư mục chứa các tác tử chuyên biệt cho nghiên cứu, thu thập, phân tích và báo cáo.
• streamlit_app.py: Chứa lớp giao diện để chạy pipeline và trực quan hóa kết quả.

Hãy triển khai lần lượt từng phần.

Bước 1: Điều kiện tiên quyết

Trước khi bắt đầu, hãy đảm bảo bạn đã cài đặt các công cụ và thư viện sau:

python3 --version  # Python 3.8+
pip install requests beautifulsoup4 matplotlib streamlitĐược hỗ trợ bởi

Kiểm tra phiên bản Python, tối thiểu là 3.8 trở lên. Sau đó, chỉ cần cài đặt các phụ thuộc còn lại như trên. Bạn cũng sẽ cần một GitHub API token để tránh giới hạn tốc độ và đặt nó làm biến môi trường bằng terminal.

Để tạo GitHub token:

• Đi tới GitHub Tokens
• Nhấp Generate New Token và chọn phiên bản classic. Không chọn mục nào khác.
• Nhấp Generate để tạo token.
• Sao chép và lưu token một cách an toàn, vì nó sẽ được dùng để xác thực trong các yêu cầu API.

Bây giờ, chạy lệnh sau:

export GITHUB_TOKEN=your_personal_token_hereĐược hỗ trợ bởi

Bước 2: Tạo Planner và Agent Controller 

Giờ chúng ta đã cài đặt xong các phụ thuộc, hãy xây dựng planner và agent controller cho ứng dụng.

1. Tạo tệp planner.py

Tệp planner.py định nghĩa một kế hoạch 4 bước đơn giản để bao quát các tác vụ cần thiết như nghiên cứu, duyệt, phân tích và báo cáo. 

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'}
    ]Được hỗ trợ bởi

Hàm trên trả về một kế hoạch tác vụ từng bước cho hệ thống, trong đó mỗi bước:

• Chỉ rõ tác tử chịu trách nhiệm (agent); và
• Định nghĩa tác vụ tác tử đó cần thực hiện (task).

2. Tạo tệp agent.py

Tệp agent định nghĩa lớp cốt lõi LangManusAgent, lớp này điều phối tất cả tác tử và duy trì ngữ cảnh dùng chung khi họ thực hiện nhiệm vụ.

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']Được hỗ trợ bởi

Đoạn mã bắt đầu bằng việc gọi hàm plan_task() để lấy danh sách các bước (được định nghĩa trong planner.py). Sau đó, nó chạy từng bước bằng cách gọi tác tử chuyên biệt tương ứng theo thứ tự sau:

• Tác tử researcher truy xuất một kho GitHub đang thịnh hành.
• Tác tử browser thu thập hoạt động commit của kho bằng GitHub API.
• Tác tử coder phân tích dữ liệu commit và tạo biểu đồ.
• Tác tử reporter tổng hợp mọi thứ thành báo cáo markdown cuối cùng.

Mỗi tác tử lưu kết quả của mình vào từ điển context, cho phép các tác tử phía sau truy cập và xây dựng dựa trên đầu ra trước đó.

Bước 3: Triển khai các Tác tử LangManus

Giờ chúng ta đã sẵn sàng các hàm cốt lõi, hãy xây dựng các tác tử cho ứng dụng.

1. Tạo tệp agents/researcher.py

Tác tử này xác định một dự án Python mã nguồn mở phổ biến trên GitHub bằng cách thu thập dữ liệu từ trang 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}"Được hỗ trợ bởi

Cách hoạt động như sau:

• Tác tử gửi một yêu cầu GET tới kho GitHub và phân tích phản hồi HTML trả về bằng BeautifulSoup.
• Sau đó, nó tìm dự án đầu tiên được liệt kê dưới thẻ trending bằng bộ chọn CSS và trích xuất đường dẫn URL của kho (ví dụ, /user/repo)
• Cuối cùng, nó dựng và trả về URL đầy đủ của GitHub như “https://github.com/user/repo”

2. Tạo tệp agents/browser.py

Tác tử trình duyệt được dùng để truy xuất hoạt động gần đây từ kho GitHub đã chọn. Nó sử dụng GitHub REST API để thu thập lịch sử commit và siêu dữ liệu.

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
    }Được hỗ trợ bởi

Hàm trên thực hiện các việc sau:

• Trích xuất phần user/repo của URL GitHub và tạo yêu cầu tới GitHub API.
• Tác tử sau đó phân tích JSON trả về để trích xuất:
• Commit SHA
• Thông điệp commit
• Tên tác giả
• Dấu thời gian
• Các giá trị này được lưu trong hai danh sách: commits và commit_dates. 
• Cuối cùng, hàm trả về một từ điển chứa cả hai danh sách, được các tác tử phía sau sử dụng cho phân tích và trực quan hóa.

3. Tạo tệp agents/coder.py

Tác tử này xử lý và phân tích lịch sử commit thu thập từ GitHub và tạo cả tóm tắt văn bản lẫn biểu đồ trực quan bằng 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, chartsĐược hỗ trợ bởi

Tác tử này xử lý lịch sử commit trên GitHub và tạo tóm tắt Markdown cùng các biểu đồ trực quan bằng matplotlib. Nó phân loại commit vào các nhóm định sẵn như sửa lỗi, tính năng, tài liệu, v.v. dựa trên đối sánh từ khóa. Sau đó dùng matplotlib để tạo ba biểu đồ trực quan thể hiện:

• Hoạt động commit trong 30 ngày qua
• Commit theo danh mục
• Các từ khóa được dùng thường xuyên nhất trong thông điệp commit

Cuối cùng, tác tử tạo một tóm tắt markdown nêu bật các commit chính trong từng danh mục và trả về cả phần tóm tắt lẫn đường dẫn biểu đồ để hiển thị trong báo cáo.

4. Tạo tệp agents/reporter.py

Tác tử reporter tạo báo cáo Markdown cuối cùng, kết hợp:

• Liên kết kho GitHub
• Danh sách gạch đầu dòng các commit gần đây
• Tóm tắt theo danh mục của thông điệp commit (từ tác tử 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 mdĐược hỗ trợ bởi

Hàm generate_report() lắp ghép báo cáo Markdown cuối cùng sử dụng URL GitHub, dữ liệu commit, phân tích theo danh mục và đường dẫn biểu đồ. Nó trả về một chuỗi định dạng markdown có thể hiển thị trên terminal hoặc render trong giao diện như Streamlit. Nó trả về một chuỗi định dạng markdown có thể in ra console hoặc render trong Streamlit.

Bước 4: Xây dựng giao diện với Streamlit

Ứng dụng Streamlit cho phép người dùng chạy toàn bộ pipeline chỉ với một cú nhấp. Tạo tệp streamlit_app.py và thêm đoạn mã sau: 

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.")Được hỗ trợ bởi

Đoạn mã thực hiện các việc sau:

• Sử dụng thư viện streamlit để tạo một bảng điều khiển tối giản sao cho khi nhấp nút phân tích, nó kích hoạt hàm LangManusAgent.run_and_return().
• Ứng dụng hiển thị báo cáo Markdown bằng st.markdown() và lặp qua từng đường dẫn biểu đồ, sau đó render chúng bằng st.image().

Cấu trúc cuối cùng của dự án phân tích GitHub dùng LangManus của chúng ta sẽ như sau:

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.pngĐược hỗ trợ bởi

Bước 5: Kiểm thử ứng dụng StreamLit

Giờ chúng ta đã có đầy đủ các thành phần, hãy chạy ứng dụng Streamlit. Chạy lệnh sau trong terminal:

streamlit run streamlit_app.pyĐược hỗ trợ bởi

Nhấp nút "Run Analysis on Trending Repo" trong trình duyệt của bạn, và các tác tử chạy bằng LangManus sẽ truy xuất, phân tích và trình bày thông tin chi tiết về kho GitHub trong vài giây.

Kết luận

LangManus cho phép chúng ta xây dựng các hệ thống đa tác tử có cấu trúc tương tác với dữ liệu thế giới thực. Trong hướng dẫn này, chúng ta đã tạo một trình phân tích kho GitHub tự động hoàn toàn, trong đó chúng ta:

• Nghiên cứu các kho đang thịnh hành.
• Thu thập lịch sử commit.
• Trực quan hóa xu hướng bằng biểu đồ
• Tóm tắt kết quả bằng Markdown

LangManus có tiềm năng lớn để xây dựng các tác tử nghiên cứu, bảng điều khiển và trợ lý dựa trên dữ liệu.