LangManus: una guida con progetto demo

LangManus è un framework open-source, guidato dalla community, per l'automazione con AI, progettato per creare sistemi strutturati multi-agente basati su modelli linguistici. Con LangManus, puoi creare agenti intelligenti che combinano pianificazione, ricerca, coding, interazione con il browser e reporting in un'unica pipeline coerente.

In questo tutorial, ti guiderò nella creazione di una demo funzionante con LangManus che:

• Trova un repository open-source di tendenza su GitHub
• Esegue lo scraping delle attività di commit recenti
• Analizza gli aggiornamenti di funzionalità e i pattern di contribuzione
• Genera un report in Markdown
• Visualizza le tendenze di attività con diversi grafici

Che cos'è LangManus?

L'architettura di LangManus supporta controllo granulare, verificabilità ed estendibilità. Si basa su strumenti potenti come:

• LangGraph per l'orchestrazione degli agenti.
• Browser-Use per l'interazione web.
• LiteLLM per l'unificazione dei modelli.

Con LangManus, puoi creare agenti intelligenti che combinano pianificazione, ricerca, coding, interazione con il browser e reporting in un'unica pipeline, alimentata da:

• YAML o configurazione basata su .env per modelli e chiavi.
• API LLM compatibili con OpenAI (tramite LiteLLM).
• Integrazione con strumenti come Jina e Tavily per la ricerca.
• Supporto per modelli vision, REPL, sessioni browser e formattazione markdown.

Panoramica del progetto LangManus: analizzatore di repository GitHub 

L'app che andremo a costruire è un assistente interattivo che utilizza le capacità multi-agente di LangManus per analizzare un repository GitHub di tendenza. Per configurare gli agenti LangManus, ci serve una struttura multi-file in cui ogni file ha un ruolo distinto nel sistema multi-agente:

• planner.py: definisce la sequenza dei task.
• agent.py: coordina gli agenti e mantiene il contesto.
• agents/: contiene agenti specializzati per ricerca, scraping, analisi e reporting.
• streamlit_app.py: include il livello UI per eseguire la pipeline e visualizzare i risultati.

Implementiamoli uno per uno.

Passaggio 1: Prerequisiti

Prima di iniziare, assicuriamoci di avere installati i seguenti strumenti e librerie:

python3 --version  # Python 3.8+
pip install requests beautifulsoup4 matplotlib streamlitOfferto da

Controlla la versione di Python, che dovrebbe essere almeno la 3.8 o superiore. Poi, installa semplicemente tutte le altre dipendenze indicate sopra. Ti servirà anche un token API di GitHub per evitare i limiti di rate e impostarlo come variabile d'ambiente tramite terminale.

Per generare i token GitHub:

• Vai su GitHub Tokens
• Clicca Generate New Token e seleziona la versione classica. Non selezionare altro.
• Clicca Generate per creare il token.
• Copia e conserva il token in modo sicuro: verrà usato per l'autenticazione nelle richieste API.

Ora esegui il seguente comando:

export GITHUB_TOKEN=your_personal_token_hereOfferto da

Passaggio 2: Creare il Planner e il Controller degli agenti 

Ora che abbiamo installato tutte le dipendenze, costruiamo il planner e il controller degli agenti per la nostra applicazione.

1. Creare un file planner.py

Il file planner.py definisce un semplice piano in 4 step per coprire ogni task richiesto, come research, browse, analyze e report. 

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'}
    ]Offerto da

La funzione sopra restituisce un piano di task passo passo per il sistema, in cui ogni step:

• Specifica quale agente è responsabile (agent); e
• Definisce cosa deve fare quell'agente (task).

2. Creare un file agent.py

Il file dell'agente definisce la classe core LangManusAgent, che orchestra tutti gli agenti e mantiene un contesto condiviso mentre eseguono i loro compiti.

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']Offerto da

Il codice inizia chiamando la funzione plan_task() per recuperare un elenco di step (definiti in planner.py). Quindi esegue ogni step invocando l'agente specializzato appropriato nel seguente ordine:

• L'agente researcher recupera un repository GitHub di tendenza.
• L'agente browser esegue lo scraping dell'attività di commit del repository usando la GitHub API.
• L'agente coder analizza i dati dei commit e genera i grafici.
• L'agente reporter compila il tutto in un report finale in markdown.

Ogni agente salva i propri risultati nel dizionario context, consentendo agli agenti a valle di accedere e costruire sui risultati precedenti.

Passaggio 3: Implementare gli agenti LangManus

Ora che abbiamo le funzioni core pronte, costruiamo gli agenti per la nostra applicazione.

1. Creare un file agents/researcher.py

Questo agente identifica un progetto Python open-source popolare da GitHub eseguendo lo scraping della pagina 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}"Offerto da

Ecco come funziona:

• L'agente invia una richiesta GET al repository GitHub e analizza la risposta HTML restituita usando BeautifulSoup.
• Poi individua il primo progetto elencato sotto il tag trending usando un selettore CSS ed estrae il percorso URL del repository (ad es., /user/repo)
• Infine, costruisce e restituisce l'URL completo di GitHub come "https://github.com/user/repo"

2. Creare un file agents/browser.py

L'agente browser viene utilizzato per recuperare l'attività recente dal repository GitHub selezionato. Usa la GitHub REST API per raccogliere cronologia dei commit e metadati.

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
    }Offerto da

Ecco cosa fa la funzione sopra:

• Estrae la parte user/repo dell'URL di GitHub e forma una richiesta alla GitHub API.
• L'agente quindi analizza il JSON restituito per estrarre:
• SHA del commit
• Messaggio del commit
• Nome dell'autore
• Timestamp
• Questi valori sono memorizzati in due liste: commits e commit_dates. 
• Infine, la funzione restituisce un dizionario contenente entrambi, che viene utilizzato dagli agenti a valle per ulteriori analisi e visualizzazioni.

3. Creare un file agents/coder.py

Questo agente elabora e analizza la cronologia dei commit raccolta da GitHub e genera sia un riepilogo testuale sia insight visivi usando 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, chartsOfferto da

Questo agente elabora la cronologia dei commit di GitHub e genera un riepilogo in Markdown e grafici usando matplotlib. Classifica i commit in gruppi predefiniti come bug fix, feature, documentazione e altro tramite il matching di parole chiave. Poi usa matplotlib per generare tre grafici informativi che mostrano:

• Attività dei commit negli ultimi 30 giorni
• Commit per categoria
• Le parole chiave più frequenti nei messaggi di commit

Infine, l'agente crea un riepilogo in markdown evidenziando i commit chiave in ogni categoria e restituisce sia il riepilogo sia i percorsi dei grafici per il rendering nel report.

4. Creare un file agents/reporter.py

L'agente reporter genera il report finale in Markdown che combina:

• Il link al repository GitHub
• Un elenco puntato dei commit recenti
• Un riepilogo categorizzato dei messaggi di commit (dal 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 mdOfferto da

La funzione generate_report() assembla il report finale in Markdown usando l'URL di GitHub, i dati dei commit, l'analisi categorizzata e i percorsi ai grafici. Restituisce una singola stringa in formato markdown che può essere visualizzata nel terminale o renderizzata in un'interfaccia come Streamlit. Restituisce una singola stringa in formato markdown che può essere stampata sulla console o renderizzata in Streamlit.

Passaggio 4: Costruire la UI con Streamlit

L'app Streamlit consente di eseguire l'intera pipeline con un solo clic. Crea un file streamlit_app.py e aggiungi il seguente codice: 

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.")Offerto da

Ecco cosa fa il codice:

• Usa la libreria streamlit per creare una dashboard minimale tale che, cliccando il pulsante di analisi, venga attivata la funzione LangManusAgent.run_and_return().
• L'app mostra il report in Markdown tramite st.markdown() e itera su ciascun percorso dei grafici per poi renderizzarli con la funzione st.image().

La struttura finale del nostro progetto di analisi GitHub basato su LangManus dovrebbe essere la seguente:

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.pngOfferto da

Passaggio 5: Testare l'app StreamLit

Ora che abbiamo tutti i componenti al loro posto, eseguiamo la nostra applicazione Streamlit. Esegui il seguente comando nel terminale:

streamlit run streamlit_app.pyOfferto da

Clicca il pulsante "Run Analysis on Trending Repo" nel browser e i tuoi agenti basati su LangManus recupereranno, analizzeranno e presenteranno insight sul repository GitHub in pochi secondi.

Conclusione

LangManus ci permette di costruire sistemi multi-agente strutturati che interagiscono con dati reali. In questa guida abbiamo creato un analizzatore di repo GitHub completamente automatizzato in cui abbiamo:

• Ricercato i repository di tendenza.
• Eseguito lo scraping della cronologia dei commit.
• Visualizzato le tendenze con grafici
• Riepilogato i risultati in Markdown

LangManus ha un grande potenziale per costruire agenti di ricerca, dashboard e assistenti data-driven.