🔍 RepoLens — Understand Any Codebase in Seconds

🧠 Paste a GitHub URL. Get a full visual architecture walkthrough, module breakdown, key code flows, and an AI chat to explore deeper.

💡 The Problem

Every developer knows the pain: you open a new repo and face a wall of unfamiliar code. READMEs are outdated. Architecture docs don't exist. You spend hours jumping between files trying to piece together how things work.

What if you could understand any codebase in under 60 seconds?

✨ What RepoLens Does

📎 Paste a GitHub repo URL
🤖 AI agents analyze the entire codebase — architecture, modules, data flows, patterns
📊 Get an interactive visual walkthrough:
- 🗺️ Architecture Diagram — auto-generated Mermaid diagram showing how components connect
- 📦 Module Breakdown — every major module explained with key files highlighted
- 🔄 Key Code Flows — step-by-step walkthroughs of critical paths (auth, API lifecycle, data pipeline, etc.) with annotated code snippets
💬 Ask follow-up questions — chat with the codebase using semantic code search

🏗️ How It Works

  GitHub Repo URL
        │
        ▼
  ┌─────────────────┐    ┌──────────────────────────────────────┐
  │  🌐 Next.js UI   │◄──►│  ⚡ FastAPI Backend                   │
  └─────────────────┘    └──────────────┬───────────────────────┘
                                        │
                                        ▼
                          ┌──────────────────────────────┐
                          │  🤖 Railtracks Agent Pipeline  │
                          │                              │
                          │  IndexerAgent ──────────────►│
                          │  ArchitectureAgent ────────►│
                          │  ModuleAgent ──────────────►│
                          │  FlowAgent ────────────────►│
                          │  DiagramAgent (+ validator) ►│
                          │  ComposerAgent ────────────►│
                          └──────┬──────────┬───────────┘
                                 │          │
                      ┌──────────▼┐  ┌──────▼──────────┐
                      │ 🧬 Augment │  │ 🌊 DigitalOcean  │
                      │  Context   │  │  Gradient AI    │
                      │  Engine    │  │  Inference      │
                      └───────────┘  └─────────────────┘

🔗 The Agent Pipeline (Built with Railtracks)

RepoLens uses 7 specialized AI agents orchestrated as a sequential flow with a validation loop:

Agent	Job
🗂️ IndexerAgent	Indexes the repo using Augment Context Engine via MCP
🏛️ ArchitectureAgent	Identifies architecture patterns, tech stack, and design decisions
📦 ModuleAgent	Breaks the codebase into logical modules with descriptions
🔄 FlowAgent	Discovers 3-5 critical code flows with step-by-step walkthroughs
📊 DiagramAgent	Generates a Mermaid.js architecture diagram
✅ DiagramReviewer	Validates diagram syntax and completeness (validation loop)
🎼 ComposerAgent	Assembles everything into a structured response for the UI

Plus a 💬 ChatAgent for follow-up Q&A powered by semantic code retrieval.

🧬 Augment Code — The Brain of RepoLens

Augment's Context Engine is the centerpiece — it's what makes the analysis actually understand code rather than just pattern-match.

Context Connectors index any GitHub repo into a semantic search engine
Agents query the index via MCP (Model Context Protocol) to find relevant code
The ChatAgent uses semantic retrieval for grounded, accurate answers
Every code snippet shown in the UI comes from Augment's semantic search — not naive grep

# Railtracks agents connect to Augment via MCP
augment_server = connect_mcp(
    MCPHttpParams(url="http://localhost:8081/mcp")
)

ArchitectureAgent = rt.agent_node(
    tool_nodes=augment_server.tools,  # 🧬 Augment search tools
    llm=do_gradient_llm,              # 🌊 DigitalOcean inference
    system_message="Analyze this codebase's architecture..."
)

🌊 DigitalOcean — Infrastructure & Intelligence

Gradient AI Inference Hub — powers all LLM calls across every agent (OpenAI-compatible API)
App Platform — one-click deployment for both frontend and backend
All inference runs through inference.do-ai.run — zero infrastructure to manage

🤖 Railtracks — The Orchestration Layer

Flows are just Python — no config files, no DSLs, just async/await
Sequential pipeline with a validation loop for diagram quality
Built-in MCP support connects directly to Augment's Context Engine
Full observability and error handling out of the box

🛠️ Tech Stack

Layer	Technology
🌐 Frontend	Next.js + Tailwind CSS + shadcn/ui
⚡ Backend	Python + FastAPI + uvicorn
🤖 Agents	Railtracks — flows are just Python
🧬 Code Intelligence	Augment Code Context Connectors + Context Engine SDK
🧠 LLM Inference	DigitalOcean Gradient AI Inference Hub
📊 Diagrams	Mermaid.js
🚀 Deployment	DigitalOcean App Platform

🚀 Quick Start

# Clone
git clone https://github.com/your-org/repolens.git && cd repolens

# Backend
cd backend
cp .env.example .env   # Add your API keys
uv sync
uv run uvicorn main:app --reload --port 8000

# Frontend (new terminal)
cd frontend
pnpm install && pnpm dev

Open http://localhost:3000 and paste a GitHub URL 🎉

🔑 Environment Variables

DO_MODEL_ACCESS_KEY=     # DigitalOcean Gradient AI key
AUGMENT_SESSION_AUTH=    # From `auggie token print`
GITHUB_TOKEN=            # GitHub PAT for repo access

🎬 Demo Script (3 Minutes)

Time	Action
0:00	🎤 "Every developer wastes hours understanding new codebases. We fixed that."
0:15	📎 Paste a GitHub repo URL into RepoLens
0:30	⏳ Show the agent pipeline working — "7 AI agents powered by Railtracks, using Augment's Context Engine to deeply understand the code"
1:00	🗺️ Walk through the architecture diagram
1:30	📦 Show module breakdown + key code flows with annotated snippets
2:00	💬 Ask a follow-up question in the chat — "How does authentication work?"
2:30	🌊 "Deployed live on DigitalOcean App Platform, LLM inference via Gradient AI"
2:45	🎯 "Try it yourself" — share the live URL