LangManus: डेमो प्रोजेक्ट सहित एक गाइड

LangManus एक ओपन-सोर्स, समुदाय-प्रेरित AI ऑटोमेशन फ्रेमवर्क है, जो भाषा मॉडलों का उपयोग करके संरचित, मल्टी-एजेंट सिस्टम बनाने के लिए डिज़ाइन किया गया है। LangManus के साथ, आप ऐसे बुद्धिमान एजेंट बना सकते हैं जो योजना, शोध, कोडिंग, ब्राउज़र इंटरैक्शन और रिपोर्टिंग को एक एकीकृत पाइपलाइन में जोड़ते हैं।

इस ट्यूटोरियल में, मैं आपको LangManus के साथ एक कार्यशील डेमो बनाने के लिए मार्गदर्शन दूंगा, जो:

• GitHub पर एक ट्रेंडिंग ओपन-सोर्स रिपॉजिटरी खोजता है
• हालिया कमिट गतिविधि स्क्रैप करता है
• फ़ीचर अपडेट और योगदान पैटर्न का विश्लेषण करता है
• एक मार्कडाउन रिपोर्ट बनाता है
• कई चार्ट के माध्यम से गतिविधि रुझानों का विज़ुअलाइज़ेशन करता है

LangManus क्या है?

LangManus की आर्किटेक्चर सूक्ष्म नियंत्रण, ऑडिटेबिलिटी और एक्स्टेंसिबिलिटी का समर्थन करती है। यह निम्नलिखित शक्तिशाली टूल्स पर आधारित है:

• LangGraph एजेंट ऑर्केस्ट्रेशन के लिए।
• Browser-Use वेब इंटरैक्शन के लिए।
• LiteLLM मॉडल एकीकरण के लिए।

LangManus के साथ, आप ऐसे बुद्धिमान एजेंट बना सकते हैं जो योजना, शोध, कोडिंग, ब्राउज़र इंटरैक्शन और रिपोर्टिंग को एक एकीकृत पाइपलाइन में जोड़ते हैं, जो निम्न से संचालित होती है:

• YAML या .env-आधारित कॉन्फ़िगरेशन, मॉडलों और कीज़ के लिए।
• OpenAI-संगत LLM API (LiteLLM के माध्यम से)।
• Jina और Tavily जैसे टूल्स के साथ इंटीग्रेशन, सर्च के लिए।
• विज़न मॉडल, REPLs, ब्राउज़र सेशन और मार्कडाउन फॉर्मेटिंग का समर्थन।

LangManus प्रोजेक्ट अवलोकन: GitHub रिपॉजिटरी एनालाइज़र 

हम जो ऐप बनाएंगे वह एक इंटरैक्टिव असिस्टेंट है जो LangManus की मल्टी-एजेंट क्षमताओं का उपयोग करके किसी ट्रेंडिंग GitHub रिपॉजिटरी का विश्लेषण करता है। LangManus एजेंट सेट करने के लिए, हमें एक मल्टी-फ़ाइल संरचना चाहिए, जहाँ प्रत्येक फ़ाइल मल्टी-एजेंट सिस्टम में अलग भूमिका निभाती है:

• planner.py: यह कार्यों के क्रम को परिभाषित करता है।
• agent.py: यह फ़ाइल एजेंटों का समन्वय करती है और संदर्भ बनाए रखती है।
• agents/: इस फ़ोल्डर में शोध, स्क्रैपिंग, विश्लेषण और रिपोर्टिंग के लिए विशेषज्ञ एजेंट होते हैं।
• streamlit_app.py: इसमें पाइपलाइन चलाने और परिणामों को विज़ुअलाइज़ करने के लिए UI लेयर होती है।

आइए इन्हें एक-एक करके इम्प्लीमेंट करते हैं।

चरण 1: पूर्वापेक्षाएँ

शुरू करने से पहले, सुनिश्चित करें कि हमारे पास निम्नलिखित टूल और लाइब्रेरीज़ इंस्टॉल हैं:

python3 --version  # Python 3.8+
pip install requests beautifulsoup4 matplotlib streamlitसंचालित द्वारा

Python का वर्शन जाँचें, जो कम से कम 3.8 या अधिक होना चाहिए। फिर, ऊपर बताए गए अन्य सभी डिपेंडेंसीज़ इंस्टॉल करें। आपको रेट लिमिट से बचने के लिए एक GitHub API टोकन की भी आवश्यकता होगी और इसे टर्मिनल का उपयोग करके एनवायरनमेंट वेरिएबल के रूप में सेट करें।

GitHub टोकन बनाने के लिए:

• यहाँ जाएँ GitHub Tokens
• यहाँ क्लिक करें Generate New Token और क्लासिक संस्करण चुनें। कुछ और न चुनें।
• टोकन बनाने के लिए Generate पर क्लिक करें।
• टोकन को कॉपी करें और सुरक्षित रखें, क्योंकि इसे API रिक्वेस्ट में ऑथेंटिकेशन के लिए उपयोग किया जाएगा।

अब, निम्न कमांड चलाएँ:

export GITHUB_TOKEN=your_personal_token_hereसंचालित द्वारा

चरण 2: प्लानर और एजेंट कंट्रोलर बनाना 

अब जब हमारे पास सभी डिपेंडेंसीज़ इंस्टॉल हैं, तो आइए अपने एप्लिकेशन के लिए प्लानर और एजेंट कंट्रोलर बनाते हैं।

1. planner.py फ़ाइल बनाना

planner.py फ़ाइल एक सरल 4-चरणीय योजना परिभाषित करती है, जो आवश्यक प्रत्येक कार्य को कवर करती है, जैसे research, browse, analyze और 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'}
    ]संचालित द्वारा

ऊपर दिया गया फ़ंक्शन सिस्टम के लिए चरण-दर-चरण कार्य योजना लौटाता है, जहाँ प्रत्येक चरण:

• यह बताता है कि किस एजेंट की ज़िम्मेदारी है (agent); और
• यह परिभाषित करता है कि वह एजेंट क्या करेगा (task)।

2. agent.py फ़ाइल बनाना

एजेंट फ़ाइल मुख्य LangManusAgent क्लास को परिभाषित करती है, जो सभी एजेंटों का ऑर्केस्ट्रेशन करती है और उनके कार्य करते समय साझा संदर्भ बनाए रखती है।

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']संचालित द्वारा

कोड plan_task() फ़ंक्शन को कॉल करके शुरू होता है ताकि चरणों की सूची (जो planner.py में परिभाषित है) प्राप्त हो सके। फिर, यह निम्न क्रम में उपयुक्त विशेषज्ञ एजेंट को बुलाकर प्रत्येक चरण चलाता है:

•  researcher एजेंट एक ट्रेंडिंग GitHub रिपॉजिटरी लाता है।
•  browser एजेंट GitHub API का उपयोग करके रिपॉजिटरी की कमिट गतिविधि स्क्रैप करता है।
•  coder एजेंट कमिट डेटा का विश्लेषण करता है और चार्ट बनाता है।
•  reporter एजेंट सब कुछ मिलाकर अंतिम मार्कडाउन रिपोर्ट बनाता है।

प्रत्येक एजेंट अपने परिणाम context डिक्शनरी में संग्रहीत करता है, जिससे डाउनस्ट्रीम एजेंट पूर्ववर्ती आउटपुट तक पहुँच पाते हैं और उन पर निर्माण कर सकते हैं।

चरण 3: LangManus एजेंट्स को लागू करना

अब जब हमारे पास कोर फंक्शन तैयार हैं, तो आइए अपने एप्लिकेशन के लिए एजेंट बनाते हैं।

1. agents/researcher.py फ़ाइल बनाना

यह एजेंट GitHub की GitHub Trending पेज को स्क्रैप करके एक लोकप्रिय ओपन-सोर्स Python प्रोजेक्ट की पहचान करता है।

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}"संचालित द्वारा

यह इस प्रकार काम करता है:

• एजेंट GitHub रिपॉजिटरी पेज को GET रिक्वेस्ट भेजता है और BeautifulSoup का उपयोग करके प्राप्त HTML रिस्पॉन्स को पार्स करता है।
• इसके बाद यह ट्रेंडिंग टैग के तहत सूचीबद्ध पहले प्रोजेक्ट को CSS सेलेक्टर के जरिए ढूँढता है और रिपॉजिटरी URL पाथ निकालता है (जैसे, /user/repo)
• अंत में, यह पूर्ण GitHub URL बनाता है और लौटाता है, जैसे “https://github.com/user/repo”

2. agents/browser.py फ़ाइल बनाना

ब्राउज़र एजेंट चयनित GitHub रिपॉजिटरी से हालिया गतिविधि लाने के लिए उपयोग होता है। यह कमिट हिस्ट्री और मेटाडेटा इकट्ठा करने के लिए GitHub REST API का उपयोग करता है।

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
    }संचालित द्वारा

ऊपर दिए गए फ़ंक्शन द्वारा यह किया जाता है:

• यह GitHub URL के user/repo भाग को निकालता है और GitHub API रिक्वेस्ट बनाता है।
• एजेंट फिर लौटे हुए JSON को पार्स करके निम्न निकालता है:
• कमिट SHA
• कमिट संदेश
• लेखक का नाम
• टाइमस्टैम्प
• ये मान दो सूचियों में संग्रहीत होते हैं: commits और commit_dates. 
• अंततः, फ़ंक्शन दोनों को समाहित करने वाली एक डिक्शनरी लौटाता है, जिसे आगे विश्लेषण और विज़ुअलाइज़ेशन के लिए डाउनस्ट्रीम एजेंट उपयोग करते हैं।

3. agents/coder.py फ़ाइल बनाना

यह एजेंट GitHub से एकत्रित कमिट हिस्ट्री को प्रोसेस और विश्लेषित करता है तथा 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संचालित द्वारा

यह एजेंट GitHub कमिट हिस्ट्री को प्रोसेस करता है और matplotlib का उपयोग करके एक Markdown सारांश और विज़ुअल चार्ट बनाता है। यह कीवर्ड मिलान के माध्यम से कमिट्स को बग फिक्स, फीचर्स, डॉक्यूमेंटेशन आदि जैसी पूर्व-परिभाषित श्रेणियों में वर्गीकृत करता है। इसके बाद यह matplotlib से तीन सूझबूझ भरे चार्ट तैयार करता है, जो दर्शाते हैं:

• पिछले 30 दिनों में कमिट गतिविधि
• श्रेणी के अनुसार कमिट्स
• कमिट संदेशों में सबसे अधिक बार आने वाले कीवर्ड

अंत में, एजेंट प्रत्येक श्रेणी में प्रमुख कमिट्स को उजागर करते हुए एक markdown सारांश बनाता है और रिपोर्ट में रेंडरिंग के लिए सारांश तथा चार्ट पथ दोनों लौटाता है।

4. agents/reporter.py फ़ाइल बनाना

रिपोर्टर एजेंट अंतिम Markdown रिपोर्ट बनाता है, जो इनको संयोजित करती है:

• GitHub रेपोज़िटरी लिंक
• हालिया कमिट्स की बुलेट सूची
• कमिट संदेशों का श्रेणीबद्ध सारांश (कोडर एजेंट से)

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संचालित द्वारा

यह generate_report() फ़ंक्शन GitHub URL, कमिट डेटा, श्रेणीबद्ध विश्लेषण और चार्ट पथों का उपयोग करके अंतिम Markdown रिपोर्ट तैयार करता है। यह एकल markdown-फ़ॉर्मैटेड स्ट्रिंग लौटाता है, जिसे टर्मिनल में दिखाया जा सकता है या Streamlit जैसी UI में रेंडर किया जा सकता है। यह एकल markdown-फ़ॉर्मैटेड स्ट्रिंग लौटाता है, जिसे कंसोल पर प्रिंट किया जा सकता है या Streamlit में रेंडर किया जा सकता है।

चरण 4: Streamlit के साथ UI बनाना

Streamlit ऐप उपयोगकर्ताओं को एक क्लिक में पूरी पाइपलाइन चलाने देता है। एक streamlit_app.py फ़ाइल बनाएँ और निम्न कोड जोड़ें: 

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.")संचालित द्वारा

यहाँ कोड क्या करता है:

• यह streamlit लाइब्रेरी का उपयोग करके एक मिनिमल डैशबोर्ड बनाता है, ताकि बटन पर क्लिक करने पर LangManusAgent.run_and_return() फ़ंक्शन ट्रिगर हो।
• ऐप st.markdown() फ़ंक्शन से Markdown रिपोर्ट दिखाता है और प्रत्येक चार्ट पथ पर लूप लगाकर उन्हें st.image() फ़ंक्शन से रेंडर करता है।

हमारे LangManus-समर्थित GitHub विश्लेषण प्रोजेक्ट की अंतिम संरचना इस प्रकार होनी चाहिए:

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संचालित द्वारा

चरण 5: StreamLit ऐप का परीक्षण

अब जबकि हमारे पास सभी घटक موجود हैं, आइए अपना Streamlit अनुप्रयोग चलाएँ। टर्मिनल में यह कमांड चलाएँ:

streamlit run streamlit_app.pyसंचालित द्वारा

अपने ब्राउज़र में "Run Analysis on Trending Repo" बटन पर क्लिक करें, और आपके LangManus-संचालित एजेंट सेकंडों में GitHub रेपोज़िटरी से इनसाइट्स लाकर, उनका विश्लेषण कर प्रस्तुत करेंगे।

निष्कर्ष

LangManus हमें संरचित मल्टी-एजेंट सिस्टम बनाने में सक्षम बनाता है, जो वास्तविक दुनिया के डेटा के साथ इंटरैक्ट करते हैं। इस गाइड में, हमने एक पूर्णत: स्वचालित GitHub रेपो विश्लेषक बनाया, जहाँ हमने:

• ट्रेंडिंग रेपोज़िटरीज़ पर शोध किया।
• कमिट हिस्ट्री स्क्रैप की।
• रुझानों को चार्ट्स के साथ विज़ुअलाइज़ किया
• परिणामों को Markdown में संक्षेपित किया

LangManus में शोध एजेंट, डैशबोर्ड और डेटा-चालित असिस्टेंट बनाने की ठोस संभावनाएँ हैं।