EVY - EVYone, EVYwhere, EVYtime

Revolutionary SMS-based AI system with Off-Grid Mesh Networking

🌟 Overview

EVY is an SMS-based AI community platform optimized for edge deployment on Raspberry Pi 5 hardware. The system provides off-grid AI assistance accessible via SMS, designed for community action, information access, and knowledge sharing—with emergency response as a critical feature. Built for resource-constrained environments where traditional internet infrastructure is unavailable or unreliable.

🚀 Key Innovations

Edge-Optimized: Designed for Raspberry Pi 5 with hardware constraints in mind
Community Platform: Information, knowledge sharing, and community action
Emergency Response: Critical disaster response and emergency communication capabilities
Hybrid Architecture: Rust (critical path) + Python (ecosystem) for optimal performance
Compression Engine: Edge-optimized compression for SMS responses (160-char limit)
Off-Grid Operation: No internet or cellular dependency required
Solar Powered: Truly sustainable communication infrastructure
Resource-Aware: Battery and memory-aware operations throughout

📚 Implementation Documentation

Unified Implementation Plan ⭐ PRIMARY - Complete 24-month roadmap (Months 1-9: Edge + Enhancements, Months 10-24: Scaling & Ecosystem)
Master Implementation Plan - Original 9-month edge-focused plan
Enhancements Plan - Multiple GSM HATs, Local Connectivity, Optimization
Technical Specifications - Detailed component specs
Testing Plan - Comprehensive testing strategy
Deployment Runbook - Step-by-step deployment guide
API Documentation - Complete API reference
Quick Start Guide - Get started in 30 minutes
Documentation Index - Central documentation navigation
Implementation Index - Detailed implementation navigation

🏗️ Architecture

Dual-Node System

🌱 lilEVY (Edge Node)

Hardware: Raspberry Pi 5 (8GB/16GB RAM) + GSM HAT + LoRa HAT
Power: Solar-powered (50-100W panel, 10-15W consumption)
Capabilities: SMS interface, tiny LLM inference (BitNet/edge models), local RAG, mesh networking
Range: 10-15 miles via LoRa mesh network
Cost: ~$450 per node
Edge Constraints: 8GB RAM, 4 cores, ARM64, microSD storage
Optimizations: Rust for critical path, compression engine, resource-aware operations

🏢 bigEVY (Central Node)

Hardware: High-performance server + GPU
Capabilities: Large LLM inference, global RAG, analytics, coordination
Power: Grid-connected or large solar array
Role: Heavy AI processing, model updates, knowledge management

🔗 Mesh Networking

Communication Layers:
├── SMS Layer: Direct user communication
├── LoRa Layer: 10-15 mile mesh network
├── Internet Layer: When available (fallback)
└── Bluetooth Layer: Local area communication

🧩 Idealized Component Blueprint (Current)

lilEVY Hardware Profile (Edge Node)

Compute: Raspberry Pi 5 (8GB/16GB)
Cellular/SMS + GNSS: SIM7600-series 4G HAT over USB (/dev/ttyUSB0, /dev/ttyUSB1)
LoRa Mesh: SX1276 LoRa HAT over SPI (/dev/spidev0.0) with configurable CS pin
GPS: NMEA source from LoRa/GPS HAT UART or SIM7600 GNSS path
Power Telemetry: battery level path wired for edge power-aware routing
Deployment Defaults: region-aware LoRa frequency, offline-first service priorities

lilEVY Service Topology

sms-gateway: SMS ingress/egress with direct-send fallback when queue is unavailable
message-router: intent-aware routing, multi-SMS chunking, and operator !status command
tiny-llm: local inference with Ollama defaults and BitNet-ready provider switching
local-rag: ChromaDB-backed retrieval with similarity thresholding and hash-based sync
node-communication: LoRa node messaging, discovery, routing, and telemetry plumbing
monitoring: Prometheus metrics collection for edge observability

Cross-Cutting Platform Components

Rust services: sms_gateway, message_router, and compression crates for critical paths
Emergency response: template + detector + service flow for high-priority scenarios
Shared integration layer: service discovery, rust bridge utilities, and local edge database
Validation harnesses: full software suite and per-device hardware validation scripts

🔧 Hardware Requirements

🌱 lilEVY Node (Edge)

Core Components:
  Raspberry Pi 5 (8GB RAM): $80-100
    - ARM Cortex-A76 quad-core 64-bit processor
    - 8GB LPDDR5 RAM (16GB optional)
    - Gigabit Ethernet, WiFi, Bluetooth
    - 40-pin GPIO header

  GSM HAT (SMS Communication): $50
    - SIM800L or similar GSM module
    - Antenna included
    - SMS/voice/data capabilities
    - Power: 3.7V-4.2V, 2A peak

  LoRa HAT (Mesh Networking): $25
    - SX1276 LoRa transceiver
    - 915MHz default for US (region-configurable)
    - 14dBm output power
    - 10-15 mile range (line of sight)

  MicroSD Card (32GB+): $15
    - Class 10 or better
    - 32GB minimum (recommended 64GB)
    - For OS and data storage

  Power Management:
    Solar Panel (50-100W): $80-150
      - 12V or 24V panel
      - Weatherproof design
      - MC4 connectors
    
    Charge Controller: $25
      - MPPT or PWM type
      - 12V/24V compatible
      - Overcharge protection
    
    Battery (12V 36Ah): $120
      - Deep cycle AGM or lithium
      - 0.36kWh capacity
      - 3+ days runtime without sun

  Enclosure & Accessories:
    Weatherproof Enclosure: $40
      - IP65 rated
      - Vented for cooling
      - Mounting brackets
    
    Antennas: $30
      - GSM antenna (2dBi)
      - LoRa antenna (3dBi)
      - Coaxial cables
    
    Cables & Connectors: $20
      - Jumper wires
      - Power cables
      - Mounting hardware

Total lilEVY Cost: ~$400-450

🏢 bigEVY Node (Central)

Server Hardware:
  Main Server: $2,000-5,000
    - Intel Xeon or AMD EPYC processor
    - 32GB+ RAM (64GB recommended)
    - 1TB+ SSD storage
    - Gigabit Ethernet
    - Redundant power supplies

  GPU (Optional but Recommended): $1,000-3,000
    - NVIDIA RTX 4090 or A6000
    - 24GB+ VRAM
    - For large model inference
    - CUDA support

  Networking:
    High-Speed Internet: $100/month
      - Fiber or cable connection
      - 100+ Mbps upload
      - Static IP (recommended)
    
    Backup Internet: $50/month
      - Cellular hotspot
      - 4G/5G connection
      - Failover capability

  Power & Cooling:
    UPS Battery Backup: $500
      - 1500VA or higher
      - 30+ minute runtime
      - Network management
    
    Cooling System: $200
      - Server rack fans
      - Temperature monitoring
      - Automatic shutdown

Total bigEVY Cost: $4,000-10,000+

📡 Enhanced lilEVY (With Mesh Networking)

Additional Components for Mesh:
  LoRa HAT: $25
    - SX1276 LoRa transceiver
    - 915MHz default for US deployments
    - 14dBm output power

  LoRa Antenna: $15
    - Tuned to deployment region (915MHz for US)
    - 3dBi gain
    - Weatherproof design

  Antenna Mount: $10
    - Mast or pole mount
    - Coaxial cable routing
    - Grounding system

Additional Cost: +$50 per node
Total Enhanced lilEVY: ~$450

🔌 Development & Testing Hardware

Development Setup:
  Raspberry Pi 5 Kit: $120
    - Pi 5, power supply, case
    - MicroSD card, cables
    - For development/testing

  GSM/LoRa Development Kit: $150
    - Multiple HATs for testing
    - Various antennas
    - Breadboard setup

  Multimeter & Tools: $50
    - Digital multimeter
    - Soldering iron
    - Wire strippers, crimpers

  Network Testing: $100
    - LoRa range testers
    - Signal analyzers
    - Network monitoring tools

Development Cost: ~$400

📋 Hardware Compatibility Matrix

lilEVY Compatibility:
  Raspberry Pi Models:
    ✅ Pi 5 (8GB/16GB) - Recommended
    ✅ Pi 4 (8GB) - Compatible fallback
    ⚠️ Pi 3B+ - Limited performance
    ❌ Pi 1/2/Zero - Not supported

  GSM HAT Compatibility:
    ✅ SIM800L - Primary support
    ✅ SIM900 - Compatible
    ✅ SIM7600 - 4G support
    ❌ SIM7000 - Different driver needed

  LoRa HAT Compatibility:
    ✅ SX1276 - Primary support
    ✅ SX1278 - Compatible
    ✅ SX1262 - Future support
    ❌ SX1280 - Different frequency

  Power Requirements:
    Pi 5 + GSM HAT: ~8W
    Pi 5 + GSM + LoRa: ~10W
    Solar Panel: 50W minimum
    Battery: 36Ah recommended

🛒 Recommended Suppliers

Raspberry Pi & Accessories:
  - Adafruit: https://adafruit.com
  - SparkFun: https://sparkfun.com
  - Digi-Key: https://digikey.com
  - Mouser: https://mouser.com

GSM/LoRa HATs:
  - Waveshare: https://waveshare.com
  - Dragino: https://dragino.com
  - Adafruit: LoRa modules
  - SparkFun: GSM modules

Solar & Power:
  - Renogy: https://renogy.com
  - Goal Zero: https://goalzero.com
  - Amazon: Solar panels
  - Local electrical suppliers

Enclosures & Mounting:
  - Polycase: https://polycase.com
  - Bud Industries: https://budind.com
  - Amazon: Weatherproof boxes
  - Local hardware stores

💰 Cost Breakdown by Deployment Scale

Small Deployment (3-5 nodes):
  lilEVY Nodes: $450 × 5 = $2,250
  bigEVY Node: $4,000
  Development Tools: $400
  Total: ~$6,650

Medium Deployment (10-20 nodes):
  lilEVY Nodes: $450 × 15 = $6,750
  bigEVY Node: $6,000 (with GPU)
  Network Infrastructure: $1,000
  Total: ~$13,750

Large Deployment (50+ nodes):
  lilEVY Nodes: $450 × 50 = $22,500
  bigEVY Cluster: $15,000 (multiple servers)
  Network Infrastructure: $5,000
  Total: ~$42,500

Cost per User (100 users/node):
  Small: $66.50 per user
  Medium: $9.17 per user
  Large: $2.83 per user

🛠️ Technology Stack

Backend Services

Rust Components (Critical Path):
- SMS Gateway (backend/rust_services/sms_gateway)
- Message Router (backend/rust_services/message_router)
- Compression Engine (backend/rust_services/compression)
Python Components (Ecosystem):
- LLM Inference (Ollama default + BitNet support)
- RAG Service (ChromaDB + persistent embedding cache)
- SMS Gateway + Message Router API services
- LoRa Node Communication + Emergency Response
- Edge DB + Shared integration modules
Framework: Python 3.11, FastAPI, Uvicorn
LLM: BitNet-first edge inference path
Vector DB: ChromaDB (persistent edge store)
Database: SQLite (edge-first persistence)
Monitoring: Prometheus (edge metrics)
Containerization: Docker + Docker Compose

Mesh Networking

Radio: LoRa (region-aware defaults; 915MHz for US deployments)
Protocol: Custom EVY Mesh Protocol with self-healing
Security: AES-256 encryption, digital signatures
Routing: Intelligent multi-hop routing with priority queuing

Frontend

Framework: React 18, TypeScript, Vite
Styling: TailwindCSS
Features: Real-time mesh visualization, LoRa monitoring

🚀 Quick Start

For Implementation

See Quick Start Guide for rapid deployment (30 minutes)

For Development

See Development Setup for local development environment

Standard lilEVY Deployment

# Clone repository
git clone https://github.com/evy-ai/evy.git
cd EVY

# Deploy standard lilEVY
./deploy-lilevy.sh

Enhanced lilEVY with Mesh Networking

# Deploy enhanced lilEVY with LoRa radio
./deploy-enhanced-lilevy.sh

Hybrid System (lilEVY + bigEVY)

# Deploy both lilEVY and bigEVY
./deploy-hybrid.sh

Service Endpoints

Frontend Dashboard: http://localhost:3000
API Gateway: http://localhost:8000
API Documentation: http://localhost:8000/docs
Mesh Monitoring: http://localhost:3001
Prometheus: http://localhost:9090

📖 Implementation Resources

Master Implementation Plan - Complete roadmap
Technical Specifications - Component details
Deployment Runbook - Detailed deployment steps
Implementation Checklist - Pre-implementation readiness

📱 Usage

SMS Interface

Send any SMS to your lilEVY node and receive AI-powered responses:

Example Queries:
- "What hospitals are near me?"
- "How do I perform CPR?"
- "Weather emergency protocol"
- "Emergency help needed" (triggers priority routing)

Smart Routing

EVY automatically selects the best communication method:

Simple queries: Processed locally
Complex queries: Routed to bigEVY via mesh network
Emergency queries: Prioritized through fastest path
Off-grid: Full functionality without internet

🗂️ Project Structure

EVY/
├── backend/
│   ├── lilevy/                    # lilEVY-specific services
│   │   └── services/
│   │       ├── lora_radio_service.py      # LoRa mesh networking
│   │       ├── enhanced_lilevy_service.py # Main orchestrator
│   │       └── tiny_llm_service.py        # Edge LLM inference
│   ├── bigevy/                    # bigEVY-specific services
│   │   └── services/
│   │       ├── large_llm_service.py       # Central LLM processing
│   │       └── global_rag_service.py      # Global knowledge base
│   ├── shared/                    # Shared utilities
│   │   ├── communication/
│   │   │   ├── smart_router.py           # Intelligent routing
│   │   │   ├── mesh_protocol.py          # Mesh networking
│   │   │   └── knowledge_sync.py         # Data synchronization
│   │   ├── models.py              # Data models
│   │   └── config.py              # Configuration
│   ├── services/                  # Core nanoservices
│   │   ├── sms_gateway/           # SMS communication
│   │   ├── message_router/        # Message routing
│   │   ├── llm_inference/         # LLM inference engine
│   │   ├── rag_service/           # Retrieval-Augmented Generation
│   │   └── privacy_filter/        # Data sanitization
│   └── api_gateway/               # Main API gateway
├── frontend/                      # React dashboard
├── scripts/                       # Knowledge base builders
├── monitoring/                    # Prometheus configuration
├── docker-compose.lilevy.yml      # lilEVY deployment
├── docker-compose.bigevy.yml      # bigEVY deployment
├── docker-compose.enhanced-lilevy.yml # Enhanced lilEVY with LoRa
├── docker-compose.hybrid.yml      # Hybrid system deployment
└── deploy-*.sh                    # Deployment scripts

🔧 Configuration

Environment Variables

# Core Configuration
NODE_TYPE=lilevy|bigevy
NODE_ID=unique-node-identifier
LLM_PROVIDER=openai|ollama
OPENAI_API_KEY=your_api_key

# LoRa Mesh Configuration
LORA_ENABLED=true
LORA_FREQUENCY=915.0
LORA_POWER=14
MESH_NETWORK_ENABLED=true
SMART_ROUTING_ENABLED=true

# SMS Configuration
SMS_DEVICE=/dev/ttyUSB1
GSM_ENABLED=true

# Performance Tuning
MAX_SMS_PER_MINUTE=10
MAX_SMS_PER_HOUR=100
RESPONSE_TIME_TARGET=5

📊 Knowledge Base

Comprehensive Local Knowledge (626 entries, 15.4MB)

Emergency Procedures: 54 entries (CPR, first aid, disaster response)
Local Services: 40 entries (hospitals, utilities, government)
Educational Resources: 34 entries (K-12, higher ed, adult learning)
Health & Wellness: 26 entries (preventive care, chronic disease)
Legal & Regulatory: 29 entries (rights, procedures, resources)
Community Services: 36 entries (social services, mental health)
Cultural & Entertainment: 35 entries (museums, theaters, parks)
Technology & Digital: 26 entries (connectivity, digital literacy)
Advanced Features: 300+ entries (AI, security, automation)

Real-Time Synchronization

bigEVY → lilEVY: Priority-based knowledge updates
Emergency Alerts: Immediate weather, safety, system alerts
Community Updates: Local events, service changes
Model Updates: AI model improvements and patches

🌍 Deployment Options

1. Standard lilEVY (SMS + Local AI)

./deploy-lilevy.sh

SMS interface with local LLM
Local RAG knowledge base
Offline operation capability
Cost: ~$400 per node

2. Enhanced lilEVY (SMS + Mesh Network)

./deploy-enhanced-lilevy.sh

All standard features plus:
LoRa mesh networking (10-15 mile range)
Smart communication routing
Self-healing network capabilities
Cost: ~$450 per node

3. Hybrid System (lilEVY + bigEVY)

./deploy-hybrid.sh

Multiple lilEVY nodes + central bigEVY
Complex query processing
Global knowledge management
Advanced analytics and monitoring

📈 Performance Metrics

Communication Performance

SMS Interface:
  Response Time: <10s (target: <15s)
  Success Rate: >95%
  Character Limit: 160 (SMS standard)
  Uptime: >99%
  Latency: <50ms (Rust SMS Gateway)

LoRa Mesh Network:
  Range: 10-15 miles (line of sight)
  Data Rate: 0.3-50 kbps
  Latency: <2.5s (with compression)
  Reliability: >95% message delivery
  Power: <1W (transmitting)

Smart Routing:
  Decision Time: <50ms (Rust Message Router)
  Fallback Time: <1 second
  Success Rate: >98%
  Coverage: Unlimited (via mesh)

Compression:
  Compression Time: <1s (rule-based), <1.5s (with model)
  Compression Ratio: 40-50% (vs 20-30% truncation)
  Memory Usage: <50MB

Resource Usage (Edge Constraints)

lilEVY Node (Raspberry Pi 5, 8GB RAM):
  Memory Budget:
    OS & System: 1.0GB
    Rust Services: 0.5GB (SMS, Router, Compression, Mesh)
    Python Services: 1.5GB (LLM, RAG, Emergency)
    Models: 2.0GB (BitNet-class edge models)
    Database Cache: 0.5GB
    Buffer: 1.4GB
    Total: 7.0GB (87.5% utilization)
  
  CPU Budget (4 cores):
    SMS Gateway: 25% (Core 0)
    Message Router: 25% (Core 1)
    LLM Inference: 50% (Core 2)
    RAG Service: 25% (Core 3)
    Other Services: 25% (Shared)
    Total: 150% (overlap acceptable)
  
  Power Budget:
    Raspberry Pi: 5-10W (idle-active)
    GSM HAT: 2-5W (idle-transmitting)
    LoRa HAT: 0.5-1W (idle-transmitting)
    Services: 2-4W (idle-active)
    Total: 9.5-20W (within 15W target)
  
  Storage Budget (128GB):
    OS: 8GB
    Models: 5GB (compressed, quantized)
    Database: 2GB (SQLite, with growth)
    Logs: 1GB (rotated, minimal)
    Services: 2GB
    Buffer: 110GB
    Total: 18GB (14% utilization)

🎯 Use Cases

Community Information & Knowledge

Local Information Access: Services, events, news, and community resources
Knowledge Sharing: Educational content, tutorials, and learning resources
Community Action: Volunteer coordination, community organizing, local initiatives
Digital Bridge: Connect communities without reliable internet infrastructure
Information Democracy: Universal access to information via SMS

Emergency Response

Disaster Communication: Works when cell towers fail
Emergency Coordination: First responder communication
Public Safety Alerts: Weather alerts, evacuation notices
Emergency Information: Access to emergency procedures, medical info
Resource Management: Supply tracking, volunteer coordination
Infrastructure Independence: Off-grid operation during disasters

Rural & Remote Communities

Digital Bridge: Connect remote areas without infrastructure
Local Services: Access to healthcare, education, government services
Community Connectivity: Mesh networking for community-wide communication
Educational Support: Learning resources and tutoring
Agricultural Information: Farming tips, weather, market prices

Research & Field Applications

Remote Stations: Data collection and sharing
Environmental Monitoring: Sensor networks and reporting
Scientific Collaboration: Research coordination
Field Studies: Off-grid data access and analysis

🔮 Roadmap & Implementation Status

✅ Foundation + Edge Hardening (Complete)

✅ Offline-first defaults and deployment gating are implemented
✅ GSM/LoRa/GPS/power hardware paths are wired in service code
✅ RAG reliability improvements are in place (cache + threshold + hash sync)
✅ BitNet/local-first routing updates are integrated
✅ Verification and operator observability workflows are added

✅ Validation Assets (Complete)

✅ Full software validation suite (scripts/test_software_suite.py)
✅ Hardware validation checklist + per-device test scripts
✅ Integration and regression test updates for current architecture

📌 Next Execution Focus

Run hardware suite on target Pi hardware and record baselines
Publish operator runbooks from measured field metrics
Promote release cut after hardware go/no-go signoff

📋 Implementation Timeline

Phase 1: Edge Implementation (Months 1-9)

Months 1-3: Critical Foundation (Hardware validation, Rust services, Integration)
Months 4-6: Core Infrastructure (Model management, Database, Mesh, Monitoring) + Multiple GSM HATs
Months 7-9: Production Readiness (Security, API Gateway, Deployment) + Local Connectivity + Hybrid Cloud SMS

Phase 2: Multi-Node Deployment (Months 10-12)

Multi-node architecture, bigEVY integration, network deployment

Phase 3: Production Deployment (Months 13-18)

Security & compliance, performance optimization, pilot deployment, production launch

Phase 4: Community & Ecosystem (Months 19-24)

Open source release, partnerships, module marketplace, international expansion, global impact

See Unified Implementation Plan ⭐ for complete 24-month timeline.

📚 Documentation

Implementation Documentation

Master Implementation Plan - Complete 9-month roadmap with phases, milestones, and resource budgets
Technical Specifications - Detailed component specifications, interfaces, and algorithms
Testing Plan - Comprehensive testing strategy with unit, integration, and hardware tests
Deployment Runbook - Step-by-step deployment guide for edge hardware
API Documentation - Complete API reference for all services
Quick Start Guide - Get started in 30 minutes
Development Setup - Local development environment setup
Implementation Checklist - Pre-implementation readiness checklist
Documentation Index - Central documentation navigation
Implementation Index - Detailed implementation navigation

Strategic Documents

Pivot Strategy - Community platform strategy with emergency response focus
Compression Integration - Compression engine integration details
Rust Refactor Analysis - Selective Rust refactoring strategy
Gap Analysis - Complete gap analysis and priorities
Competitive Landscape - Market analysis and positioning

🤝 Contributing

EVY is an open-source project building the future of resilient AI community communication and knowledge sharing. We welcome contributions!

How to Contribute

Review Implementation Documentation - Start with Master Implementation Plan
Check Implementation Checklist - Verify readiness with Implementation Checklist
Fork the repository
Create a feature branch
Follow Technical Specifications - Use Technical Specifications as reference
Add tests - Follow Testing Plan
Update documentation
Submit a pull request

Areas for Contribution

Rust Components: SMS Gateway, Message Router, Compression Engine, Mesh Network
Python Components: LLM Service, RAG Service, Emergency Service
Hardware Integration: GSM/LoRa HAT drivers, power management
Protocol Development: Mesh networking improvements
Knowledge Base: Emergency procedures, local information
Testing: Unit tests, integration tests, hardware tests
Documentation: Guides, tutorials, API documentation

📄 License

MIT License

📞 Contact & Support

GitHub Issues: Report bugs and request features
Documentation: See individual component guides
Community: Join the EVY development community
Email: jonathan.kershaw@gmail.com

🌟 Acknowledgments

EVY represents a paradigm shift in communication technology, combining:

AI Intelligence from modern language models
Mesh Networking resilience from LoRa radio
Universal Access through SMS interface
Sustainability through solar power

Built for a world where everyone deserves access to AI assistance, everywhere, everytime.

EVY - Making AI accessible to EVYone, EVYwhere, EVYtime through the power of SMS and mesh networking. 🚀📡🤖

🎯 Implementation Ready

EVY now includes implementation-ready architecture and delivered component paths across edge services, Rust critical-path modules, and validation tooling.

✅ Core edge services integrated
✅ Rust service crates included
✅ Local-first routing + BitNet path implemented
✅ RAG reliability and knowledge sync improvements applied
✅ Software and hardware validation assets available

See Documentation Index for the complete component-by-component reference.

Last Updated: March 2026 - Implementation + Validation Baseline Established

Name		Name	Last commit message	Last commit date
Latest commit History 6 Commits
backend		backend
config		config
docs		docs
frontend		frontend
monitoring		monitoring
scripts		scripts
.gitignore		.gitignore
Dockerfile		Dockerfile
README.md		README.md
deploy-bigevy.sh		deploy-bigevy.sh
deploy-enhanced-lilevy.sh		deploy-enhanced-lilevy.sh
deploy-hybrid.sh		deploy-hybrid.sh
deploy-lilevy.sh		deploy-lilevy.sh
docker-compose.bigevy.yml		docker-compose.bigevy.yml
docker-compose.enhanced-lilevy.yml		docker-compose.enhanced-lilevy.yml
docker-compose.hybrid.yml		docker-compose.hybrid.yml
docker-compose.lilevy.yml		docker-compose.lilevy.yml
docker-compose.yml		docker-compose.yml
env.template		env.template
env.wichita		env.wichita
start-local.sh		start-local.sh
start.bat		start.bat
start.sh		start.sh
test-system.py		test-system.py

Folders and files

Latest commit

History

Repository files navigation