AtlasStack is an autonomous software engineering engine that analyzes GitHub repositories using Gemini 1.5 Flash and Qwen2.5-Coder, finds bugs, explains architecture, and proposes fixes — including an embedded web IDE experience.

• Deep Repo Analysis: Clones any public GitHub repo and produces a structured report: architecture, data flow, important files, security fixes, and a health score.
• Embedded Web IDE: A full VS Code-like development environment directly in the browser.
• "Explain Like I'm 10": Toggleable ELI5 summaries for every codebase analysis.
• Lite Mode Backend: Runs entirely on Python + SQLite — no Docker needed.
• Premium CLI Tool: Analyze repositories and view history directly from your terminal.
• Autonomous Training Data Collection: Captures scan inputs and LLM outputs to build a high-quality fine-tuning dataset automatically.
• Enterprise Authentication: Secured by Clerk, providing out-of-the-box SSO, OAuth, and user management.

AtlasStack is built as a distributed system of specialized services coordinated via an API Gateway.

flowchart TD
  A[Client / UI / CLI] -->|REST| B(API Gateway)
  B -->|Queue| C(Analysis Worker)
  C -->|Model calls| D(LLM Service)
  C -->|Index| E(Knowledge Service)
  E -->|Search| B
  subgraph Data Stores
    F[(PostgreSQL)]
    G[(Redis)]
    H[(Neo4j)]
    I[(Weaviate)]
  end
  B --> F
  B --> G
  C --> F
  C --> G
  E --> H
  E --> I

For more details, see the Architecture Deep Dive.

• Frontend: React, TypeScript, Vite, Monaco Editor, Tailwind CSS, Framer Motion
• Backend (Lite Mode): Python 3.12, FastAPI, SQLite, Gemini 1.5 Flash (Google) or Qwen2.5-Coder (HuggingFace)

• Message Broker: RabbitMQ
• Graph Database: Neo4j (Code dependency maps)
• Vector Database: Weaviate (Semantic code search)
• Caching & Sessions: Redis
• Primary Data: PostgreSQL
• Observability: Prometheus, Grafana, Jaeger (Tracing)
• Orchestration: Docker Compose, Kubernetes

• Python 3.12+
• Node.js 18+
• A Gemini API Key (Recommended) or a HuggingFace token

cp .env.example .env
cp clients/web/.env.example clients/web/.env.local
# Edit .env — at minimum set HF_TOKEN
# Edit clients/web/.env.local — set VITE_CLERK_PUBLISHABLE_KEY

# Recommended: Use a virtual environment
python -m venv .venv
.\.venv\Scripts\Activate.ps1

pip install -r requirements.txt
pip install -e .  # Registers the 'atlas' command

python test_app2.py
# → http://localhost:8005
# → API docs at http://localhost:8005/docs

cd clients/web
npm install
npm run dev
# → http://localhost:3000

1. Open http://localhost:3000
2. Click Sign In / Register → create an account
3. Enter a public GitHub repo URL and click Start Analysis
4. The AI will clone the repo, analyze it, and return a full report

No AI Key? The analysis endpoint falls back to a mock response. Set GEMINI_API_KEY or HF_TOKEN in .env to enable real AI analysis.

The AtlasStack VS Code extension brings AI-driven analysis directly to your workspace.

1. Build/Install: Open clients/vscode and follow the README to build the .vsix.
2. Connect: Open VS Code settings and set atlasstack.serverUrl to your backend (default: http://localhost:8005).
3. Analyze: Use the AtlasStack icon in the Activity Bar to run deep repository scans.

The AtlasStack CLI is a powerful tool for developers who live in the terminal.

1. Create Environment:

   python -m venv .venv
   .\.venv\Scripts\Activate.ps1  # Windows
   # source .venv/bin/activate   # macOS/Linux

2. Install CLI:

   pip install -r requirements.txt
   pip install -e .

Full interactive docs at http://localhost:8005/docs

atlasstack/
├── clients/
│   ├── web/              # Vite + React frontend (landing page + IDE)
│   └── vscode/           # VS Code extension
├── services/
│   ├── api/              # FastAPI gateway (auth, repos, analysis)
│   ├── analysis/         # Celery workers (AST, security, perf)
│   ├── llm/              # LLM inference service
│   └── knowledge/        # Neo4j + Weaviate knowledge graph
├── shared/               # Shared Pydantic models + utilities
├── k8s/                  # Kubernetes manifests
├── monitoring/           # Prometheus + Grafana + Jaeger configs
├── test_app2.py          # Lite Mode entry point
└── docker-compose.yml    # Full stack deployment

AtlasStack supports custom model fine-tuning via training/. You can run the pipeline to adapt the analysis engine to specific coding standards or languages.

# Run Supervised Fine-Tuning (SFT)
make train-sft

# Run RLHF pipeline
make train-rlhf

AtlasStack can automatically harvest its own analysis results to build a specialized dataset for future training.

• Storage: Data is saved in JSONL format for easy ingestion by the DatasetLoader.
• Default Path: training/datasets/collected_scans.jsonl
• Toggle: Enable or disable via COLLECT_TRAINING_DATA in your .env.

Every collected entry includes the system instruction, the repository context, and the structured LLM response, along with metadata like the repo URL and scan timestamp.

For a full enterprise-grade deployment with PostgreSQL, Redis, and RabbitMQ:

1. Prepare Environment:

   cp .env.example .env
   # Fill in required secrets (HF_TOKEN, DATABASE_URL, etc.)

2. Launch Stack:

   docker-compose up -d

3. Run Migrations:

   docker-compose exec api alembic upgrade head

Deployment manifests are located in /k8s.

kubectl apply -f k8s/

See .env.example for the full list of configuration options.

• Authentication: All user authentication, session management, and SSO is handled securely via Clerk (frontend) and JWT (backend).
• Vulnerability Scanning: CI/CD includes automated scans via bandit, safety, and semgrep.
• Execution Sandboxing: Repository analysis runs in isolated temporary directories with strict timeouts and size limits.
• LLM Data Privacy: Local LLM inference via Lite Mode ensures your codebase never leaves your infrastructure (unless using external HuggingFace/Google Inference APIs).

Apache License 2.0 — see LICENSE for details.