arch-analysis

Analyze LangGraph applications to identify bottlenecks and propose architectural improvements.

1|Updated Nov 25, 2025
One-click install
npx skills add https://github.com/hiroshi75/langgraph-master --skill arch-analysis
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: arch-analysis
Source: https://github.com/hiroshi75/langgraph-master/tree/main/langgraph-master/skills/arch-analysis
Command: npx skills add https://github.com/hiroshi75/langgraph-master --skill arch-analysis

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill automates the complex and time-consuming process of analyzing LangGraph application architecture, identifying performance bottlenecks, and generating diverse improvement strategies. It saves developers significant manual effort in performance tuning and architectural decision-making, allowing them to focus on implementing the best solutions rather than extensive manual diagnosis.

Core Features & Use Cases

  • Current State Analysis: Automatically measures performance baselines and understands the existing graph structure.
  • Bottleneck Identification: Pinpoints specific latency, cost, and accuracy issues within the LangGraph application.
  • Multi-Strategy Proposals: Generates 3-5 diverse, actionable improvement proposals, all candidates for parallel exploration and evaluation.
  • Use Case: A developer notices their LangGraph application is slow and expensive. Instead of manually sifting through code and logs, this skill automatically diagnoses the root causes (e.g., sequential processing, inefficient RAG) and provides concrete, evaluated architectural changes to fix it, without manual code inspection.

Quick Start

Analyze the LangGraph application in the current directory, identify performance bottlenecks, and propose architectural improvements.

Frequently Asked Questions about arch-analysis

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I identify performance bottlenecks in my LangGraph application?

Bottleneck identification in LangGraph analyzes node-level metrics across latency, cost, and accuracy to pinpoint which components slow execution or increase expenses. The analysis measures your current graph structure and performance baselines, then surfaces specific issues like sequential processing or inefficient RAG patterns.

Can I automatically generate architectural improvements for my LangGraph graphs?

Yes. LangGraph architecture analysis generates 3-5 diverse, actionable improvement proposals tailored to your graph's specific bottlenecks. Each proposal targets different optimization angles—parallelization, efficiency gains, cost reduction—ready for parallel exploration and evaluation.

What metrics does LangGraph performance analysis measure?

Performance analysis measures latency, cost, and accuracy across your LangGraph application's nodes and execution flow. It establishes baselines from your current graph, then evaluates how proposed architectural changes would impact each metric.

How do I use architecture analysis results to optimize my LangGraph application?

Architecture analysis produces an analysis report detailing bottlenecks and an improvement_proposals document describing 3-5 concrete changes with constraints and implementation details. Feed these proposals to implementation and evaluation tools to test and measure their actual impact.

Do I need to manually inspect my LangGraph code to find performance issues?

No. Architecture analysis automates diagnosis by examining your live graph structure, performance baselines, and node metrics directly. It eliminates manual code sifting and log inspection, surfacing root causes and improvement strategies without requiring deep manual analysis.

What types of architectural changes does LangGraph analysis propose?

Proposals address diverse optimization angles: sequential-to-parallel conversions, RAG efficiency improvements, cost reduction strategies, latency optimization, and accuracy enhancements. Each proposal is independently actionable and evaluated against your performance baselines.