Domain AI that can run as a cloud service, a self-contained browser runtime, or a disconnected on-prem lab. The same patterns — agents, local inference, containers, and reproducible delivery — show up in fintech, spatial engines, and air-gap GPU platforms.

flowchart TB
    subgraph FIN["AI Fintech"]
        DRL["domain-rag-lab"] -->|"backtest specs"| LUM["lumina-invest"]
        LUM -->|"Open API orders"| SCT["stock-coin-trade"]
        DRL -.-> SKP["stock-kms-portal"]
    end
    subgraph ENG["Web 3D Engines"]
        HAN["Hanok simulator<br/>dimetric studio"]
        KART["Siamese Cat KartRider<br/>Three.js + Rapier"]
    end
    subgraph AIR["Air-Gap GPU Research"]
        HAR["harbor-lab<br/>offline registry"]
        K8S["k8s-jupyter-lab<br/>OVA + K8s + local LLM"]
        HAR -.->|"image mirror"| K8S
    end

• Fintech: independently deployed services, separate databases, REST only (API key auth).
• 3D: browser engines with no required backend — a procedural dimetric studio and a WebGL physics sim.
• Air-gap: VMware OVA delivery into a network with no public internet. Harbor, Nexus, and GitLab mirror images and packages; GPU workers run local LLM, agents, and JupyterHub.

Four repositories form a pipeline for financial AI, quant analysis, RAG-based knowledge search, paper trading, and brokerage Open API auto-trading.

flowchart LR
    DRL["domain-rag-lab<br/>(finance RAG & LEAN backtests)"] -->|"backtest results / strategy specs (HTTP API)"| LUM["lumina-invest<br/>(robo-advisor & quant signals)"]
    LUM -->|"order / balance Open API (API key)"| SCT["stock-coin-trade<br/>(paper trading & Open API broker)"]
    DRL -.->|"fork & frontend integration"| SKP["stock-kms-portal<br/>(learning, charts, KMS, Lex/RAG portal)"]

• Integration principle: domain-rag-lab, lumina-invest, and stock-coin-trade are deployed independently with separate databases and communicate only via REST APIs (API key auth).
• Portal: stock-kms-portal consolidates domain-rag-lab and the investment-analysis web app into a single entry point (port 80).

Integrated Korean financial learning and investment-analysis KMS portal. FastAPI Vanilla JS ApexCharts Qdrant pgvector AWS Lex LEAN

• Market charts: Query domestic and global stock/index prices (Yahoo Finance-based API) with candlestick charts
• Financial learning: 10 learning units, with Mermaid.js diagrams
• LEAN backtesting: Built-in local Docker runner for the QuantConnect LEAN engine
• Hybrid chat & RAG: AWS Lex v2 chatbot combined with Qdrant document RAG
• Origin: Forked from the domain-rag-lab structure, with frontends migrated to a single origin

Paper-trading platform for stocks (KRX), crypto, and alternative assets, plus brokerage Open API practice. FastAPI AWS SAM MariaDB PostgreSQL Vanilla JS Nginx

• Open API: Virtual account issuing and order execution (/api/v1/orders, etc.) for external systems such as lumina-invest
• Data: MariaDB for members/trades, PostgreSQL (pg-stock) for OHLCV minute/daily bars
• Broker integrations: Korea Investment & Securities (KIS) API/paper trading, KB Securities Open API, Alpaca Paper Trading, TradingView Pine Script
• Tooling: KIS MCP (Model Context Protocol) server with VS Code/Codex integration
• Frontend: Vanilla JavaScript (ES Modules) served by Nginx

Robo-advisor and quant-signal orchestrator for automated trading. FastAPI Celery PostgreSQL Redis LangChain LangGraph Qdrant Neo4j LightGBM

• Auto-trading engine: Celery Beat runs the quant.auto_trade_cycle task every 10 minutes
• Orchestration: Receives strategy specs backtested in domain-rag-lab, computes risk limits, and sends orders to stock-coin-trade via Open API
• AI & ML: LangChain/LangGraph agents, Scikit-learn and LightGBM models
• AWS: SageMaker training-result lookup and AWS Comprehend sentiment analysis
• Storage: PostgreSQL 16 (SQLAlchemy, asyncpg, Alembic), Redis (sessions, Celery broker/backend)

RAG for financial products and asset allocation, with QuantConnect LEAN backtest workflows. FastAPI Streamlit Qdrant pgvector Redis Docker

• Hybrid search: Qdrant vector search and PostgreSQL keyword search fused with Reciprocal Rank Fusion (RRF)
• Multi-turn orchestrator: Session short-term memory and pgvector-based long-term memory
• Ingestion: PDF/TXT document ingestion and chunking pipeline
• LEAN backtesting: Local Docker-based QuantConnect LEAN engine
• Infrastructure: Docker Compose, Caddy (TLS reverse proxy), AWS EC2 deployment

Browser-native spatial runtimes. Scenes render on the client: a dimetric town studio drawn on Canvas 2D, and a WebGL time-trial with a physics step. Neither needs a game server to place a building or run a lap.

Joseon village studio — a 2:1 dimetric town builder for composing a hanok village and exporting a pixel-perfect snapshot. React Vite TypeScript Canvas 2D

• World: 16×16 diamond grid (256 cells), painter’s-algorithm depth sort, nearest-neighbor pixel art
• Procedural architecture: runtime isometric hanok — gidan, timber columns, changhomun, giwa / choga, jangdokdae, ondol chimneys — 56 buildings inside a 256-tile palette
• Scene tools: 90° rotation, day/night lighting, looping mill and water animation, five village presets, undo
• Export: 2,176×1,216 PNG snapshot with preview, download, and clipboard copy
• Runtime: no server and no project file; the map lives in memory until export

Browser 3D time-trial — a 1:87 HO-scale kart on a night-time desk coaster. Three.js Rapier WebGL2 Vite Web Audio

• Engine: single WebGL loop (ACES, bloom, depth-of-field, FXAA) with a Rapier static world and a spline vehicle step
• Track: six-sector banked coaster, drift sparks, apex boost, guardrail penalty, F1-style start lights
• Ghost & cameras: best-lap hologram recorded at 30 Hz (localStorage), chase / cockpit / desk orbit / drone cameras, autopilot
• Diorama: millimeter-scale desk and bedroom; GLB props with procedural-mesh fallback
• Delivery: vite build bundles models so a race can run from the production dist without a live asset host

On-prem platforms for teams that cannot send models, code, or research data to a public cloud. Images, packages, and weights are staged online, then imported from media into a disconnected VMware lab.

flowchart LR
    subgraph BUILD["Online build"]
        PACKER["Packer + Ansible"] --> OVA["OVA x8"]
        PACKER --> BUNDLE["Offline bundle"]
    end
    OVA --> MEDIA["USB / HDD"]
    BUNDLE --> MEDIA
    subgraph AIRGAP["Customer air-gap"]
        INFRA["Harbor · Nexus · GitLab · NAS"]
        K8S["Kubernetes<br/>control plane + GPU workers"]
        GPU["Ollama · vLLM · TGI<br/>JupyterHub · agents"]
        INFRA --> K8S --> GPU
    end
    MEDIA --> INFRA
    MEDIA --> K8S

Air-gap AI agent platform delivered as VMware OVAs — GPU local LLM, JupyterHub, and Kubernetes for an internal research network. VMware OVA Kubernetes NVIDIA GPU Ollama vLLM JupyterHub Harbor

• Delivery: Packer/Ansible builds eight OVAs (control plane, three GPU workers, Harbor, Nexus, GitLab, NAS) plus an offline bundle of images, manifests, apt packages, and model files
• GPU path: physical NVIDIA GPU via PCIe passthrough or vGPU, nvidia-container-runtime on containerd, CUDA inside the pod
• Research stack: Ollama, vLLM, and TGI for local inference; JupyterHub for notebooks; LangGraph and AutoGen agents; Chroma and Milvus for RAG
• Offline coding: preloaded Ollama models with Codex CLI or Claude Code pointed at the local runtime — no public API required to edit, explain, or draft tests
• Install: phase1 build online → phase2 rehearse after boot → phase3 import and apply inside the air-gap

Hands-on lab for running Harbor the way an air-gapped network would: internal registry, CA trust, robot accounts, and image import without Docker Hub. Harbor Docker kind WSL2

• Air-gap flow: save/load/tar import, proxy-cache concepts, and a preflight that checks images in Harbor before a model deploy
• Cluster pull: kind pulls a Harbor HTTPS image using an image-pull secret and the internal CA
• Inference images: vLLM image skeleton and Kubernetes deploy templates (probes, imagePullSecret, NodePort) as the registry side of a GPU research stack