LangManus: Demo Projeyle Bir Rehber

LangManus; dil modelleri kullanarak yapılandırılmış, çoklu aracılı sistemler kurmak için tasarlanmış, açık kaynaklı ve topluluk odaklı bir yapay zeka otomasyon çerçevesidir. LangManus ile planlama, araştırma, kodlama, tarayıcı etkileşimi ve raporlamayı tek bir bütünleşik hat içinde birleştiren akıllı ajanlar oluşturabilirsiniz.

Bu eğitimde, LangManus ile aşağıdakileri yapan çalışan bir demo oluşturmanıza rehberlik edeceğim:

• GitHub’da trend olan bir açık kaynak deposu bulur
• Son commit etkinliğini tarar
• Özellik güncellemelerini ve katkı kalıplarını analiz eder
• Bir markdown raporu üretir
• Etkinlik eğilimlerini birden fazla grafikle görselleştirir

LangManus Nedir?

LangManus’un mimarisi ince ayarlı kontrol, denetlenebilirlik ve genişletilebilirlik sağlar. Şu güçlü araçlar üzerine inşa edilmiştir:

• LangGraph ile ajan orkestrasyonu.
• Browser-Use ile web etkileşimi.
• LiteLLM ile model birleştirme.

LangManus ile planlama, araştırma, kodlama, tarayıcı etkileşimi ve raporlamayı tek bir bütünleşik hat içinde birleştiren akıllı ajanlar geliştirebilirsiniz; şu yeteneklerden güç alır:

• YAML veya .env tabanlı model ve anahtar yapılandırması.
• OpenAI uyumlu LLM API’leri (LiteLLM üzerinden).
• Arama için Jina ve Tavily gibi araçlarla entegrasyon.
• Görsel modeller, REPL’ler, tarayıcı oturumları ve markdown biçimlendirme desteği.

LangManus Proje Genel Bakışı: GitHub Depo Analizörü 

Oluşturacağımız uygulama, LangManus’un çoklu aracılı yeteneklerini kullanarak trend olan bir GitHub deposunu analiz eden etkileşimli bir asistandır. LangManus Ajanlarını kurmak için, her dosyanın çoklu ajan sisteminde farklı bir rol oynadığı çok dosyalı bir yapıya ihtiyacımız var:

• planner.py: Görevlerin sırasını tanımlar.
• agent.py: Ajanları koordine eder ve bağlamı korur.
• agents/: Araştırma, scraping, analiz ve raporlama için uzmanlaşmış ajanları içerir.
• streamlit_app.py: Hattı çalıştırmak ve sonuçları görselleştirmek için UI katmanını barındırır.

Bunları tek tek uygulayalım.

Adım 1: Önkoşullar

Başlamadan önce, aşağıdaki araç ve kütüphanelerin yüklü olduğundan emin olalım:

python3 --version  # Python 3.8+
pip install requests beautifulsoup4 matplotlib streamlitAltyapı:

Python sürümünüzü kontrol edin; en az 3.8 veya üzeri olmalıdır. Ardından yukarıda belirtilen diğer bağımlılıkları yükleyin. Ayrıca hız sınırlarına takılmamak için bir GitHub API belirtecine ihtiyaç duyacaksınız; bunu terminal üzerinden ortam değişkeni olarak ayarlayın.

GitHub belirteci oluşturmak için:

• Şuraya gidin: GitHub Tokens
•  Generate New Token’a tıklayın ve klasik sürümü seçin. Başka hiçbir şeyi seçmeyin.
• Belirteci oluşturmak için Generate’e tıklayın.
• Belirteci güvenli biçimde kopyalayıp saklayın; API isteklerinde kimlik doğrulama için kullanılacaktır.

Şimdi şu komutu çalıştırın:

export GITHUB_TOKEN=your_personal_token_hereAltyapı:

Adım 2: Planlayıcı ve Ajan Denetleyicisini Oluşturma 

Artık tüm bağımlılıkları yükledik; uygulamamız için planlayıcıyı ve ajan denetleyicisini oluşturalım.

1. planner.py dosyası oluşturma

planner.py dosyası; araştırma, gezinme, analiz ve raporlama gibi gerekli her görevi kapsayan basit bir 4 adımlı plan tanımlar. 

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'}
    ]Altyapı:

Yukarıdaki işlev, sistem için adım adım bir görev planı döndürür; her adımda:

• Hangi ajanın sorumlu olduğunu belirtir (agent); ve
• O ajanın ne yapması gerektiğini tanımlar (task).

2. agent.py dosyası oluşturma

Ajan dosyası, tüm ajanları yöneten ve görevleri yerine getirirken paylaşılan bir bağlamı sürdüren çekirdek LangManusAgent sınıfını tanımlar.

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']Altyapı:

Kod, adım listesini almak için önce plan_task() işlevini çağırır (planner.py’de tanımlanmıştır). Ardından aşağıdaki sırayla uygun uzman ajanı çağırarak her adımı çalıştırır:

• researcher ajanı trend olan bir GitHub deposu getirir.
• browser ajanı GitHub API’sini kullanarak deponun commit etkinliğini tarar.
• coder ajanı commit verilerini analiz eder ve grafikler üretir.
• reporter ajanı her şeyi nihai bir markdown raporunda derler.

Her ajan, sonuçlarını context sözlüğünde depolar; böylece aşağı yöndeki ajanlar önceki çıktılara erişip onların üzerine inşa edebilir.

Adım 3: LangManus Ajanlarını Uygulama

Artık çekirdek işlevler hazır; uygulamamız için ajanları oluşturalım.

1. agents/researcher.py dosyası oluşturma

Bu ajan, GitHub Trending sayfasını tarayarak popüler bir açık kaynak Python projesini belirler.

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}"Altyapı:

Nasıl çalıştığına bakalım:

• Ajan, GitHub sayfasına bir GET isteği gönderir ve dönen HTML yanıtını BeautifulSoup ile ayrıştırır.
• Ardından trend etiketi altındaki ilk projeyi bir CSS seçiciyle bulur ve depo URL yolunu çıkarır (örn. /user/repo)
• Son olarak, “https://github.com/user/repo” gibi tam GitHub URL’sini oluşturur ve döndürür

2. agents/browser.py dosyası oluşturma

Tarayıcı ajanı, seçilen GitHub deposundan son etkinliği almak için kullanılır. Commit geçmişini ve meta verileri toplamak üzere GitHub REST API’sini kullanır.

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
    }Altyapı:

Yukarıdaki işlev şunları yapar:

• GitHub URL’sinin user/repo bölümünü çıkarır ve bir GitHub API isteği oluşturur.
• Ajan, dönen JSON’u ayrıştırarak şu bilgileri çıkarır:
• Commit SHA
• Commit mesajı
• Yazar adı
• Zaman damgası
• Bu değerler iki listede saklanır: commits ve commit_dates. 
• Son olarak, işlev her ikisini içeren bir sözlük döndürür; bu, sonraki ajanlar tarafından daha fazla analiz ve görselleştirme için kullanılır.

3. agents/coder.py dosyası oluşturma

Bu ajan, GitHub’dan toplanan commit geçmişini işler ve hem metinsel bir özet hem de matplotlib kullanarak görsel içgörüler üretir.

# 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, chartsAltyapı:

Bu ajan, GitHub commit geçmişini işler ve matplotlib kullanarak bir Markdown özeti ve görsel grafikler üretir. Anahtar kelime eşleştirme ile commit’leri hata düzeltmeleri, özellikler, dokümantasyon ve daha fazlası gibi önceden tanımlı gruplara ayırır. Ardından matplotlib ile şu üç içgörülü grafiği üretir:

• Son 30 gündeki commit etkinliği
• Kategori başına commit sayısı
• Commit mesajlarında en sık kullanılan anahtar kelimeler

Son olarak, ajan her kategori için önemli commit’leri öne çıkaran bir markdown özeti oluşturur ve raporda gösterilmek üzere hem özeti hem de grafik yollarını döndürür.

4. agents/reporter.py dosyası oluşturma

Reporter ajanı, aşağıdakileri birleştiren nihai Markdown raporunu üretir:

• GitHub depo bağlantısı
• Son commit’lerin madde işaretli listesi
• Commit mesajlarının kategorize edilmiş özeti (coder ajanından)

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 mdAltyapı:

generate_report() işlevi, GitHub URL’si, commit verileri, kategorize edilmiş analiz ve grafik yollarını kullanarak nihai Markdown raporunu derler. Tek bir markdown biçimli dize döndürür; bu dize terminalde görüntülenebilir veya Streamlit gibi bir arayüzde render edilebilir. Tek bir markdown biçimli dize döndürür; bu çıktı konsola yazdırılabilir veya Streamlit’te render edilebilir.

Adım 4: Streamlit ile Arayüz Oluşturma

Streamlit uygulaması, kullanıcıların tüm hattı tek tıklamayla çalıştırmasına olanak tanır. Bir streamlit_app.py dosyası oluşturun ve aşağıdaki kodu ekleyin: 

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.")Altyapı:

Kod şunları yapar:

• streamlit kütüphanesini kullanarak minimal bir pano oluşturur; düğmeye tıklandığında LangManusAgent.run_and_return() işlevini tetikler.
• Uygulama, st.markdown() ile Markdown raporunu gösterir; ardından her grafik yolunu döngüyle gezerek st.image() ile görselleri render eder.

LangManus destekli GitHub analiz projemizin nihai yapısı şöyle olmalıdır:

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.pngAltyapı:

Adım 5: StreamLit Uygulamasını Test Etme

Artık tüm bileşenler hazır; Streamlit uygulamamızı çalıştıralım. Terminalde şu komutu çalıştırın:

streamlit run streamlit_app.pyAltyapı:

Tarayıcınızda "Run Analysis on Trending Repo" düğmesine tıklayın; LangManus destekli ajanlarınız saniyeler içinde GitHub depo içgörülerini getirip analiz ederek sunacaktır.

Sonuç

LangManus, gerçek dünya verileriyle etkileşime giren yapılandırılmış çoklu aracılı sistemler kurmamızı sağlar. Bu rehberde, şu adımları içeren tamamen otomatik bir GitHub depo analizörü oluşturduk:

• Trend olan depoları araştırdık.
• Commit geçmişini taradık.
• Eğilimleri grafiklerle görselleştirdik
• Sonuçları Markdown ile özetledik

LangManus; araştırma ajanları, panolar ve veri odaklı asistanlar oluşturmak için ciddi bir potansiyele sahiptir.