LangManus: Een gids met demoproject

LangManus is een open-source, community-gedreven AI-automatiseringsframework om gestructureerde, multi-agentsystemen te bouwen met taalmodellen. Met LangManus kun je intelligente agents bouwen die planning, research, coderen, browserinteractie en rapportage combineren in één samenhangende pijplijn.

In deze tutorial laat ik je een werkende demo bouwen met LangManus die:

• Een trending open-source-repository op GitHub vindt
• De recente commit-activiteit scraped
• Feature-updates en bijdragepatronen analyseert
• Een markdown-rapport genereert
• Activiteitstrends visualiseert met meerdere grafieken

Wat is LangManus?

De architectuur van LangManus ondersteunt fijne controle, controleerbaarheid en uitbreidbaarheid. Het bouwt voort op krachtige tools zoals:

• LangGraph voor agent-orchestratie.
• Browser-Use voor webinteractie.
• LiteLLM voor modelunificatie.

Met LangManus kun je intelligente agents bouwen die planning, research, coderen, browserinteractie en rapportage combineren in één samenhangende pijplijn, aangedreven door:

• YAML- of .env-gebaseerde configuratie voor modellen en sleutels.
• OpenAI-compatibele LLM-API's (via LiteLLM).
• Integratie met tools zoals Jina en Tavily voor zoekopdrachten.
• Ondersteuning voor vision-modellen, REPL's, browsersessies en markdown-opmaak.

Projectoverzicht LangManus: GitHub Repository Analyzer 

De app die we bouwen is een interactieve assistent die de multi-agentcapaciteiten van LangManus gebruikt om een trending GitHub-repository te analyseren. Om LangManus Agents op te zetten, hebben we een bestandsstructuur met meerdere bestanden nodig waarin elk bestand een duidelijke rol heeft in het multi-agentsysteem:

• planner.py: definieert de volgorde van taken.
• agent.py: coördineert de agents en bewaart de context.
• agents/: bevat gespecialiseerde agents voor research, scraping, analyse en rapportage.
• streamlit_app.py: bevat de UI-laag om de pijplijn te draaien en resultaten te visualiseren.

Laten we dit stap voor stap implementeren.

Stap 1: Vereisten

Voordat we beginnen, zorgen we dat de volgende tools en libraries zijn geïnstalleerd:

python3 --version  # Python 3.8+
pip install requests beautifulsoup4 matplotlib streamlitMogelijk gemaakt door

Controleer de Python-versie; die moet minimaal 3.8 zijn. Installeer daarna simpelweg alle andere hierboven genoemde dependencies. Je hebt ook een GitHub API-token nodig om rate limits te vermijden en stelt dat in als omgevingsvariabele via de terminal.

Zo genereer je GitHub-tokens:

• Ga naar GitHub Tokens
• Klik op Generate New Token en selecteer de klassieke versie. Selecteer niets anders.
• Klik op Generate om het token aan te maken.
• Kopieer en bewaar het token veilig; het wordt gebruikt voor authenticatie bij API-verzoeken.

Voer nu de volgende opdracht uit:

export GITHUB_TOKEN=your_personal_token_hereMogelijk gemaakt door

Stap 2: De planner en agentcontroller maken 

Nu alle dependencies zijn geïnstalleerd, bouwen we de planner en agentcontroller voor onze applicatie.

1. Een planner.py-bestand maken

Het bestand planner.py definieert een eenvoudig 4-stappenplan om alle vereiste taken te dekken: research, browsen, analyseren en rapporteren. 

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'}
    ]Mogelijk gemaakt door

Bovenstaande functie geeft een stapsgewijs takenplan voor het systeem terug, waarbij elke stap:

• Aangeeft welke agent verantwoordelijk is (agent); en
• Definieert wat die agent moet doen (task).

2. Een agent.py-bestand maken

Het agentbestand definieert de kernklasse LangManusAgent, die alle agents orkestreert en een gedeelde context bijhoudt terwijl ze hun taken uitvoeren.

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']Mogelijk gemaakt door

De code begint met het aanroepen van de functie plan_task() om een lijst met stappen op te halen (gedefinieerd in planner.py). Daarna voert hij elke stap uit door de juiste gespecialiseerde agent in de volgende volgorde aan te roepen:

• De researcher-agent haalt een trending GitHub-repository op.
• De browser-agent scraped de commit-activiteit van de repository via de GitHub API.
• De coder-agent analyseert de commitdata en genereert grafieken.
• De reporter-agent maakt er een definitief markdown-rapport van.

Elke agent slaat zijn resultaten op in de context-dictionary, zodat downstream-agents toegang hebben tot en kunnen voortbouwen op eerdere outputs.

Stap 3: De LangManus-agents implementeren

Nu de kernfuncties klaar zijn, bouwen we de agents voor onze applicatie.

1. Een agents/researcher.py-bestand maken

Deze agent identificeert een populair open-source Python-project op GitHub door de GitHub Trending-pagina te scrapen.

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}"Mogelijk gemaakt door

Zo werkt het:

• De agent stuurt een GET-verzoek naar de GitHub-repository en parseert de teruggestuurde HTML-respons met BeautifulSoup.
• Vervolgens lokaliseert hij het eerste project onder de trending-tag met een CSS-selector en extraheert het repository-URL-pad (bijv. /user/repo)
• Tot slot construeert en retourneert hij de volledige GitHub-URL zoals “https://github.com/user/repo”

2. Een agents/browser.py-bestand maken

De browser-agent haalt de recente activiteit op van de geselecteerde GitHub-repository. Hij gebruikt de GitHub REST API om de commitgeschiedenis en metadata te verzamelen.

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
    }Mogelijk gemaakt door

Dit doet de bovenstaande functie:

• Hij extraheert het user/repo-gedeelte van de GitHub-URL en vormt een GitHub API-verzoek.
• De agent parseert vervolgens de teruggestuurde JSON om het volgende te extraheren:
• Commit SHA
• Commitbericht
• Naam van de auteur
• Tijdstempel
• Deze waarden worden opgeslagen in twee lijsten: commits en commit_dates. 
• Tot slot retourneert de functie een dictionary met beide, die door downstream-agents wordt gebruikt voor verdere analyse en visualisatie.

3. Een agents/coder.py-bestand maken

Deze agent verwerkt en analyseert de commitgeschiedenis die van GitHub is opgehaald en genereert zowel een tekstuele samenvatting als visuele inzichten met 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, chartsMogelijk gemaakt door

Deze agent verwerkt de GitHub-commitgeschiedenis en genereert een Markdown-samenvatting en visuele grafieken met matplotlib. Hij categoriseert commits in vooraf gedefinieerde groepen zoals bugfixes, features, documentatie en meer via keywordmatching. Vervolgens gebruikt hij matplotlib om drie inzichtelijke grafieken te maken die het volgende tonen:

• Commitactiviteit over de afgelopen 30 dagen
• Commits per categorie
• De meest gebruikte keywords in commitberichten

Tot slot maakt de agent een markdown-samenvatting met belangrijke commits per categorie en retourneert zowel de samenvatting als de padnamen van de grafieken voor weergave in het rapport.

4. Een agents/reporter.py-bestand maken

De reporter-agent genereert het definitieve Markdown-rapport dat het volgende combineert:

• De GitHub-repositorylink
• Een opsomming van recente commits
• Een gecategoriseerde samenvatting van commitberichten (van de coder-agent)

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 mdMogelijk gemaakt door

De functie generate_report() stelt het definitieve Markdown-rapport samen met de GitHub-URL, commitdata, gecategoriseerde analyse en grafiekpaden. Hij retourneert één markdown-geformatteerde string die in de terminal kan worden getoond of gerenderd in een UI zoals Streamlit. Hij retourneert één markdown-geformatteerde string die in de console kan worden geprint of in Streamlit kan worden gerenderd.

Stap 4: De UI bouwen met Streamlit

De Streamlit-app laat gebruikers de hele pijplijn met één klik draaien. Maak een bestand streamlit_app.py en voeg de volgende code toe: 

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.")Mogelijk gemaakt door

Dit doet de code:

• Hij gebruikt de library streamlit om een minimal dashboard te maken zodat, wanneer je op de analyseknop klikt, de functie LangManusAgent.run_and_return() wordt gestart.
• De app toont het Markdown-rapport met de functie st.markdown() en doorloopt elke grafiekpad; vervolgens worden ze gerenderd met de functie st.image().

De uiteindelijke structuur van ons door LangManus aangedreven GitHub-analyseproject ziet er zo uit:

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.pngMogelijk gemaakt door

Stap 5: De StreamLit-app testen

Nu alle componenten klaar zijn, draaien we onze Streamlit-applicatie. Voer de volgende opdracht uit in de terminal:

streamlit run streamlit_app.pyMogelijk gemaakt door

Klik in je browser op de knop "Run Analysis on Trending Repo" en je door LangManus aangedreven agents halen in enkele seconden GitHub-repository-inzichten op, analyseren ze en presenteren ze.

Conclusie

Met LangManus kunnen we gestructureerde multi-agentsystemen bouwen die met echte data interacteren. In deze gids maakten we een volledig geautomatiseerde GitHub-repo-analyzer waarbij we:

• De trending repositories hebben onderzocht.
• De commitgeschiedenis hebben gescraped.
• Trends hebben gevisualiseerd met grafieken
• Resultaten hebben samengevat in Markdown

LangManus heeft serieuze potentie voor het bouwen van research-agents, dashboards en datagedreven assistenten.