NexusScribe

AI-Powered Real-Time Transcription & Meeting Intelligence Platform

NexusScribe is a self-hosted, enterprise-grade transcription platform that transforms meetings into actionable intelligence. Built for organizations requiring on-premises data sovereignty, it delivers real-time speech-to-text transcription with speaker diarization, powered by local AI inference.

---

Table of Contents

• Features
• Architecture
• Quick Start
• Installation
• Configuration
• Security
• Compliance
• API Reference
• Crate Documentation
• Performance
• Deployment
• Development
• Contributing
• License

---

Features

Cloud SaaS Platform

• Multi-tenant architecture with organization-based data isolation
• Stripe billing integration with subscription plans and metered usage
• Self-service signup with email verification via Resend
• S3 cloud storage for recordings and transcripts with presigned URLs
• Usage tracking with quota enforcement (402 responses when exceeded)
• Plan tiers: Free (5 meetings/month), Pro ($29/month), Enterprise (custom)

Real-Time Transcription

• Sub-200ms latency speech-to-text using Whisper models
• Multiple compute backends: CPU (64GB+ RAM), CUDA GPU, Hailo NPU (8/10-H)
• Automatic language detection with support for 99 languages
• Word-level timestamps for precise navigation and search
• Configurable model sizes: tiny, base, small, medium, large-v2, large-v3

Speaker Diarization

• MFCC-based voice embeddings for speaker identification
• Real-time speaker separation during live meetings
• Voice profile training for improved accuracy over time
• Clustering algorithms for unknown speaker detection

Meeting Intelligence

• Automatic summarization with key points extraction
• Action item detection and assignment tracking
• Sentiment analysis per speaker and segment
• Topic clustering and keyword extraction
• Searchable transcript archive

Collaboration

• Real-time collaborative editing with operational transformation (OT)
• Inline comments with threaded discussions
• Version history with full audit trail
• Export to PDF, DOCX, JSON, SRT, VTT formats
• Timestamp-linked commenting

Video Conferencing Integration

• Microsoft Teams bot integration with audio capture
• Zoom meeting transcription via bot
• Google Meet support
• LiveKit native video conferencing with WebRTC
• Custom WebSocket audio streaming API

Mobile App (React Native/Expo)

• Cross-platform iOS and Android support via Expo SDK 54
• Real-time transcription with waveform visualization
• AI Studio with editing tools (clarity, tone, filler removal, chapters)
• External meeting transcription - connect bots to Zoom/Teams/Meet
• Offline support with automatic sync when online
• Push notifications for meeting reminders and transcription completion
• Secure authentication with MFA support
• Share & export transcripts in multiple formats

Enterprise Features

• Role-based access control (RBAC) with Admin, Editor, Viewer, Guest roles
• Multi-factor authentication (TOTP) with backup codes
• JWT authentication with refresh token rotation and blacklisting
• SSO/SAML authentication (Okta, Azure AD, Google Workspace, OneLogin)
• Webhook integrations with HMAC-SHA256 signatures and retry logic
• Custom vocabulary for domain-specific terminology and acronyms
• Meeting templates with preset titles, descriptions, and participants
• HashiCorp Vault integration for secrets management at scale
• Rate limiting with token bucket algorithm (5/min auth, 100/min API)
• Security headers (CSP, HSTS, X-Frame-Options)
• Account lockout after failed login attempts
• API-first architecture for integrations
• Multi-tenant organization support

Compliance & Privacy

• HIPAA compliance with audit logging, AES-256-GCM encryption, BAA tracking
• SOC 2 Type II controls with security events, access reviews, incident tracking
• GDPR compliance with data subject rights (access, portability, erasure, consent)
• CCPA compliance with Do Not Sell flag and CA consumer rights
• FERPA compliance for educational institutions with student record protection
• Data retention policies with configurable retention periods and auto-deletion
• Compliance reporting with exportable audit trails for regulators

---

Architecture

┌─────────────────────────────────────────────────────────────────────────┐
│                          NexusScribe Platform                            │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐ │
│  │   Next.js    │  │    React     │  │    Axum      │  │   Meeting    │ │
│  │   Web App    │  │   Native     │  │   REST API   │  │    Bots      │ │
│  │   (Web UI)   │  │  (Mobile)    │  │   (Rust)     │  │  (Node.js)   │ │
│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘ │
│         │                 │                 │                 │          │
│         └─────────────────┴────────┬────────┴─────────────────┘          │
│                                    │                                     │
│                           ┌────────▼────────┐                            │
│                           │   WebSocket     │                            │
│                           │   Gateway       │                            │
│                           └────────┬────────┘                            │
│                                    │                                     │
│  ┌─────────────────────────────────┴─────────────────────────────────┐  │
│  │                       Core Services Layer                          │  │
│  ├────────────┬────────────┬────────────┬────────────┬───────────────┤  │
│  │   Audio    │Transcription│  Speaker   │Collaboration│    Auth      │  │
│  │  Pipeline  │   Engine   │Diarization │   Engine   │   Service    │  │
│  │            │  (Whisper) │   (MFCC)   │    (OT)    │  (JWT/MFA)   │  │
│  └─────┬──────┴─────┬──────┴─────┬──────┴─────┬──────┴───────┬──────┘  │
│        │            │            │            │              │          │
│        └────────────┴─────┬──────┴────────────┴──────────────┘          │
│                           │                                             │
│              ┌────────────┼────────────┐                                │
│              │            │            │                                │
│        ┌─────▼─────┐ ┌────▼────┐ ┌─────▼─────┐                         │
│        │   CPU     │ │  CUDA   │ │   Hailo   │                         │
│        │ (Whisper) │ │   GPU   │ │    NPU    │                         │
│        │           │ │         │ │ (40 TOPS) │                         │
│        └───────────┘ └─────────┘ └───────────┘                         │
│                           │                                             │
│                  ┌────────▼────────┐                                   │
│                  │    Aegis-DB     │                                   │
│                  │  ┌───────────┐  │                                   │
│                  │  │Relational │  │  (Users, Meetings, Transcripts)   │
│                  │  │TimeSeries │  │  (Audio Metrics, System Stats)    │
│                  │  │ Document  │  │  (Comments, Insights, Exports)    │
│                  │  │   Graph   │  │  (Relationships, Topics)          │
│                  │  └───────────┘  │                                   │
│                  └─────────────────┘                                   │
└─────────────────────────────────────────────────────────────────────────┘

Data Flow

Audio Input → Preprocessing (16kHz mono, VAD) → Inference Engine →
Speaker Diarization → WebSocket Broadcast → Aegis-DB Storage →
Collaborative Editor → Export (PDF/DOCX/JSON/SRT)

---

Quick Start

Prerequisites

• Rust 1.75+ with cargo
• Node.js 20+ with npm
• PM2 process manager (npm install -g pm2)
• Aegis-DB (bundled or separate installation)
• Whisper model (auto-downloaded or manual)

5-Minute Setup (PM2 - Recommended)

# Clone the repository
git clone https://github.com/AutomataNexus/NexusScribe.git
cd NexusScribe

# Build everything
./nexus-ctl build

# Initialize the database (first time only)
./nexus-ctl db-init

# Download Whisper model (base, ~142MB)
mkdir -p models/whisper
curl -L -o models/whisper/ggml-base.bin \
  https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin

# Start all services via PM2
./nexus-ctl start

# Check status
./nexus-ctl status

Open http://localhost:3000 in your browser.

PM2 Service Management

# Start all services
./nexus-ctl start               # or: pm2 start ecosystem.config.js

# Stop all services
./nexus-ctl stop                # or: pm2 stop all

# Restart all services
./nexus-ctl restart             # or: pm2 restart all

# View logs
./nexus-ctl logs                # All logs
./nexus-ctl logs nexus-backend  # Backend only
./nexus-ctl logs nexus-web      # Frontend only
./nexus-ctl logs aegis-db       # Database only

# Monitor dashboard
pm2 monit

# Enable startup on boot
pm2 startup
pm2 save

Manual Setup (Alternative)

# Build the Rust backend
cargo build --release

# Download Whisper model
mkdir -p models/whisper
curl -L -o models/whisper/ggml-base.bin \
  https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin

# Start Aegis-DB
./deploy/aegis-db/start.sh start

# Start the backend
WHISPER_MODEL_PATH=./models/whisper/ggml-base.bin \
  ./target/release/nexus-scribe &

# Start the web app
cd web && npm install && npm run dev

---

Installation

From Crates.io

# Install individual crates
cargo add nexus-scribe-core
cargo add nexus-scribe-auth
cargo add nexus-scribe-transcription

From Source

git clone https://github.com/AutomataNexus/NexusScribe.git
cd NexusScribe
cargo build --release --workspace

Docker

# Build image
docker build -t nexus-scribe:latest .

# Run with docker-compose
docker-compose up -d

Raspberry Pi 5 Cross-Compilation

# Add ARM64 target
rustup target add aarch64-unknown-linux-gnu

# Cross-compile
RUSTFLAGS="-C target-cpu=cortex-a76" \
  cargo build --release --target aarch64-unknown-linux-gnu

---

Configuration

Configuration File

Create config/nexus-scribe.toml:

[server]
host = "0.0.0.0"
port = 8080

[database]
url = "aegis://localhost:9091/nexus_scribe"
pool_size = 10
timeout = 30

[auth]
jwt_secret = "your-secret-key-min-32-chars"
access_token_expiry = 3600      # 1 hour
refresh_token_expiry = 604800   # 7 days

[transcription]
model_path = "/opt/NexusScribe/models/whisper/ggml-base.bin"
device = "auto"         # auto, cpu, cuda, hailo
language = "en"         # or "auto" for detection
threads = 0             # 0 = auto-detect

[hailo]
enabled = false
device_id = 0
batch_size = 1
timeout_ms = 5000

[models]
models_path = "/opt/NexusScribe/models"

Environment Variables

Variable	Description	Default
WHISPER_MODEL_PATH	Path to Whisper GGML model	models/whisper/ggml-base.bin
JWT_SECRET	Secret for JWT signing (required)	-
RUST_LOG	Log level	info
DATABASE_URL	Aegis-DB connection	aegis://localhost:9091
HAILO_ENABLED	Enable Hailo NPU	false
RESEND_API_KEY	Resend API key for transactional emails	-
STRIPE_SECRET_KEY	Stripe secret key for billing	-
STRIPE_WEBHOOK_SECRET	Stripe webhook signing secret	-
STRIPE_PRICE_PRO	Stripe Price ID for Pro plan	-
AWS_ACCESS_KEY_ID	AWS access key for S3 storage	-
AWS_SECRET_ACCESS_KEY	AWS secret key for S3 storage	-
AWS_S3_BUCKET	S3 bucket name for file storage	-
AWS_S3_REGION	S3 bucket region	us-east-1

Whisper Model Selection

Model	Size	VRAM	Speed	Accuracy
tiny	75MB	1GB	Fastest	Basic
base	142MB	1GB	Fast	Good
small	466MB	2GB	Medium	Better
medium	1.5GB	5GB	Slow	High
large-v2	2.9GB	10GB	Slowest	Highest
large-v3	2.9GB	10GB	Slowest	Best

---

Security

NexusScribe implements enterprise-grade security. See SECURITY.md for complete documentation.

Key Security Features

Feature	Description
Authentication	JWT with refresh tokens, MFA (TOTP), account lockout
Authorization	RBAC (Admin/Editor/Viewer/Guest), IDOR protection
Secrets	HashiCorp Vault integration or environment variables
Transport	TLS 1.3 via nginx or native (--features tls)
Input Validation	SQL injection protection, path traversal prevention
Rate Limiting	Token bucket (5/min auth, 100/min API)
Headers	CSP, HSTS, X-Frame-Options, X-Content-Type-Options
WebSocket	JWT auth, origin validation, message size limits

Quick Security Setup

# Generate secure secrets
export JWT_SECRET=$(openssl rand -base64 48)
export DB_PASSWORD=$(openssl rand -base64 32)

# Production mode (enforces secret validation)
export NEXUS_SCRIBE_ENV=production

# Optional: HashiCorp Vault for enterprise
cargo build --release --features vault
export NEXUS_SCRIBE_VAULT__ENABLED=true
export NEXUS_SCRIBE_VAULT__ADDRESS=https://vault.example.com:8200

Feature Flags

Flag	Description
--features vault	HashiCorp Vault secrets management
--features tls	Native TLS termination (alternative to nginx)
--features hailo	Hailo NPU acceleration (Pi5 hardware)
--features saml	SSO/SAML authentication support
--features compliance	Full compliance suite (HIPAA, SOC 2, GDPR)

---

Compliance

NexusScribe supports enterprise compliance requirements out of the box.

HIPAA Compliance

Feature	Description
Audit Logging	6-year retention of all PHI access events
Encryption	AES-256-GCM encryption for data at rest
Access Controls	Role-based access with minimum necessary principle
BAA Tracking	Business Associate Agreement management
Breach Detection	Automated monitoring for unauthorized access

SOC 2 Type II

Control	Description
Security Events	Real-time logging of security-relevant events
Access Reviews	Periodic access certification workflows
Incident Management	Incident tracking with root cause analysis
Vendor Management	Third-party risk assessment tracking
Change Management	Audit trail for system changes

GDPR Compliance

Right	Implementation
Right to Access	Self-service data export (JSON format)
Right to Portability	Machine-readable data download
Right to Erasure	Automated data deletion workflow
Consent Management	Granular consent tracking per purpose
DPA Tracking	Data Processing Agreement management

CCPA Compliance

Feature	Description
Do Not Sell	Opt-out flag for data sales
Consumer Rights	Access, deletion, and correction requests
Privacy Notice	Required disclosures at collection
CA Resident	California residency declaration

FERPA Compliance

Feature	Description
Student Records	Protected education records handling
Directory Opt-out	Student opt-out from directory information
Consent Tracking	Parental/eligible student consent
Access Logs	Record of all education record access

Data Retention

Configure retention policies per data type:

[compliance.retention]
transcripts = "7 years"      # Meeting transcripts
audit_logs = "6 years"       # HIPAA requirement
user_data = "account_lifetime + 30 days"
recordings = "90 days"       # Audio/video files

---

API Reference

Authentication

# Register new user
curl -X POST http://localhost:8080/api/v1/auth/register \
  -H "Content-Type: application/json" \
  -d '{
    "email": "user@example.com",
    "password": "SecurePass123!",
    "display_name": "John Doe"
  }'

# Login
curl -X POST http://localhost:8080/api/v1/auth/login \
  -H "Content-Type: application/json" \
  -d '{
    "email": "user@example.com",
    "password": "SecurePass123!"
  }'
# Response: { "access_token": "...", "refresh_token": "...", "user": {...} }

# Get current user
curl http://localhost:8080/api/v1/auth/me \
  -H "Authorization: Bearer <access_token>"

Meetings

# List meetings
curl http://localhost:8080/api/v1/meetings \
  -H "Authorization: Bearer <token>"

# Create meeting
curl -X POST http://localhost:8080/api/v1/meetings \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Weekly Standup",
    "description": "Team sync meeting"
  }'

# Get meeting
curl http://localhost:8080/api/v1/meetings/<meeting_id> \
  -H "Authorization: Bearer <token>"

# Get transcript
curl http://localhost:8080/api/v1/meetings/<meeting_id>/transcript \
  -H "Authorization: Bearer <token>"

Real-Time Transcription WebSocket

// Connect to transcription stream
const ws = new WebSocket('ws://localhost:8080/ws/transcription/<meeting_id>');

ws.onopen = () => {
  console.log('Connected to transcription stream');
};

ws.onmessage = (event) => {
  const message = JSON.parse(event.data);

  switch (message.type) {
    case 'transcript':
      console.log(`[${message.speaker}]: ${message.text}`);
      break;
    case 'partial':
      console.log(`(typing): ${message.text}`);
      break;
    case 'speaker_change':
      console.log(`Speaker changed to: ${message.speaker}`);
      break;
  }
};

Bot Audio WebSocket

// For meeting bots to stream audio
const ws = new WebSocket('ws://localhost:8080/ws/audio/<meeting_id>?bot_id=<bot_id>');

// Send audio start message
ws.send(JSON.stringify({
  type: 'bot_audio_start',
  bot_id: 'bot-123',
  meeting_id: 'meeting-456',
  sample_rate: 16000,
  channels: 1,
  format: 's16le'
}));

// Stream raw PCM audio (s16le format)
ws.send(audioBuffer); // Binary data

// Send audio stop message
ws.send(JSON.stringify({
  type: 'bot_audio_stop',
  bot_id: 'bot-123',
  meeting_id: 'meeting-456'
}));

Organizations (Multi-Tenant)

# Create organization
curl -X POST http://localhost:8080/api/v1/organizations \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{"name": "Acme Corp", "slug": "acme"}'

# Invite member
curl -X POST http://localhost:8080/api/v1/organizations/<org_id>/members \
  -H "Authorization: Bearer <token>" \
  -d '{"email": "user@acme.com", "role": "editor"}'

# Get usage stats
curl http://localhost:8080/api/v1/organizations/<org_id>/usage \
  -H "Authorization: Bearer <token>"

Billing (Stripe Integration)

# Get billing portal URL
curl http://localhost:8080/api/v1/billing/portal \
  -H "Authorization: Bearer <token>"

# Create checkout session
curl -X POST http://localhost:8080/api/v1/billing/checkout \
  -H "Authorization: Bearer <token>" \
  -d '{"price_id": "price_xxx", "success_url": "...", "cancel_url": "..."}'

# Get current subscription
curl http://localhost:8080/api/v1/billing/subscription \
  -H "Authorization: Bearer <token>"

SSO/SAML

# Configure SSO provider
curl -X POST http://localhost:8080/api/v1/sso/config \
  -H "Authorization: Bearer <token>" \
  -d '{
    "provider": "okta",
    "entity_id": "https://your-app.okta.com/...",
    "sso_url": "https://your-app.okta.com/app/.../sso/saml",
    "certificate": "-----BEGIN CERTIFICATE-----..."
  }'

# Initiate SSO login
curl http://localhost:8080/api/v1/sso/login?org=acme
# Redirects to IdP

Webhooks

# Create webhook
curl -X POST http://localhost:8080/api/v1/webhooks \
  -H "Authorization: Bearer <token>" \
  -d '{
    "url": "https://your-server.com/webhook",
    "events": ["meeting.started", "meeting.ended", "transcript.completed"],
    "secret": "your-webhook-secret"
  }'

# List webhooks
curl http://localhost:8080/api/v1/webhooks \
  -H "Authorization: Bearer <token>"

Custom Vocabulary

# Add vocabulary term
curl -X POST http://localhost:8080/api/v1/vocabulary \
  -H "Authorization: Bearer <token>" \
  -d '{"term": "NexusScribe", "pronunciation": "NEX-us-scribe", "category": "product"}'

# Import vocabulary
curl -X POST http://localhost:8080/api/v1/vocabulary/import \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{"terms": [{"term": "API", "expansion": "Application Programming Interface"}]}'

Meeting Templates

# Create template
curl -X POST http://localhost:8080/api/v1/templates \
  -H "Authorization: Bearer <token>" \
  -d '{
    "name": "Weekly Standup",
    "default_title": "Team Standup - {{date}}",
    "default_description": "Weekly team sync",
    "default_participants": ["team@example.com"]
  }'

# Create meeting from template
curl -X POST http://localhost:8080/api/v1/meetings \
  -H "Authorization: Bearer <token>" \
  -d '{"template_id": "<template_id>"}'

Privacy & Compliance

# Request data export (GDPR)
curl -X POST http://localhost:8080/api/v1/privacy/export \
  -H "Authorization: Bearer <token>"

# Request data deletion
curl -X POST http://localhost:8080/api/v1/privacy/delete \
  -H "Authorization: Bearer <token>" \
  -d '{"confirm": true}'

# Update consent
curl -X PUT http://localhost:8080/api/v1/privacy/consent \
  -H "Authorization: Bearer <token>" \
  -d '{"marketing": false, "analytics": true}'

# Set Do Not Sell (CCPA)
curl -X PUT http://localhost:8080/api/v1/privacy/ccpa \
  -H "Authorization: Bearer <token>" \
  -d '{"do_not_sell": true}'

Full-Text Search

# Search transcripts
curl "http://localhost:8080/api/v1/search?q=action+items&type=transcript" \
  -H "Authorization: Bearer <token>"

# Search with filters
curl "http://localhost:8080/api/v1/search?q=budget&from=2024-01-01&to=2024-12-31" \
  -H "Authorization: Bearer <token>"

---

Crate Documentation

NexusScribe is organized as a Rust workspace with 12 specialized crates:

Crate	Description	Docs
nexus-scribe-core	Core types, configuration, error handling	README
nexus-scribe-utils	Utility functions, validators, sanitizers	README
nexus-scribe-db	Aegis-DB client (4 paradigms)	README
nexus-scribe-auth	JWT, Argon2, TOTP MFA, RBAC	README
nexus-scribe-api	REST/WebSocket type definitions	README
nexus-scribe-web	Axum HTTP server	README
nexus-scribe-audio	Audio capture, VAD, resampling	README
nexus-scribe-transcription	Whisper integration	README
nexus-scribe-speaker	Speaker diarization	README
nexus-scribe-collaboration	Real-time OT engine	README
nexus-scribe-hailo	Hailo NPU integration	README
nexus-scribe-models	ML model management	README

---

Performance

Benchmarks

Configuration	Latency	Concurrent Streams	Memory
Raspberry Pi 5 + Hailo 10-H	< 200ms	15	12GB
x86_64 + CUDA (RTX 3080)	< 100ms	50	8GB
x86_64 CPU (32 cores)	< 500ms	10	16GB

Word Error Rate (WER)

Audio Quality	Model	WER
Clear (studio)	large-v3	2-3%
Good (conference room)	large-v3	4-6%
Noisy (open office)	large-v3	8-12%
Phone quality	base	10-15%

Optimization Tips

1. Model Selection: Use base for real-time with acceptable accuracy, large-v3 for post-processing
2. Audio Quality: Ensure 16kHz mono input, use noise suppression
3. Batching: Enable batching for multiple concurrent streams
4. Memory: Use quantized models on memory-constrained devices

---

Deployment

Production Checklist

• Set strong JWT_SECRET (32+ characters)
• Enable HTTPS with valid certificates
• Configure firewall rules
• Set up log rotation
• Enable database backups
• Configure monitoring (Prometheus/Grafana)
• Set resource limits
• Configure PM2 startup on boot

PM2 Deployment (Recommended)

PM2 is the recommended process manager for production:

# Deploy all services
pm2 start ecosystem.config.js --env production

# Enable startup on boot
pm2 startup
pm2 save

# Zero-downtime reload
pm2 reload all

# View real-time monitoring
pm2 monit

# View logs
pm2 logs

PM2 Ecosystem Configuration

The ecosystem.config.js file manages all services:

Service	Name	Port	Description
Aegis-DB	aegis-db	7001	Multi-paradigm database
Backend	nexus-backend	8080	Rust/Axum API server
Frontend	nexus-web	3000	Next.js web application
Mobile Dev	nexus-mobile-dev	19000	Expo dev server (disabled by default)

Database Management

# Initialize database (first time or full reinit)
./nexus-ctl db-init

# Apply schema only (preserves data)
./nexus-ctl db-schema

# Start in cluster mode (multi-node)
./nexus-ctl db-cluster

# View database status
curl http://127.0.0.1:7001/health

Systemd Service (Alternative)

# /etc/systemd/system/nexus-scribe.service
[Unit]
Description=NexusScribe Transcription Server
After=network.target aegis-db.service

[Service]
Type=simple
User=nexus
WorkingDirectory=/opt/NexusScribe
Environment=RUST_LOG=info
Environment=WHISPER_MODEL_PATH=/opt/NexusScribe/models/whisper/ggml-base.bin
ExecStart=/opt/NexusScribe/target/release/nexus-scribe
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Nginx Reverse Proxy

upstream nexus_scribe {
    server 127.0.0.1:8080;
}

server {
    listen 443 ssl http2;
    server_name transcribe.example.com;

    ssl_certificate /etc/letsencrypt/live/transcribe.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/transcribe.example.com/privkey.pem;

    location / {
        proxy_pass http://nexus_scribe;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

---

Mobile App

Setup

cd mobile
npm install
npm start           # Start Expo dev server

Scan the QR code with Expo Go (iOS/Android) to run on your device.

Features

Feature	Description
Dashboard	Quick access to recording, meetings, external transcription, AI Studio
Recording	Record meetings with real-time audio level visualization
Studio	Waveform playback with AI tools (edit for clarity, remove fillers, add chapters)
External Meetings	Connect transcription bots to Zoom, Teams, or Google Meet
Offline Mode	Queue actions when offline, sync automatically when connected
Share/Export	Export transcripts as TXT, JSON, PDF, or DOCX

Testing

npm test            # Run 78 unit tests
npx tsc --noEmit    # TypeScript check

Project Structure

mobile/
├── src/
│   ├── screens/          # 10 screens (Login, Dashboard, Studio, etc.)
│   ├── components/       # Reusable UI components
│   ├── services/         # API client, audio, websocket, notifications
│   ├── store/            # Zustand state management
│   ├── hooks/            # Custom React hooks
│   ├── theme/            # Colors, typography, spacing
│   └── types/            # TypeScript type definitions
├── assets/               # App icons and splash screen
└── __tests__/            # Unit tests

---

Development

Build Commands

# Debug build
make build-dev

# Release build
make build

# Run tests
make test

# Run linter
make lint

# Format code
make fmt

# Check without building
make check

Testing

# All tests
cargo test --workspace

# Specific crate
cargo test -p nexus-scribe-auth

# Specific test
cargo test -p nexus-scribe-auth test_password_hash

# With output
cargo test -- --nocapture

Code Style

• Follow Rust 2021 edition idioms
• Use rustfmt for formatting (run cargo fmt)
• Run clippy before committing (run cargo clippy)
• Document public APIs with rustdoc comments
• Write tests for all public functions

---

Contributing

We welcome contributions! Please see our Contributing Guidelines.

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Make your changes
4. Run tests (cargo test --workspace)
5. Run linter (cargo clippy)
6. Commit (git commit -m 'feat: add amazing feature')
7. Push (git push origin feature/amazing-feature)
8. Open a Pull Request

Commit Convention

type(scope): description

Types: feat, fix, docs, refactor, test, perf, chore

---

License

Licensed under the Business Source License 1.1 (LICENSE).

• Use Limitation: Production use limited to single organization with ≤50 users
• Change Date: January 26, 2030
• Change License: Apache License 2.0

After the Change Date, this software will be available under the Apache License 2.0.

For enterprise licensing (unlimited users, multiple organizations), contact sales@automatanexus.com.

---

Acknowledgments

• Whisper.cpp - High-performance Whisper inference
• whisper-rs - Rust bindings for whisper.cpp
• Hailo - NPU acceleration
• Aegis-DB - Multi-paradigm database
• Axum - Rust web framework
• LiveKit - Real-time video infrastructure

---

Support

• Documentation: docs.nexusscribe.dev
• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Email: support@automatanexus.com

---

Built with Rust by AutomataNexus Development Team
_{Version 1.0.0}