MessageAI - Implementation Plan

Executive Summary

Platform: iOS (Swift/SwiftUI)
Backend: Firebase (Firestore, Authentication, Storage, Cloud Functions)
AI Integration: GPT-4o, RAG Pipelines for conversation intelligence
Core Features: Secure messaging, voice/video calls, AI-powered translation & conversation analysis

App Overview

Core Messaging Features

User Authentication: Create accounts, login/logout via Firebase Auth
Friends System: Add friends by email address, manage friend list
Real-Time Messaging: Send/receive text messages with delivery and read receipts
Rich Media: Send images, voice messages with AI transcription
Message Interactions:
- React with full iOS emoji keyboard (like iMessage)
- Edit messages (within time window)
- Long-press for translation menu
- Start threaded conversations
Voice/Video Calls: Real-time calling with WebRTC
End-to-End Encryption: Secure message content

AI-Powered Features

AI Chat Assistant: Dedicated interface to query conversations
- "Summarize my conversation with John"
- "What action items do I have?"
- "Translate my last message to Spanish"
Voice-to-Text: AI transcription of voice messages
Translation:
- Long-press any message to translate
- Request translation via AI assistant
RAG Pipeline: Semantic search over conversation history
Conversation Intelligence:
- Extract action items
- Detect decisions
- Priority message flagging

Architecture Overview

Tech Stack

Frontend (iOS)

Language: Swift 5.9+
UI Framework: SwiftUI
Local Storage: SwiftData
Reactive Programming: Combine
Networking: URLSession + Firebase SDK
Real-Time: Firebase Firestore listeners + WebRTC

Backend (Firebase)

Authentication: Firebase Authentication
Database: Cloud Firestore
Storage: Firebase Storage (images, media)
Functions: Cloud Functions (Node.js/Python)
Messaging: Firebase Cloud Messaging (FCM)
Real-Time Calls: WebRTC with Firebase signaling

AI Infrastructure

LLM: OpenAI GPT-4o (via Cloud Functions)
Embeddings: OpenAI text-embedding-3-large
Vector Store: Firebase Firestore (with vector similarity search)
Voice-to-Text: Whisper API
Translation: GPT-4o with specialized prompts

System Architecture

┌─────────────────────────────────────────────────────────────┐
│                        iOS App (Swift)                       │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │   SwiftUI    │  │  SwiftData   │  │   Combine    │      │
│  │    Views     │  │ (Local Cache)│  │   Reactive   │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
│  ┌──────────────────────────────────────────────────┐      │
│  │              ViewModels (MVVM)                    │      │
│  └──────────────────────────────────────────────────┘      │
│  ┌──────────────────────────────────────────────────┐      │
│  │         Services & Repositories Layer             │      │
│  │  • AuthService    • MessageService                │      │
│  │  • CallService    • AIService                     │      │
│  │  • StorageService • EncryptionService             │      │
│  └──────────────────────────────────────────────────┘      │
└─────────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                      Firebase Backend                        │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │   Firestore  │  │     Auth     │  │   Storage    │      │
│  │  (Real-Time) │  │ (User Mgmt)  │  │   (Media)    │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
│  ┌──────────────────────────────────────────────────┐      │
│  │            Cloud Functions (Node.js)              │      │
│  │  • Push Notifications  • AI Proxy                 │      │
│  │  • WebRTC Signaling   • Message Processing        │      │
│  └──────────────────────────────────────────────────┘      │
└─────────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                    AI Infrastructure                         │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │   OpenAI     │  │   Firebase   │  │   Whisper    │      │
│  │   GPT-4o     │  │   Firestore  │  │     API      │      │
│  │ (Translation,│  │ Vector Store │  │(Voice-to-Text│      │
│  │  Assistant)  │  │ (RAG Search) │  │              │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
└─────────────────────────────────────────────────────────────┘

Data Models

Firestore Schema

/users/{userId}
  - email: string
  - displayName: string
  - photoURL: string
  - fcmToken: string
  - publicKey: string (for E2EE)
  - lastSeen: timestamp
  - status: "online" | "offline" | "away"
  - createdAt: timestamp

/friendships/{friendshipId}
  - userId1: string
  - userId2: string
  - status: "pending" | "accepted" | "blocked"
  - requestedBy: string
  - requestedAt: timestamp
  - acceptedAt: timestamp

/conversations/{conversationId}
  - participants: [userId1, userId2]
  - participantDetails: {userId: {name, photo}}
  - type: "direct" | "group"
  - lastMessage: {text, senderId, timestamp}
  - lastMessageTime: timestamp
  - unreadCount: {userId: number}
  - encryptionKeyId: string

/conversations/{conversationId}/messages/{messageId}
  - senderId: string
  - text: string (encrypted)
  - timestamp: timestamp
  - status: "sending" | "sent" | "delivered" | "read"
  - readBy: [{userId, readAt}]
  - deliveredTo: [{userId, deliveredAt}]
  - reactions: {userId: emoji}
  - mediaURL: string (optional)
  - mediaType: "image" | "voice" | "video"
  - voiceTranscript: string (optional)
  - editedAt: timestamp (optional)
  - originalText: string (optional, for edit history)
  - replyTo: messageId (optional, for threads)
  - translations: {languageCode: translatedText}

/conversations/{conversationId}/threads/{threadId}
  - parentMessageId: string
  - participants: [userId]
  - messageCount: number
  - lastMessageTime: timestamp

/calls/{callId}
  - callerId: string
  - recipientId: string
  - type: "audio" | "video"
  - status: "ringing" | "active" | "ended" | "missed"
  - startedAt: timestamp
  - endedAt: timestamp
  - duration: number
  - sdpOffer: string
  - sdpAnswer: string
  - iceCandidates: array

/embeddings/{messageId}
  - conversationId: string
  - messageId: string
  - userId: string (owner of the message)
  - embedding: array[1536] (stored directly in Firestore)
  - text: string (unencrypted snippet for search)
  - timestamp: timestamp

/actionItems/{itemId}
  - conversationId: string
  - messageId: string
  - task: string
  - assignedTo: userId
  - createdBy: userId
  - dueDate: timestamp
  - status: "pending" | "completed"
  - extractedAt: timestamp

/decisions/{decisionId}
  - conversationId: string
  - messageId: string
  - decision: string
  - participants: [userId]
  - rationale: string
  - date: timestamp

iOS Project Structure

MessagingApp/
├── App/
│   ├── MessagingAppApp.swift
│   └── AppDelegate.swift
│
├── Models/
│   ├── User.swift
│   ├── Conversation.swift
│   ├── Message.swift
│   ├── Friendship.swift
│   ├── Call.swift
│   ├── ActionItem.swift
│   └── AIContext.swift
│
├── ViewModels/
│   ├── Authentication/
│   │   ├── LoginViewModel.swift
│   │   └── SignUpViewModel.swift
│   ├── Friends/
│   │   └── FriendsListViewModel.swift
│   ├── Conversations/
│   │   ├── ConversationListViewModel.swift
│   │   └── ChatViewModel.swift
│   ├── Calls/
│   │   └── CallViewModel.swift
│   └── AI/
│       ├── AIAssistantViewModel.swift
│       └── TranslationViewModel.swift
│
├── Views/
│   ├── Authentication/
│   │   ├── LoginView.swift
│   │   ├── SignUpView.swift
│   │   └── ProfileSetupView.swift
│   ├── Friends/
│   │   ├── FriendsListView.swift
│   │   ├── AddFriendView.swift
│   │   └── FriendRequestsView.swift
│   ├── Conversations/
│   │   ├── ConversationListView.swift
│   │   ├── ChatView.swift
│   │   ├── MessageRow.swift
│   │   ├── MessageInputBar.swift
│   │   ├── EmojiReactionPicker.swift
│   │   ├── TranslationMenuView.swift
│   │   └── ThreadView.swift
│   ├── Calls/
│   │   ├── IncomingCallView.swift
│   │   ├── ActiveCallView.swift
│   │   └── CallHistoryView.swift
│   ├── AI/
│   │   ├── AIAssistantView.swift
│   │   ├── AIConversationView.swift
│   │   └── ActionItemsView.swift
│   └── Shared/
│       ├── ImagePickerView.swift
│       ├── VoiceRecorderView.swift
│       └── LoadingView.swift
│
├── Services/
│   ├── Authentication/
│   │   └── AuthService.swift
│   ├── Friends/
│   │   └── FriendshipService.swift
│   ├── Messaging/
│   │   ├── MessageService.swift
│   │   ├── ConversationService.swift
│   │   └── RealtimeListenerService.swift
│   ├── Media/
│   │   ├── ImageService.swift
│   │   ├── VoiceRecordingService.swift
│   │   └── StorageService.swift
│   ├── Calls/
│   │   ├── CallService.swift
│   │   ├── WebRTCService.swift
│   │   └── SignalingService.swift
│   ├── AI/
│   │   ├── AIService.swift
│   │   ├── TranslationService.swift
│   │   ├── VoiceToTextService.swift
│   │   ├── RAGService.swift
│   │   └── EmbeddingService.swift
│   ├── Security/
│   │   ├── EncryptionService.swift
│   │   └── KeychainService.swift
│   ├── LocalStorage/
│   │   └── LocalStorageService.swift
│   └── Notifications/
│       └── PushNotificationService.swift
│
├── Utilities/
│   ├── NetworkMonitor.swift
│   ├── Constants.swift
│   ├── Extensions/
│   │   ├── Date+Extensions.swift
│   │   ├── String+Extensions.swift
│   │   └── View+Extensions.swift
│   └── Helpers/
│       ├── AudioManager.swift
│       └── HapticManager.swift
│
├── Resources/
│   ├── Assets.xcassets
│   ├── GoogleService-Info.plist
│   └── Info.plist
│
└── Tests/
    ├── UnitTests/
    └── UITests/

Security Architecture

End-to-End Encryption Flow

1. Key Generation (per conversation)
   - Each conversation gets unique AES-256 key
   - Keys stored in device Keychain
   - Public key exchange via Firestore

2. Message Encryption (Client-Side)
   - Encrypt message text with AES-256-GCM
   - Store encrypted text in Firestore
   - Metadata (timestamps, status) unencrypted

3. AI Processing Consideration
   - For AI features (translation, RAG), temporarily decrypt client-side
   - Send to Cloud Function with user consent
   - Never store unencrypted content on server
   - Option to disable AI for privacy-sensitive conversations

4. Media Encryption
   - Encrypt images/voice before upload
   - Store encryption key in message metadata
   - Decrypt on recipient device

AI Features Architecture

RAG Pipeline for Conversation Search

┌─────────────────────────────────────────────────────────────┐
│                     User Query                               │
│              "What did Sarah say about the project?"         │
└─────────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                  Query Embedding                             │
│           OpenAI Embeddings API (1536 dims)                  │
└─────────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                Vector Similarity Search                      │
│      Firestore: Top 10 relevant messages by cosine           │
└─────────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                  Context Assembly                            │
│   Retrieve full messages + metadata from Firestore          │
└─────────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                   LLM Generation                             │
│   GPT-4o: Answer question with retrieved context            │
└─────────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                 Stream Response to User                      │
└─────────────────────────────────────────────────────────────┘

AI Assistant Commands

// User Interface Commands
"Summarize my last 50 messages with John"
"What action items do I have?"
"Translate my last message to Spanish"
"Find all messages about the launch date"
"What did we decide about the database?"
"Show me priority messages from this week"
"Extract all decisions from this conversation"

Translation Feature

Long-Press Menu:
┌─────────────────────────┐
│ Translate to Spanish    │
│ Translate to French     │
│ Translate to German     │
│ Translate to Chinese    │
│ Translate to Japanese   │
│ More Languages...       │
└─────────────────────────┘

Implementation:
1. Detect long-press gesture
2. Show translation menu
3. Send message text + target language to Cloud Function
4. GPT-4o translates with context awareness
5. Cache translation in message document
6. Display translated text in overlay

Task List

Phase 1: Project Setup & Authentication (Days 1-2)

1.1 Project Initialization

1.2 Firebase Backend Setup

1.3 User Authentication

Phase 2: Friends System (Days 3-4)

2.1 Friend Management

2.2 Friends UI

Phase 3: Core Messaging (Days 5-7)

3.1 Conversation Management

3.2 Conversation List UI

3.3 Chat Interface

3.4 Read Receipts & Delivery Status

Phase 4: Rich Messaging Features (Days 8-10)

4.1 Emoji Reactions

4.2 Message Editing

4.3 Image Sharing

4.4 Voice Messages with AI Transcription

4.5 Message Threading

Phase 4.5: Group Chat (Days 10.5-11.5)

4.5.1 Group Chat Data & Services

4.5.2 Create Group UI

4.5.3 Group Info & Management

4.5.4 Update Chat Interface for Groups

4.5.5 Group-Specific Features

4.5.6 Firestore Rules for Groups

Update security rules
- Only members can read group messages
- Only members can send messages
- Only admins can modify group
- Anyone can leave group

Phase 5: Voice/Video Calling (Days 12-14)

Note: Voice/Video calling starts with 1-on-1 calls. Group calling can be added later.

5.1 WebRTC Setup

5.2 Call Signaling

5.3 Call UI

5.4 Call History (Optional)

Phase 6: Security & Encryption (Days 15-16)

6.1 End-to-End Encryption

6.2 Security Enhancements

Phase 7: AI Features - Translation (Days 17-18) ✅ COMPLETE

7.1 Translation Service

7.2 Translation UI

Phase 8: AI Features - RAG & Conversation Intelligence (Days 19-22) ✅ COMPLETE

8.1 Embedding Pipeline

8.2 RAG Search Service

8.3 Action Item Extraction

8.4 Decision Tracking

8.5 Priority Message Detection

Create Cloud Function classifyPriority
- Real-time or batch processing
- Check for: mentions, questions, deadlines
- Return priority score + reason
- Update message metadata
Update ConversationListView to show priority indicator
- Red badge for priority conversations
- Filter/sort by priority
Create "Priority Messages" inbox view (integrated)

Phase 9: AI Chat Assistant (Days 23-25)

9.1 AI Assistant Backend

9.2 AI Assistant UI

9.3 Context Management

Phase 9.5: Encryption Toggle (Day 26) ✅ COMPLETE

9.5.1 UX & Settings

Add encryption toggle to chat options menu
Add lock/unlock control in message composer
Display persistent conversation mode indicator (banner or status chip)
Warn users that AI features pause when encryption mode is enabled

9.5.2 Conversation State & Key Exchange

Store encryptionMode flag in conversation documents and local cache
Confirm all participants support encryption before enabling
Generate or rotate conversation keys when the mode switches

9.5.3 Messaging Pipeline

Branch send pipeline based on encryption mode selection
Encrypt messages, attachments, and transcripts client-side when locked
Persist each user's last mode selection per conversation

9.5.4 Backend & AI Integration

Gate Cloud Functions and AI jobs on encryptionMode
Skip embedding/indexing for encrypted conversations
Capture consent logs for AI-enabled conversations

9.5.5 Security & Telemetry

Extend key management services for toggle, revocation, and device sync
Ensure mode toggle events are auditable
Document privacy guarantees for each mode

9.5.6 Testing & Rollout

Add unit/UI coverage for toggling scenarios and mixed-mode history
Validate encrypted mode disables AI features end-to-end
Stage rollout with analytics to monitor adoption and regressions

Phase 11: Offline Support & Sync (Day 27) ✅ COMPLETE

11.1 Offline Messaging

11.2 Data Synchronization

Phase 12: Polish & UX Improvements (Days 28-29) ✅ PARTIAL COMPLETE

12.1 UI/UX Polish

12.2 Accessibility

12.3 Error Handling

12.4 Performance Optimization

Phase 13: Testing (Days 30-31)

13.1 Unit Tests

13.2 UI Tests

13.3 Integration Testing

13.4 Security Testing

Phase 14: Deployment & Documentation (Days 32-33)

14.1 App Store Preparation

14.2 Beta Testing

14.3 Documentation

14.4 Final Checks

Phase 10: Push Notifications (Optional - Day 34+)

⚠️ Note: This phase requires a paid Apple Developer Account ($99/year) to configure APNs certificates and test push notifications on physical devices.

10.1 Push Notification Setup

10.2 Notification Triggers

10.3 Notification Handling

Estimated Timeline

Total Duration: ~6-8 weeks (assuming full-time work)

Phase	Days	Description
1	2	Project setup & authentication
2	2	Friends system
3	3	Core messaging
4	3	Rich messaging features
4.5	1	Group chat
5	3	Voice/video calling
6	2	Security & encryption
7	2	Translation AI
8	4	RAG & conversation intelligence
9	3	AI chat assistant
9.5	1	Encryption toggle
11	1	Offline support
12	2	Polish & UX
13	2	Testing
14	2	Deployment & docs
10	1+	Push notifications (optional, requires paid Apple Dev account)
Total	34 days	(35+ with push notifications)

Note: Timeline can be adjusted based on priorities. MVP (Phases 1-4.5) can be completed in 8-12 days and includes full messaging with groups.

Key Dependencies & Tools

iOS Development

Xcode 15+
Swift 5.9+
iOS 17.0+ target
CocoaPods or Swift Package Manager

Firebase Services

Firebase Authentication
Cloud Firestore
Firebase Storage
Cloud Functions for Firebase
Firebase Cloud Messaging
Firebase Extensions (optional)

AI & ML Services

OpenAI API (GPT-4o, Whisper, Embeddings)
Firebase Firestore (vector database with similarity search)

WebRTC

WebRTC framework for iOS
STUN/TURN servers (Twilio, Xirsys, or self-hosted)

Additional Tools

Git for version control
Postman for API testing
Firebase Emulator Suite for local testing
TestFlight for beta distribution

AI Integration Details

OpenAI GPT-4o Use Cases

Translation: Context-aware message translation
Summarization: Conversation thread summaries
Action Items: Extract tasks from conversations
Decision Tracking: Identify and log decisions
Priority Detection: Classify message urgency
AI Assistant: Natural language queries about conversations
Function Calling: Route assistant commands to appropriate functions

RAG Pipeline Components

Embedding Generation: Convert messages to vectors (text-embedding-3-large)
Vector Storage: Firestore /embeddings collection with indexed metadata
Similarity Search: Find relevant messages by cosine similarity in Firestore
Context Assembly: Retrieve full messages with metadata
LLM Generation: Answer questions using retrieved context
Caching: Store embeddings and responses for efficiency

Privacy Considerations

Opt-in for AI features (user consent)
Clear disclosure when messages sent to AI
Option to disable AI per conversation
No permanent storage of unencrypted content on server
Client-side encryption before AI processing (where possible)

Success Metrics

Technical Metrics

Message delivery within 500ms (online users)
99.9% message delivery reliability
Zero data loss during offline scenarios
AI response time < 3 seconds
Call connection time < 2 seconds
App cold start < 2 seconds

User Experience Metrics

Users can catch up on conversations 80% faster with AI summaries
100% action item capture rate
Information retrieval 3x faster with semantic search
Translation accuracy > 95%
Call quality rating > 4/5 stars

Risk Management

Technical Risks

Risk	Mitigation
WebRTC complexity	Use proven library, allocate extra time
E2E encryption performance	Implement incrementally, profile early
AI API costs	Implement caching, rate limiting, user quotas
Firestore at scale	Design efficient queries, use indexes
Offline sync conflicts	Server-wins strategy, clear user communication

Product Risks

Risk	Mitigation
Feature scope creep	Strict MVP definition, prioritize P0 features
AI accuracy issues	Iterative prompt engineering, user feedback
Privacy concerns	Clear communication, opt-in, privacy policy
User adoption	Beta testing, gather feedback early

Next Steps

Review this plan - Adjust timeline and priorities based on constraints
Set up development environment - Install Xcode, Firebase, get API keys
Create Firebase project - Set up backend infrastructure
Start with Phase 1 - Build authentication foundation
Iterate rapidly - Build MVP first, then add AI features
Test early and often - Real devices, real users, real feedback
Document as you go - Save time during final documentation phase

Notes

This plan is comprehensive and can be adjusted based on your specific needs
Focus on MVP first (Phases 1-3) to get a working messaging app
AI features (Phases 7-9) can be added incrementally
Consider parallel development where possible (e.g., UI while backend is being built)
Regular testing throughout development is crucial for quality
Don't underestimate time needed for polish and bug fixes

Document Status: Ready for Implementation
Last Updated: October 23, 2025
Version: 1.2 - Using Firebase Firestore for vector database (updated from Pinecone)

FilesExpand file tree

APP_PLAN.md

Latest commit

History