DevLens

Intelligent codebase visualizer.

Turn any TypeScript, JavaScript, Python, Go, Rust, or Java repository into a living, queryable graph — every node carries a functional summary, a technical summary, and a security assessment.

Join the DevLens Cloud Waitlist →

Click the image to watch the demo

Table of Contents

• What is DevLens?
• Supported languages
• Quick Start
• Screenshots
• Why it's faster & cheaper
• Ways to use DevLens
  • Web UI
  • CLI
  • Agent Skill — AI-Powered Understanding
  • MCP Server — for any MCP-compatible AI agent
• Configuration
• What DevLens understands
• Benchmarks
• Who is this for
• How DevLens compares
• Repository layout
• DevLens Cloud

What is DevLens?

DevLens turns a codebase into a pre-built dependency graph. Instead of reading files one at a time, you (or your AI agent) query the graph: every component, class, function, route, struct, or trait is a node, and every connection is a typed edge (CALLS, IMPORTS, HANDLES, IMPLEMENTS, …). Each node carries:

• Functional summary — what business purpose does this serve?
• Technical summary — how does it work?
• Security assessment — severity + explanation

This is the difference between an AI that re-reads your whole repo every session and an AI that already knows the architecture — architecture reviews, impact analysis, security audits, and onboarding take seconds, not hours.

Supported languages

DevLens parses six languages with native parsers (no regex, no tree-sitter) and understands their frameworks:

Each repo is analyzed with its language's own parser (Python ast, JavaParser, Go go/ast + go/types, Rust syn, TS compiler API), so edges are real — type-checked interfaces (IMPLEMENTS), framework routes (HANDLES), and ORM data layers (READS_FROM/WRITES_TO).

Quick Start

1. Install

npm install -g @devlensio/cli

No Node.js? Use the standalone binary installer (zero dependencies):

Linux / macOS:

curl -fsSL https://raw.githubusercontent.com/devlensio/devlensOSS/main/scripts/install.sh | sh

Windows (PowerShell):

irm https://raw.githubusercontent.com/devlensio/devlensOSS/main/scripts/install.ps1 | iex

2. Configure your AI provider (only needed if you want AI summaries — structure-only works offline)

cd your-project
devlens init

3. Analyze

devlens analyze . --summarize

DevLens detects the language (TS/JS, Python, Go, Rust, Java) from your manifests, builds the graph, and summarizes every node.

4. Explore

devlens overview                # language, framework, stats, central nodes
devlens detect                  # "what is this repo?" — language, manifest, deps
devlens find-nodes -t ROUTE     # every route in the app
devlens architecture            # one-command architecture brief
devlens security                # security flags across the codebase

That's it. Want it in your AI agent instead? Jump to the Agent Skill.

Screenshots

Interactive graph explorer · node inspector with AI summaries & security risk · focused node subgraph · security findings

Why it's fast & cheaper

A node summary is ~50 tokens. The file it describes is ~2,000. Querying summaries and graph slices (get_blast_radius, get_subgraph) costs a fraction of reading files — humans get answers faster, and AI agents spend dramatically fewer tokens on the same task.

Ways to use DevLens

Pick the interface that fits your workflow:

Web UI — Visual Exploration

For when you want to see your codebase laid out as an interactive graph.

Open the Web UI, paste your repo path, and explore a force-directed canvas — click any node to see its summaries, callers, callees, and security flags. Search, filter, diff commits across versions.

git clone https://github.com/devlensio/devlensOSS.git
cd devlensOSS && bun install && bun run dev

CLI (@devlensio/cli) — Terminal Power

For scripts, CI, and answers fast without leaving the terminal. Every command supports --json for piping into scripts, -v/--verbose for diagnostics, and --quiet for minimal output.

npm install -g @devlensio/cli

Analyze & summarize

Explore & understand

Impact & quality

Manage & integrate

Full reference: src/cli/README.md — every command with options and examples.

Agent Skill — AI-Powered Understanding

The most powerful way to use DevLens. Your AI agent normally reads files one at a time — the DevLens Skill teaches it to query the pre-built graph instead.

npx @devlensio/skill install

Then reload your tool and use /devlens in Claude Code, Cursor, Kilo, opencode, pi, or any AI coding agent:

Full reference: packages/skill-installer/README.md — all subcommands, install options, and supported AI tools.

MCP Server — for Any MCP-Compatible AI Agent

Wire DevLens into any MCP client (Claude Code, Claude Desktop, IDE agents, …). The server is bundled inside the CLI and exposes 21 tools covering discovery, search, traversal, security, and one-call workflow summaries.

devlens mcp                       # stdio mode
claude mcp add devlens -- devlens mcp   # register in Claude Code
devlens mcp http -p 7000          # HTTP mode

Your agent can: list analyzed repos, get a repo overview (language + framework + stats), find nodes by name/type/severity, read summaries, trace blast radius / k-hop / subgraphs, find cycles, analyze a new repo, compare commits (analyze_changes), and generate whole-packet architecture/security/PR-review/onboarding/context outputs from one call.

Full reference: src/mcp/README.md — tool catalog, registration, configuration.

Configuration

Config lives in ~/.devlens/config.json and is set via devlens init or devlens config.

# Interactive setup — picks from a catalog and fetches live model lists
devlens config --set

# Non-interactive scripting
devlens config --provider openai --provider-name deepseek --model deepseek-v4-flash --api-key <key>

# Switch between saved providers without re-entering credentials
devlens config --active openai:deepseek

# Health check
devlens doctor

Models are discovered dynamically from each provider's /models endpoint — no hardcoded model lists. Custom OpenAI- or Anthropic-compatible endpoints can be added through the interactive flow. Summaries are never generated silently — the skill and CLI ask permission first; structure-only analysis needs no provider at all.

What DevLens understands

Node types (per language — a graph is per-repo/per-language):

Edge types (the connections the graph draws): CALLS, IMPORTS, READS_FROM, WRITES_TO, PROP_PASS, EMITS, LISTENS, WRAPPED_BY, GUARDS, HANDLES, TESTS, USES, NEXTJS_API_CALL, NAVIGATES_TO, IMPLEMENTS (class → interface / trait / ABC), EXTENDS (class → base class).

EXPORTS and THROWS + node types MODULE/PACKAGE are reserved for future languages.

Router awareness — routes are real graph nodes: Next.js (app & pages), React Router / TanStack Router / wouter, Express / Fastify / Hono / Koa, Django URLconf / DRF, Flask blueprints, @RestController (Spring), Gin / Echo / chi / HTTP handlers, axum / actix / rocket.

Every node carries: importance score + functional summary + technical summary + security assessment (when summarized).

Benchmarks

Tested across real-world tasks — architecture understanding, feature implementation, and bug finding — comparing the same model (DeepSeek V4 Flash, GLM 5.2, Kimi K2.6, Qwen 3.6) with and without DevLens.

Architecture understanding (full DevLens MCP)

Even the strongest tested model was 81% cheaper ($0.0035 vs $0.0185) and used 83% fewer input tokens with DevLens.

Who is this for

• Developers & teams — onboard devs in hours not weeks, review PRs with impact context, catch circular deps and god-files, keep living documentation.
• Engineering leaders — bird's-eye architecture view, spot debt before it becomes a crisis, understand work across repos.
• AI-augmented developers — stop letting your agent burn tokens re-reading files; it queries the graph instead.

How DevLens compares

DevLens is the only tool in this space that combines three things: native semantic parsing (not regex or tree-sitter), per-node AI summaries with per-node security analysis, and framework-aware data edges (routes, ORM reads/writes). That combination is what makes it uniquely suited for AI agents working inside a single codebase — and it's the only option you can use commercially under AGPL.

Every alternative trades away at least one of those capabilities:

Other notable alternatives: CodeSee (service-level dependency mapping, enterprise-only), CodeQL (GitHub-native semantic security analysis — deep but no AI summaries or graph visualization), and ctags-based indexers (lightweight symbol indexes, no graph intelligence).

Why teams choose DevLens over the others:

• You get semantic edges (type-checked inheritance, ORM data flow, framework routes) that syntactic tools like Graphify and GitNexus simply can't produce — so your agent doesn't guess relationships, it knows them.
• You get per-node security analysis that no other open-source tool provides — not Sourcegraph (which only has compliance certifications), not GitNexus (which has optional PDG, not built-in), not DeepWiki (which ignores security entirely).
• You get 21 MCP tools + a universal /devlens skill — a tighter, more purpose-built agent surface than Sourcegraph's general-purpose MCP or GitNexus's hooks.

(Feature comparison from public sources, Aug 2026.)

Repository layout

devlensOSS/
├── src/
│   ├── cli/                  # `devlens` CLI (commander program + commands)
│   ├── core/                 # Shared query core (CLI + MCP — never drift)
│   ├── mcp/                  # MCP server (stdio + HTTP) — 21 tools
│   └── server/               # HTTP API for the Web UI
├── frontend/                 # Next.js graph visualizer (Cytoscape)
├── plugins/devlens/          # Agent Skill source (Claude plugin)
├── packages/skill-installer/ # @devlensio/skill — the npx installer
├── bin/                      # Platform launcher
├── npm/<platform>/           # 5 prebuilt binary packages (darwin/linux/windows × arm64)
├── scripts/                  # Release tooling
└── server.json               # MCP registry manifest

The analysis engine (“native parsers + graph build”) ships as the separate devlensio package.

DevLens Cloud

A hosted version is in development:

• Shareable graphs your whole team can access
• Cross-repo navigation — understand your entire org
• Graphical context for AI agents — smarter code review and analysis
• No local setup

Join the waitlist →

License

AGPL-3.0. Part of the devlensio family of tools.