Skip to content

Guiimartinho/routeai

BranchesTags

Repository files navigation

RouteAI

RouteAI

LLM-Powered Electronic Design Automation Platform for PCB Design

Download & Install | Features | Architecture | Getting Started | Development | Deployment | License

Python 3.11+ Go 1.22 C++17 React 18 MIT License Download

Overview

RouteAI is an intelligent EDA platform that combines large language models with deterministic solvers to automate and assist PCB (Printed Circuit Board) design workflows. It bridges the gap between human design intent and physical constraints by using LLMs for natural language understanding and expert-grade analysis, while relying on formal solvers for all geometric, electrical, and manufacturing computations.

Key Principle: LLMs handle intent interpretation and design review. Deterministic solvers handle all mathematical operations — coordinates, clearances, impedances, and routing are never generated by AI.

Download & Install

Windows (5 minutes)

Step 1 — Download the installer

Go to https://github.com/Guiimartinho/routeai/releases and download RouteAI-EDA-Setup-x.x.x.exe.

Step 2 — Run the installer

Double-click the .exe. The installer will:

  • Install RouteAI EDA to C:\Program Files\RouteAI EDA\
  • Create Desktop and Start Menu shortcuts
  • Optionally open the Ollama download page
  • Optionally add RouteAI to your PATH

Step 3 — Install Ollama (required for AI features)

  1. Download from ollama.com/download
  2. Run the Ollama installer (next, next, finish)
  3. Open a terminal (PowerShell or CMD) and run:
ollama pull qwen2.5:7b

This downloads the AI model (~5GB). Only needed once.

Step 4 — Open RouteAI

Click the "RouteAI EDA" shortcut on your Desktop. Done.

Or use the one-line installer (PowerShell, admin):

irm https://raw.githubusercontent.com/Guiimartinho/routeai/main/scripts/install-windows.ps1 | iex

Linux (5 minutes)

Option A — One-line install (Ubuntu/Debian)

curl -fsSL https://raw.githubusercontent.com/Guiimartinho/routeai/main/scripts/install-linux.sh | bash

This automatically: downloads the .deb, installs it, installs Ollama, pulls the AI model, and launches RouteAI.

Option B — Manual install

# 1. Download the package from GitHub Releases
wget https://github.com/Guiimartinho/routeai/releases/latest/download/RouteAI-EDA-amd64.deb

# 2. Install
sudo dpkg -i RouteAI-EDA-amd64.deb

# 3. Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# 4. Pull the AI model
ollama pull qwen2.5:7b

# 5. Launch
routeai-eda

Option C — AppImage (any distro)

wget https://github.com/Guiimartinho/routeai/releases/latest/download/RouteAI-EDA-x86_64.AppImage
chmod +x RouteAI-EDA-x86_64.AppImage
./RouteAI-EDA-x86_64.AppImage

What you need vs. what's included

Component Included in installer? You need to install?
RouteAI Desktop App Yes No
Go API Backend Yes (bundled) No
React Frontend Yes (bundled) No
Node.js Runtime Yes (Electron) No
Ollama No Yes (for AI features)
AI Model (qwen2.5:7b) No Yes (ollama pull qwen2.5:7b)
Python ML Service No Optional (advanced AI analysis)
NVIDIA GPU Drivers No Recommended (faster AI)

GPU Recommendations

GPU VRAM AI Performance
RTX 3050/4050 6-8 GB Basic — chat + validation
RTX 3060/4060/4070 10-12 GB Good — full analysis
RTX 4080/4090 16-24 GB Excellent — all features
No GPU (CPU only) — Works but slow

From Source (Development)

git clone https://github.com/Guiimartinho/routeai.git
cd routeai
./scripts/setup-dev.sh

This installs all dependencies (Python, Node, Go, Ollama) and starts all services. See Getting Started for details.

Features

Design Analysis & Review

  • AI-Powered Design Review — Automated PCB analysis with actionable recommendations following IPC standards
  • 3-Gate Validation Pipeline — Schema validation, confidence scoring, and citation checking for all LLM outputs
  • Schematic Review — Circuit topology analysis, component selection validation, and net connectivity checks

Multi-Format Support

  • KiCad — Full import/export for .kicad_pcb and .kicad_sch files
  • Eagle — Full import/export for .brd and .sch files
  • Gerber/Excellon — Manufacturing output generation

Routing Engine

  • A* Pathfinding — Heuristic-based trace routing
  • Lee Router — Breadth-first search for guaranteed completion
  • Differential Pair Routing — Matched impedance pair routing
  • Length Matching — Trace equalization for high-speed buses
  • Rip-up and Reroute — Iterative optimization for congested boards
  • Global Routing — Multi-net simultaneous routing

Signal & Power Integrity

  • Impedance Calculation — Microstrip, stripline, and coplanar waveguide
  • Crosstalk Analysis — Near-end and far-end coupling estimation
  • Thermal Simulation — Component and copper thermal analysis
  • IR Drop Analysis — Power distribution network verification
  • Return Path Analysis — Signal integrity validation

Manufacturing

  • DRC Engine — 50+ design rule checks (geometric, electrical, manufacturing)
  • IPC Compliance — Automated IPC-2221/IPC-7351 verification
  • DFM Analysis — Design-for-manufacturing validation
  • BOM Export — Bill of materials generation
  • Gerber Generation — Production-ready output files
  • Pick & Place — Assembly data export

Component Intelligence

  • Unified Component Search — Cross-source search across KiCad, Eagle, SnapEDA, LCSC, and EasyEDA libraries
  • RAG Pipeline — Retrieval-augmented generation from IPC standards, datasheets, and design guidelines
  • 17,000+ Indexed Components — Pre-built component library with symbols and footprints

Collaboration & Integration

  • Real-Time Collaboration — WebSocket-based multi-user editing
  • KiCad Plugin — Direct integration with KiCad 8 PCB editor
  • Version Control — Built-in Git support for design versioning
  • Air-Gapped Mode — Fully offline deployment with local LLM (Ollama)

Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                         Client Layer                                │
│  ┌──────────┐  ┌──────────────┐  ┌───────────┐  ┌──────────────┐  │
│  │ Web App  │  │ Desktop App  │  │    CLI    │  │ KiCad Plugin │  │
│  │ (React)  │  │ (Electron)   │  │ (Python)  │  │  (Python)    │  │
│  └────┬─────┘  └──────┬───────┘  └─────┬─────┘  └──────┬───────┘  │
└───────┼────────────────┼────────────────┼───────────────┼──────────┘
        │                │                │               │
        └────────────────┴───────┬────────┴───────────────┘
                                 │ REST / WebSocket
┌────────────────────────────────┼───────────────────────────────────┐
│                         API Gateway (Go/Gin)                       │
│                         Port 8080                                  │
│  ┌──────────┐  ┌───────────┐  ┌───────────┐  ┌────────────────┐  │
│  │   Auth   │  │  Projects │  │ WebSocket │  │  Rate Limiter  │  │
│  │  (JWT)   │  │  Manager  │  │    Hub    │  │   Middleware   │  │
│  └──────────┘  └───────────┘  └───────────┘  └────────────────┘  │
└──────────┬──────────────────────────┬─────────────────────────────┘
           │                          │
     ┌─────┴─────┐             ┌──────┴──────┐
     │ ML Service │             │   Router    │
     │ (FastAPI)  │             │   (gRPC)    │
     │ Port 8001  │             │ Port 50051  │
     └─────┬──────┘             └──────┬──────┘
           │                           │
┌──────────┴───────────────────────────┴────────────────────────────┐
│                       Core Services                                │
│  ┌──────────────┐  ┌────────────┐  ┌──────────┐  ┌────────────┐  │
│  │ Intelligence │  │   Solver   │  │  Parsers │  │    Core     │  │
│  │  (LLM/RAG)  │  │ (DRC/SI)   │  │(KiCad/   │  │(Data Model)│  │
│  │             │  │            │  │  Eagle)   │  │            │  │
│  └──────────────┘  └────────────┘  └──────────┘  └────────────┘  │
└───────────────────────────────────────────────────────────────────┘
           │                │                │
┌──────────┴────────────────┴────────────────┴──────────────────────┐
│                       Data Layer                                   │
│  ┌──────────────────┐  ┌─────────┐  ┌──────────────────────────┐  │
│  │ PostgreSQL 16    │  │  Redis  │  │  MinIO (S3-compatible)   │  │
│  │ + PostGIS        │  │   7.x   │  │  Object Storage          │  │
│  │ + pgvector       │  │         │  │                          │  │
│  └──────────────────┘  └─────────┘  └──────────────────────────┘  │
└───────────────────────────────────────────────────────────────────┘

Tech Stack

Layer Technology Purpose
Frontend React 18 + TypeScript + Vite Web application
Desktop Electron 33 Cross-platform desktop app
3D Rendering Three.js + React Three Fiber PCB visualization
State Management Zustand Client-side state
API Gateway Go 1.22 + Gin HTTP/WebSocket gateway
ML Service Python 3.11 + FastAPI LLM orchestration
LLM Framework LangChain + Anthropic SDK AI agent pipeline
Routing Engine C++17 + gRPC + Protobuf High-performance routing
Constraint Solver Z3 Formal verification
Database PostgreSQL 16 + PostGIS + pgvector Spatial data + embeddings
Cache Redis 7 Session and rate limiting
Object Storage MinIO Design file storage
CI/CD GitHub Actions Automated testing
Monitoring Prometheus + Grafana Observability

Project Structure

routeai/
├── packages/
│   ├── core/              # Unified PCB data model (Pydantic v2)
│   ├── parsers/           # KiCad/Eagle file parsers and exporters
│   ├── intelligence/      # LLM agents, RAG pipeline, validation
│   ├── solver/            # DRC engine, SI/PI analysis, Z3 constraints
│   ├── api/               # Go API gateway (Gin + JWT + WebSocket)
│   ├── router/            # C++17 routing engine (A*, Lee, diff pair)
│   ├── web/               # React frontend (Three.js, Zustand)
│   ├── cli/               # Command-line interface (Click + Rich)
│   └── kicad-plugin/      # KiCad 8 editor integration
├── app/                   # Electron desktop application
├── infrastructure/
│   ├── docker/            # Dockerfiles for all services
│   ├── k8s/               # Kubernetes manifests
│   ├── monitoring/        # Prometheus + Grafana configs
│   └── air-gapped/        # Offline deployment setup
├── scripts/               # Setup, seeding, and benchmark scripts
├── data/
│   ├── component_library/ # Pre-indexed KiCad component data
│   ├── ipc_standards/     # IPC reference documents
│   ├── benchmarks/        # Performance test data
│   └── reference_designs/ # Sample PCB designs
├── .github/workflows/     # CI/CD pipeline
├── docker-compose.yml     # Development environment
├── docker-compose.prod.yml# Production environment
└── Makefile               # Build automation

Getting Started

Prerequisites

  • Python 3.11+ with Poetry
  • Go 1.22+
  • Node.js 18+ with npm
  • Docker and Docker Compose
  • CMake 3.20+ and Conan (for C++ routing engine)

GPU Requirements

RouteAI runs LLM inference locally via Ollama. No cloud APIs required.

GPU VRAM T3 (Chat/Validation) T2 (Analysis/DSL) T1 (Deep Review)
RTX 3050/4050 6-8 GB Phi-3.5 (3.8B) Qwen2.5 (7B) Decomposed
RTX 3060/4060/4070 10-12 GB Qwen2.5 (7B) Qwen2.5-Coder (14B) Decomposed
RTX 4060 Ti/4080 16 GB Qwen2.5 (7B) Qwen2.5-Coder (14B) Decomposed
RTX 4090 24 GB Qwen2.5 (7B) Qwen2.5 (32B) Direct

Run the setup script to auto-detect your GPU and pull the right models:

./scripts/setup_ollama.sh

Quick Start

  1. Clone the repository
git clone git@github.com:Guiimartinho/routeai.git
cd routeai
  1. Start infrastructure services
make dev

This starts PostgreSQL (port 5432), Redis (port 6379), and MinIO (ports 9000/9001).

  1. Install Python packages
for pkg in core parsers solver intelligence cli; do
  cd packages/$pkg && poetry install && cd ../..
done
  1. Build and run the API gateway
cd packages/api
go build -o routeai-api .
./routeai-api

The API will be available at http://localhost:8080.

  1. Start the ML service
cd packages/intelligence
poetry run uvicorn routeai_intelligence.ml_service:app --host 0.0.0.0 --port 8001
  1. Start the web frontend
cd packages/web
npm install
npm run dev

The web app will be available at http://localhost:5173.

Environment Variables

Create a .env file in the project root:

# Database
POSTGRES_HOST=localhost
POSTGRES_PORT=5432
POSTGRES_USER=routeai
POSTGRES_PASSWORD=routeai_dev
POSTGRES_DB=routeai

# Storage
MINIO_ENDPOINT=localhost:9000
MINIO_ACCESS_KEY=minioadmin
MINIO_SECRET_KEY=minioadmin

# LLM Provider (local Ollama — run ./scripts/setup_ollama.sh first)
OLLAMA_BASE_URL=http://localhost:11434

# JWT
JWT_SECRET=your-jwt-secret

Development

Commands

make dev              # Start development infrastructure
make dev-down         # Stop infrastructure services
make test             # Run all package tests
make test-core        # Test core package
make test-parsers     # Test parsers package
make test-intelligence# Test intelligence package
make test-solver      # Test solver package
make test-cli         # Test CLI package
make test-cov         # Run tests with coverage
make lint             # Run ruff + mypy on all packages
make lint-fix         # Auto-fix linting issues
make format           # Format code with ruff
make benchmark        # Run performance benchmarks
make clean            # Remove build artifacts

Code Quality

Tool Purpose Config
Ruff Linting + formatting ruff.toml
MyPy Static type checking (strict) mypy.ini
Pytest Unit and integration tests Per-package pyproject.toml
Google Test C++ unit tests packages/router/CMakeLists.txt

Coverage Targets

Package Target
core 80%
parsers 80%
solver 70%
intelligence 60%
cli 80%

Building the C++ Router

cd packages/router
mkdir build && cd build
conan install .. --build=missing
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build . -j$(nproc)

Building the Desktop App

cd app
npm install
npm run electron:build          # All platforms
npm run electron:build:win      # Windows
npm run electron:build:linux    # Linux

Building Installers

# Build Windows installer (.exe)
./scripts/build-installer.sh windows

# Build Linux packages (AppImage + .deb)
./scripts/build-installer.sh linux

# Build all platforms
./scripts/build-installer.sh all

Output files are in app/release/.

Deployment

Docker Compose (Production)

docker-compose -f docker-compose.prod.yml up -d

Kubernetes

kubectl apply -f infrastructure/k8s/namespace.yaml
kubectl apply -f infrastructure/k8s/

Air-Gapped (Offline)

For secure environments without internet access:

cd infrastructure/air-gapped
docker-compose -f docker-compose.airgap.yml up -d

This deployment uses local Ollama models (Mistral, LLaMA 3.1) instead of cloud APIs.

API Reference

The API gateway exposes the following endpoint groups:

Endpoint Method Description
/api/v1/auth/* POST Authentication (register, login, SSO)
/api/v1/projects/* CRUD Project management
/api/v1/reviews/* POST/GET Design review operations
/api/v1/board/* GET/POST Board data and component queries
/api/v1/chat POST LLM chat interface
/api/v1/tools/* POST DRC, routing, placement tools
/api/v1/workflow/* POST/GET Multi-step analysis workflows
/ws WebSocket Real-time collaboration
/health GET Service health check

Screenshots

PCB Viewer Design Review

3D Board View Routing Analysis

Contributing

  1. Fork the repository
  2. Create a feature branch (git checkout -b feature/your-feature)
  3. Ensure tests pass (make test)
  4. Ensure linting passes (make lint)
  5. Submit a pull request

All new code must include tests and maintain the established coverage targets.

License

This project is licensed under the MIT License. See individual package files for details.

RouteAI — Intelligent PCB Design, Powered by AI.

About

No description, website, or topics provided.

Resources

Readme
Activity

Stars

12 stars

Watchers

0 watching

Forks

2 forks
Report repository

Releases

1 tags

Packages

 
 
 

Contributors

Languages