Skip to content

MomenMushtaha/MessageAI

BranchesTags

Repository files navigation

MessageAI

AI-Powered Messaging Platform for Remote Teams

A production-ready iOS messaging application built with SwiftUI and Supabase, featuring integrated AI assistants to help remote professionals manage communication overload, track decisions, and maintain team alignment across time zones.

🎯 Overview

MessageAI combines enterprise-grade messaging infrastructure with intelligent AI assistants designed specifically for distributed teams. Built on a modern SwiftUI + Supabase architecture, it delivers WhatsApp-quality real-time messaging enhanced with contextual AI features that surface insights without leaving your conversations.

Target Users: Engineering managers, product leads, and remote team coordinators managing high-volume async communication across time zones.

Core Value: Transforms message overload into actionable intelligence through embedded AI agents.

✨ Key Features

🤖 AI Assistants

MoChain - Remote Team Assistant

Your intelligent work companion that lives inside your conversations:

  • 📊 Thread Summarization - Digest 50+ message threads in seconds
  • 🎯 Action Item Extraction - Auto-detect commitments and owners ("I'll do X")
  • ✅ Decision Tracking - Surface agreed-upon decisions from discussions
  • 🚨 Priority Detection - Flag urgent messages automatically
  • 🔍 Smart Semantic Search - Find information by meaning, not keywords
  • 💬 Direct Chat - Ask MoChain questions about your team coordination
  • 🧠 Multi-Step Workflows - Execute complex tasks autonomously

MushLifts - Personal Wellness Assistant

Dedicated fitness and wellness AI for busy remote professionals:

  • 💪 Workout Planning - Personalized training programs
  • 🥗 Nutrition Guidance - Meal planning and dietary advice
  • 🏃 Fitness Tracking - Progress monitoring and motivation
  • ⚖️ Work-Life Balance - Wellness tips for remote workers

💬 Core Messaging

Real-Time Communication

  • Instant message delivery via Supabase Realtime
  • WhatsApp-style message status (sent ✓, delivered ✓✓, read 🔵)
  • Typing indicators and presence system
  • Group chats with participant management
  • Direct one-on-one conversations

Rich Media Support

  • 📸 Image sharing via S3/CloudFront CDN
  • 🎥 Video messages with playback controls
  • 🎙️ Voice messages with waveform visualization
  • 🖼️ Group avatars and profile pictures

Smart Features

  • 📝 Message pinning for important updates
  • 🗑️ Delete for Me vs Delete for Everyone
  • 🧹 Clear chat history (personal view only)
  • 🎯 Lazy conversation creation (DB created on first message)
  • 💾 Offline support with auto-sync
  • ⚡ Optimistic UI for instant feedback

🎨 User Experience

Beautiful Interface

  • WhatsApp-inspired gradients and animations
  • Custom message bubble shapes with tail pointers
  • Glass morphism effects on AI action toolbar
  • Smooth spring-based transitions (60fps)
  • Professional design token system (Colors, Typography, Shadows, Spacing)

Smart Notifications

  • In-app banner notifications (no developer account needed)
  • APNs push notification support
  • Conversation-aware notification routing

Helpful Guidance

  • Character counter (4096 limit)
  • Empty states with onboarding hints
  • User-friendly error messages
  • AI configuration banner for setup

⚡ Performance & Architecture

Dual-Database Design

  • Global DB for shared conversations and messages
  • Per-user privacy layer for personal deletions
  • Server-side message filtering for optimal privacy
  • ISO8601 timestamp standardization

Optimization

  • NSCache reduces Supabase reads by ~70%
  • Lazy loading with pagination (100 messages at a time)
  • Smart UI updates (only re-render on actual changes)
  • 15MB cache limit with auto-cleanup
  • Optimized queries with delta polling
  • <200ms latency with optimistic UI

Observability

  • Performance monitoring dashboard
  • Sync service monitoring
  • Database operation tracing
  • State inspector for debugging
  • Test data seeding for development

🛠 Technology Stack

Frontend

  • SwiftUI - Declarative UI framework
  • SwiftData - Modern local persistence
  • iOS 17+ - Latest platform features
  • CoreML - On-device AI inference
  • AVFoundation - Audio/video playback

Backend

  • Supabase Postgres - Realtime JSON document store with JSONB
  • Supabase Auth - Email/password authentication
  • Supabase Edge Functions - Serverless API endpoints (Deno runtime)
  • AWS S3 + CloudFront - Media storage and CDN
  • OpenAI GPT-4 - AI assistant capabilities

AI Infrastructure

  • On-device Apple Intelligence for translations
  • Server-side inference via Edge Functions
  • Multiple inference provider support (CoreML, Foundation Models, Server)

📋 Requirements

  • iOS: 17.0 or later
  • Xcode: 16.0 or later
  • Swift: 5.9+
  • Supabase: Project with Postgres database
  • Optional: AWS S3 bucket for media, OpenAI API key for AI features

🚀 Quick Start

Local Development Setup

For simulator and local testing, use the automated setup script:

# Clone the repository
git clone https://github.com/MomenMushtaha/MessageAI.git
cd message-ai

# Run Supabase setup (installs CLI, starts local instance, creates schema)
./scripts/setup-supabase.sh

# Start AI agent backend (optional - for MoChain/MushLifts)
./scripts/start-backend.sh

The setup script automatically:

  • Installs Supabase CLI (if needed)
  • Initializes local Supabase at http://127.0.0.1:54321
  • Creates realtime_documents table with RLS policies
  • Sets up authentication system

Physical Device Testing

To test on a physical iOS device connected to your local Supabase:

  1. Find your Mac's local IP address:

    ifconfig | grep "inet " | grep -v 127.0.0.1

  2. Update Info.plist with your local IP:

    <key>SUPABASE_URL</key>
<string>http://192.168.x.x:54321</string>

  3. Enable Local Network permission:

    • iOS Settings → Privacy & Security → Local Network → MessageAI ✓

Production Deployment

1. Supabase Cloud Setup

Create a production Supabase project:

# Create project at https://supabase.com/dashboard
# Then configure your project:

# Create realtime documents table
psql $SUPABASE_DB_URL -c "
CREATE TABLE IF NOT EXISTS realtime_documents (
  path TEXT PRIMARY KEY,
  data JSONB
);

-- Enable RLS
ALTER TABLE realtime_documents ENABLE ROW LEVEL SECURITY;

-- Allow authenticated users full access
CREATE POLICY \"Allow authenticated access\"
  ON realtime_documents
  FOR ALL
  USING (auth.role() = 'authenticated')
  WITH CHECK (auth.role() = 'authenticated');
"

2. Configure App Credentials

Copy the example config and fill in your credentials:

cp Config.example.xcconfig Config.xcconfig

Edit Config.xcconfig:

SUPABASE_URL = https://your-project.supabase.co
SUPABASE_ANON_KEY = your-anon-key-here
SUPABASE_FUNCTIONS_URL = https://your-project.functions.supabase.co
S3_UPLOAD_ENDPOINT = $(SUPABASE_FUNCTIONS_URL)/generate-upload-url
MOCHAIN_CHAT_ENDPOINT = $(SUPABASE_FUNCTIONS_URL)/mochain
MUSHLIFTS_CHAT_ENDPOINT = $(SUPABASE_FUNCTIONS_URL)/mushlifts

3. Deploy Edge Functions

Deploy the AI and media handling functions:

cd supabase/functions

# Deploy all functions
supabase functions deploy mochain
supabase functions deploy mushlifts
supabase functions deploy generate-upload-url
supabase functions deploy send-notification
supabase functions deploy aiSummarize
supabase functions deploy summarizeText

# Set environment variables
supabase secrets set OPENAI_API_KEY=sk-your-key-here
supabase secrets set AWS_BUCKET=your-bucket-name
supabase secrets set AWS_REGION=us-east-1
supabase secrets set CLOUDFRONT_DOMAIN=d123.cloudfront.net

4. AWS S3 + CloudFront Setup

For media storage:

  1. Create S3 Bucket

    • Enable private ACLs and block public access
    • Note the bucket name and region

  2. Create CloudFront Distribution (optional but recommended)

    • Point to your S3 bucket
    • Note the distribution domain (e.g., d123.cloudfront.net)

  3. Configure IAM Credentials

    • Create IAM user with S3 write permissions
    • Generate access keys
    • Store in Edge Function environment variables

  4. Update Edge Function Config

    supabase secrets set AWS_ACCESS_KEY_ID=your-access-key
supabase secrets set AWS_SECRET_ACCESS_KEY=your-secret-key

5. APNs Push Notifications

For production push notifications:

  1. Generate APNs key in Apple Developer Console
  2. Upload key to Supabase (or configure in Edge Function)
  3. Device tokens automatically register via app's built-in flow
  4. Stored at users/{userId}/pushTokens/{token} in realtime_documents

📁 Project Structure

message-ai/
├── MessageAI/                          # Main iOS app directory
│   ├── MessageAIApp.swift              # App entry point, Supabase + SwiftData init
│   ├── MainAppView.swift               # Root view with auth state management
│   │
│   ├── Models/                         # Data models
│   │   ├── User.swift                  # User model with online presence
│   │   ├── Conversation.swift          # Conversation (direct/group)
│   │   ├── LocalMessage.swift          # SwiftData message persistence
│   │   ├── LocalConversation.swift     # SwiftData conversation cache
│   │   └── TypingStatus.swift          # Typing indicator state
│   │
│   ├── Views/                          # SwiftUI screens
│   │   ├── Auth/                       # Authentication screens
│   │   │   ├── LoginView.swift         # Email/password login
│   │   │   └── SignUpView.swift        # User registration
│   │   │
│   │   ├── Chat/                       # AI Assistant interfaces
│   │   │   ├── MoChainChatView.swift   # MoChain AI chat
│   │   │   └── MushLiftsChatView.swift # MushLifts wellness chat
│   │   │
│   │   ├── ChatList/                   # Conversation list screens
│   │   │   ├── ChatListView.swift      # Main conversations list
│   │   │   ├── ConversationRow.swift   # Conversation cell UI
│   │   │   ├── NewChatView.swift       # Start direct chat
│   │   │   ├── NewGroupView.swift      # Create group chat
│   │   │   ├── MoChainCard.swift       # MoChain entry point card
│   │   │   ├── MushLiftsCard.swift     # MushLifts entry point card
│   │   │   └── AIConfigBanner.swift    # AI setup prompt
│   │   │
│   │   ├── Conversation/               # Message detail screens
│   │   │   ├── ConversationDetailView.swift  # Message thread view
│   │   │   ├── GroupDetailsView.swift        # Group settings
│   │   │   ├── GroupInfoView.swift           # Group info sheet
│   │   │   └── OpenAISettingsView.swift      # Configure AI API keys
│   │   │
│   │   ├── Profile/                    # User profile screens
│   │   │   ├── UserProfileView.swift   # View user profile
│   │   │   └── EditProfileView.swift   # Edit own profile
│   │   │
│   │   ├── Settings/                   # App settings
│   │   │   └── InferenceSettingsView.swift   # AI inference config
│   │   │
│   │   ├── Debug/                      # Development tools
│   │   │   ├── ConversationDebugView.swift   # Message debugging
│   │   │   ├── UserDiagnosticView.swift      # User data inspection
│   │   │   ├── StateInspectorView.swift      # App state viewer
│   │   │   ├── DatabaseExplorerView.swift    # DB browser
│   │   │   └── TestDataDebugView.swift       # Test data management
│   │   │
│   │   └── Components/                 # Reusable view components
│   │       ├── AIInsightsView.swift    # AI results display
│   │       ├── MessageActionsSheet.swift     # Message context menu
│   │       ├── TypingIndicatorView.swift     # Typing animation
│   │       ├── ForwardMessageView.swift      # Message forwarding
│   │       └── ReactionPickerView.swift      # Message reactions
│   │
│   ├── Components/                     # Standalone UI components
│   │   ├── AIBottomBar.swift           # AI actions toolbar
│   │   ├── MessageBubbleShape.swift    # Custom bubble shape
│   │   ├── AIResultCard.swift          # AI insight card
│   │   ├── InAppNotificationBanner.swift     # Notification banner
│   │   ├── OfflineBanner.swift         # Offline indicator
│   │   ├── AudioMessageView.swift      # Voice message player
│   │   ├── VideoMessageView.swift      # Video player
│   │   ├── ImageMessageView.swift      # Image viewer
│   │   ├── VoiceRecordingView.swift    # Voice recorder UI
│   │   ├── PinnedMessagesView.swift    # Pinned messages sheet
│   │   ├── AnimatedTypingIndicator.swift     # Typing dots
│   │   ├── SelectableMessageText.swift       # Text selection
│   │   └── SkeletonView.swift          # Loading placeholders
│   │
│   ├── Services/                       # Business logic layer
│   │   ├── AuthService.swift           # Authentication
│   │   ├── AuthService+ServiceProtocol.swift
│   │   ├── ChatService.swift           # Core messaging orchestration
│   │   ├── ChatService+Conversations.swift   # Conversation CRUD
│   │   ├── ChatService+Messages.swift        # Message CRUD
│   │   ├── ChatService+Sending.swift         # Message sending logic
│   │   ├── ChatService+MessageActions.swift  # Delete, pin, etc.
│   │   ├── ChatService+Groups.swift          # Group management
│   │   ├── ChatService+Users.swift           # User lookups
│   │   ├── ChatService+Media.swift           # Media handling
│   │   ├── ChatService+Notifications.swift   # In-app notifications
│   │   ├── ChatService+ServiceProtocol.swift
│   │   ├── PresenceService.swift       # Online status + typing
│   │   ├── PresenceService+ServiceProtocol.swift
│   │   ├── SyncService.swift           # Offline sync coordination
│   │   ├── SyncService+ServiceProtocol.swift
│   │   ├── SyncMonitor.swift           # Sync health monitoring
│   │   ├── LocalStorageService.swift   # SwiftData persistence
│   │   ├── LocalStorageService+ServiceProtocol.swift
│   │   ├── MediaService.swift          # S3 media uploads
│   │   ├── AIService.swift             # AI features coordinator
│   │   ├── InferenceManager.swift      # Multi-provider AI inference
│   │   ├── CoreMLInferenceProvider.swift     # On-device inference
│   │   ├── FoundationModelsInferenceProvider.swift  # Apple Intelligence
│   │   ├── ServerInferenceProvider.swift     # Edge Function calls
│   │   ├── NotificationService.swift   # In-app notification manager
│   │   ├── PushNotificationService.swift     # APNs registration
│   │   ├── NetworkMonitor.swift        # Connectivity monitoring
│   │   ├── NetworkMonitor+ServiceProtocol.swift
│   │   ├── CacheManager.swift          # NSCache for users/convos
│   │   ├── RateLimiter.swift           # API rate limiting
│   │   ├── HealthCheckService.swift    # Service health monitoring
│   │   ├── ErrorRecoveryService.swift  # Auto-recovery logic
│   │   ├── PerformanceMonitor.swift    # Performance tracking
│   │   ├── LoggingService.swift        # Centralized logging
│   │   ├── DatabaseOperationTracer.swift     # DB query tracing
│   │   ├── AudioService.swift          # Audio recording/playback
│   │   ├── AppConfig.swift             # App configuration
│   │   ├── ServiceProtocol.swift       # Service lifecycle protocol
│   │   │
│   │   └── Supabase/                   # Supabase integration
│   │       ├── SupabaseAuthClient.swift      # Auth REST wrapper
│   │       ├── SupabaseRealtimeDatabase.swift # Realtime DB w/ polling
│   │       └── SupabaseConfiguration.swift   # Config validation
│   │
│   ├── Theme/                          # Design system tokens
│   │   ├── Colors.swift                # Color palette
│   │   ├── Typography.swift            # Font styles
│   │   ├── Shadows.swift               # Shadow presets
│   │   └── Spacing.swift               # Spacing constants
│   │
│   ├── Utilities/                      # Helper utilities
│   │   ├── ValidationUtility.swift     # Input validation
│   │   └── TestDataSeeder.swift        # Test data generation
│   │
│   └── AppDelegate.swift               # AppDelegate for APNs
│
├── supabase/                           # Backend infrastructure
│   └── functions/                      # Edge Functions (Deno)
│       ├── mochain/                    # MoChain AI agent
│       │   └── index.ts                # GPT-4 streaming chat
│       ├── mushlifts/                  # MushLifts AI agent
│       │   └── index.ts                # Fitness/wellness AI
│       ├── generate-upload-url/        # Media upload handler
│       │   └── index.ts                # S3 presigned URL generation
│       ├── send-notification/          # Push notifications
│       │   ├── index.ts                # APNs dispatcher
│       │   └── apns.ts                 # APNs client
│       ├── aiSummarize/                # Thread summarization
│       │   └── index.ts                # Conversation summarizer
│       └── summarizeText/              # Generic text summary
│           └── index.ts                # Text summarization
│
├── scripts/                            # Development scripts
│   ├── setup-supabase.sh               # Automated Supabase local setup
│   ├── start-backend.sh                # Start all edge functions locally
│   ├── start-ai-agents.sh              # Start AI agent servers
│   ├── stop-agents.sh                  # Stop AI agent servers
│   └── .env-setup.sh                   # Environment configuration
│
├── MessageAI.xcodeproj/                # Xcode project
├── Config.xcconfig                     # App configuration (git-ignored)
├── Config.example.xcconfig             # Configuration template
├── Info.plist                          # App info and permissions
├── Info.plist.example                  # Info.plist template
├── MessageAI.entitlements              # App capabilities
└── README.md                           # This file

🗄 Database Architecture

MessageAI uses a dual-database architecture for privacy and performance:

Global Database (Shared)

Stores all conversations and messages accessible to participants:

realtime_documents.data:
{
  "conversations": {
    "{conversationId}": {
      "type": "direct" | "group",
      "name": "Group Name",  // only for groups
      "avatarUrl": "https://...",  // optional group avatar
      "participantIds": ["user1", "user2", ...],
      "participantMap": { "user1": true, "user2": true },
      "createdAt": "2024-01-01T00:00:00Z",
      "lastMessageAt": "2024-01-01T12:34:56Z",
      "messages": {
        "{messageId}": {
          "senderId": "user1",
          "text": "Hello world",
          "createdAt": "2024-01-01T12:34:56Z",
          "type": "text" | "image" | "video" | "audio",
          "mediaUrl": "https://...",  // for media messages
          "deliveredTo": ["user2"],
          "readBy": ["user2"],
          "deletedForEveryone": true,  // if sender deleted for all
          "isPinned": true  // optional
        }
      }
    }
  },
  "users": {
    "{userId}": {
      "profile": {
        "displayName": "John Doe",
        "email": "john@example.com",
        "avatarUrl": "https://...",
        "createdAt": "2024-01-01T00:00:00Z"
      },
      "presence": {
        "isOnline": true,
        "lastSeen": "2024-01-01T12:34:56Z"
      },
      "typing": {
        "{conversationId}": {
          "isTyping": true,
          "timestamp": "2024-01-01T12:34:56Z"
        }
      }
    }
  }
}

Per-User Database (Private)

Personal deletions and preferences invisible to other users:

realtime_documents.data:
{
  "users": {
    "{userId}": {
      "deletedMessages": {
        "{conversationId}": {
          "{messageId}": true  // marked as deleted for this user
        }
      },
      "pushTokens": {
        "{token}": {
          "createdAt": "2024-01-01T00:00:00Z",
          "deviceName": "iPhone 15 Pro"
        }
      }
    }
  }
}

Key Design Patterns

  • Lazy Creation: Conversations created in DB only when first message is sent
  • Delete for Me: Adds messageId to users/{userId}/deletedMessages (private)
  • Delete for Everyone: Sets deletedForEveryone: true on message (global)
  • Clear Chat: Bulk adds all message IDs to user's deletedMessages
  • Server-Side Filtering: Messages filtered during fetch based on deletion lists
  • ISO8601 Timestamps: All dates use ISO8601 strings for consistency
  • Participant Map: Enables efficient WHERE participantMap ? :userId queries

🧪 Development Tools

Debug Views

Access via ChatListView menu:

  • State Inspector - View app-wide state in real-time
  • Database Explorer - Browse Supabase documents
  • Conversation Debug - Inspect message metadata
  • User Diagnostic - View user data and presence
  • Test Data Debug - Seed conversations for testing
  • Performance Monitor - Track app performance metrics

Test Data Seeding

Use TestDataSeeder to generate realistic test data:

// In TestDataDebugView
let seeder = TestDataSeeder(userId: currentUserId)
await seeder.seedConversations(count: 10)
await seeder.seedMessages(conversationId: id, count: 50)

Scripts

# Start local Supabase
./scripts/setup-supabase.sh

# Start edge functions locally (requires Deno)
./scripts/start-backend.sh

# Start AI agents
./scripts/start-ai-agents.sh

# Stop AI agents
./scripts/stop-agents.sh

🔧 Configuration Files

Config.xcconfig

Main app configuration (copy from Config.example.xcconfig):

SUPABASE_URL = https://your-project.supabase.co
SUPABASE_ANON_KEY = your-anon-key
SUPABASE_FUNCTIONS_URL = https://your-project.functions.supabase.co
S3_UPLOAD_ENDPOINT = $(SUPABASE_FUNCTIONS_URL)/generate-upload-url
MOCHAIN_CHAT_ENDPOINT = $(SUPABASE_FUNCTIONS_URL)/mochain
MUSHLIFTS_CHAT_ENDPOINT = $(SUPABASE_FUNCTIONS_URL)/mushlifts

Info.plist

Runtime configuration (copy from Info.plist.example):

<key>SUPABASE_URL</key>
<string>http://127.0.0.1:54321</string>  <!-- Local dev -->

<key>SUPABASE_ANON_KEY</key>
<string>your-local-anon-key</string>

<!-- AI Endpoints -->
<key>MOCHAIN_CHAT_ENDPOINT</key>
<string>http://127.0.0.1:54321/functions/v1/mochain</string>

<key>MUSHLIFTS_CHAT_ENDPOINT</key>
<string>http://127.0.0.1:54321/functions/v1/mushlifts</string>

<!-- Media -->
<key>S3_UPLOAD_ENDPOINT</key>
<string>http://127.0.0.1:54321/functions/v1/generate-upload-url</string>

📱 Features Deep Dive

AI Bottom Bar

Glassmorphic toolbar with 5 AI actions available in conversations:

  1. Summarize ✨ - Generate thread summary
  2. Actions ✅ - Extract action items with owners
  3. Decisions 🏆 - Find agreed-upon decisions
  4. Search 🔍 - Semantic search within conversation
  5. Translate 🌐 - On-device message translation

Implemented in AIBottomBar.swift

Message Status System

WhatsApp-style delivery receipts:

  • ✓ (Gray) - Sent to server
  • ✓✓ (Gray) - Delivered to recipient device
  • 🔵✓✓ (Blue) - Read by recipient

Managed by ChatService+Messages.swift with real-time updates via observers.

Presence System

Real-time online/offline status:

  • Heartbeat: 60-second intervals update users/{userId}/presence/isOnline
  • Last Seen: Displays "last seen X ago" when offline
  • Typing Indicators: Real-time typing status per conversation
  • Auto-Cleanup: Observer pattern ensures presence updates stop when view dismissed

Implemented in PresenceService.swift

Offline Support

Comprehensive offline-first architecture:

  1. SwiftData Persistence - All messages/conversations cached locally
  2. Optimistic UI - Messages appear instantly, sync in background
  3. Network Monitor - Detects connectivity changes, shows offline banner
  4. SyncService - Queues operations, auto-syncs when online
  5. Conflict Resolution - Server timestamp wins on conflicts

See SyncService.swift and NetworkMonitor.swift

🎨 Theme System

Centralized design tokens in MessageAI/Theme/:

// Colors.swift - Semantic color system
Color.brandBlue
Color.aiActionPurple
Color.textPrimary
Color.backgroundPrimary

// Typography.swift - Text styles
Font.headline
Font.bodyText
Font.caption

// Shadows.swift - Shadow presets
View().shadow(.card)
View().shadow(.elevated)

// Spacing.swift - Consistent spacing
Spacing.xs   // 4pt
Spacing.sm   // 8pt
Spacing.md   // 16pt
Spacing.lg   // 24pt

🚢 Deployment Checklist

Pre-Launch

  • Update Config.xcconfig with production Supabase credentials
  • Update Info.plist with production endpoints
  • Deploy all Edge Functions to Supabase
  • Set up AWS S3 bucket and CloudFront distribution
  • Configure APNs certificates and upload to Supabase
  • Set OPENAI_API_KEY secret in Supabase
  • Test AI features with production API keys
  • Enable Supabase RLS policies on all tables
  • Test on physical device with production backend
  • Remove debug views from production builds
  • Update app version and build number

Post-Launch

  • Monitor Supabase usage and costs
  • Monitor OpenAI API usage
  • Monitor S3/CloudFront bandwidth
  • Set up error tracking (Sentry, etc.)
  • Monitor APNs delivery rates
  • Review performance metrics
  • Gather user feedback on AI accuracy

🤝 Contributing

This is a reference implementation showcasing modern iOS + Supabase architecture with AI integration. Feel free to:

  • Fork and customize for your use case
  • Report issues or suggest improvements
  • Use as learning material for SwiftUI + Supabase
  • Extend with additional AI features

📄 License

See LICENSE file for details.

🙏 Acknowledgments

MessageAI - Intelligent messaging for distributed teams. Built with ❤️ using SwiftUI and Supabase.

About

ReviewLens AI is a secure, web-based platform designed to help businesses extract actionable insights from large volumes of customer reviews. The system ingests publicly available reviews from platforms such as Amazon or Google Maps and enables users to interact with the data through a guardrailed AI-powered Q&A interface.

Resources

Readme
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages