Expo MCP Server - React Native Mobile Development Platform

Overview

Create an MCP server that provides comprehensive integration with Expo CLI and Expo Development Build workflows, enabling AI assistants to manage React Native mobile app development, device management, build processes, deployment, and Expo-specific development workflows.

Use Cases

Primary Use Cases

Project Management: Initialize, configure, and manage Expo projects
Development Workflow: Start development servers, manage device connections
Build Management: Handle EAS builds, manage build configurations
Device & Simulator Management: Connect to physical devices and simulators
Deployment: Publish updates and manage app store submissions

Specific Scenarios

Cross-Platform Development: Managing iOS and Android builds simultaneously
Over-The-Air Updates: Publishing and rolling back app updates
Development Team Coordination: Managing shared development builds
App Store Deployment: Coordinating build processes for app store submissions
Testing & QA: Managing test builds and device provisioning

Ideal API Structure

Tools (MCP Functions)

Project Management

// Initialize new Expo project
create_project(name: string, template?: string, options?: ExpoCreateOptions): Promise<ProjectResult>

// Configure existing Expo project
configure_project(path?: string, config?: ExpoConfig): Promise<ConfigResult>

// Upgrade Expo SDK version
upgrade_sdk(target_version?: string, path?: string): Promise<UpgradeResult>

// Install and configure Expo plugins
install_plugin(plugin_name: string, config?: object, path?: string): Promise<PluginResult>

Development Server Management

// Start Expo development server
start_dev_server(options?: DevServerOptions): Promise<ServerResult>

// Stop development server
stop_dev_server(instance_id?: string): Promise<void>

// Get development server status
get_server_status(instance_id?: string): Promise<ServerStatus>

// Reload app on connected devices
reload_app(instance_id?: string): Promise<ReloadResult>

Device & Simulator Management

// List connected devices and simulators
list_devices(): Promise<Device[]>

// Connect to physical device
connect_device(device_id?: string): Promise<ConnectionResult>

// Launch iOS simulator
launch_ios_simulator(simulator_name?: string): Promise<SimulatorResult>

// Launch Android emulator
launch_android_emulator(emulator_name?: string): Promise<EmulatorResult>

// Install app on specific device
install_on_device(device_id: string, build_url?: string): Promise<InstallResult>

Build Management (EAS)

// Configure EAS build
configure_eas_build(platform?: 'ios'|'android'|'all'): Promise<EASConfigResult>

// Start EAS build
start_eas_build(platform?: 'ios'|'android'|'all', profile?: string): Promise<BuildResult>

// Get build status
get_build_status(build_id?: string): Promise<BuildStatus>

// Download build artifacts
download_build(build_id: string, path?: string): Promise<DownloadResult>

// List recent builds
list_builds(platform?: 'ios'|'android', limit?: number): Promise<Build[]>

Publishing & Updates

// Publish over-the-air update
publish_update(message?: string, channel?: string): Promise<PublishResult>

// List published updates
list_updates(channel?: string): Promise<Update[]>

// Roll back to previous update
rollback_update(update_id: string): Promise<RollbackResult>

// Manage update channels
manage_channels(action: 'create'|'delete'|'rename', channel_config: ChannelConfig): Promise<ChannelResult>

Asset & Resource Management

// Optimize app assets
optimize_assets(path?: string): Promise<OptimizationResult>

// Analyze bundle size
analyze_bundle_size(platform?: 'ios'|'android'): Promise<BundleAnalysis>

// Manage app icons and splash screens
manage_app_assets(assets: AssetConfig): Promise<AssetResult>

// Validate app configuration
validate_app_config(path?: string): Promise<ValidationResult>

Resources (MCP Data Sources)

Project Information

// Current project configuration
expo://project/config -> ExpoConfig

// Project dependencies and versions
expo://project/dependencies -> DependencyInfo[]

// EAS build configuration
expo://project/eas-config -> EASConfig

Development Status

// Development server status
expo://dev/server-status -> DevServerStatus

// Connected devices
expo://dev/devices -> ConnectedDevice[]

// Current app state on devices
expo://dev/app-status -> AppStatus[]

Build & Deployment

// Recent builds status
expo://builds/recent -> BuildInfo[]

// Published updates
expo://updates/published -> PublishedUpdate[]

// Asset optimization report
expo://assets/optimization -> AssetOptimizationReport

Prompts (MCP Templates)

// Common Expo development workflows
"setup-new-expo-project" -> Guide for creating and configuring new Expo project
"configure-eas-builds" -> Template for setting up EAS Build for iOS and Android
"setup-ota-updates" -> Configure over-the-air update workflow
"deploy-to-app-stores" -> Step-by-step app store deployment process
"troubleshoot-device-connection" -> Device connection troubleshooting guide
"optimize-app-performance" -> App performance optimization checklist

Implementation Details

Core Technologies

Language: TypeScript (for consistency with MCP ecosystem)
Expo CLI Integration: Direct integration with @expo/cli and related packages
EAS Integration: EAS CLI for build and submission management
Device Management: Integration with iOS Simulator and Android Emulator APIs
Metro Bundler: Integration with React Native's Metro bundler

Required Expo Integrations

import { Config } from '@expo/config';
import { getProjectConfigDescription } from '@expo/config-plugins';
import { AndroidConfig, IOSConfig } from '@expo/config-plugins';
import { Build, EASUpdate } from '@expo/eas-cli';

// Core integrations needed:
// - Expo CLI command execution and parsing
// - EAS Build API integration
// - Device discovery and connection management
// - Metro bundler lifecycle management
// - Asset optimization and bundle analysis

Configuration Options

interface ExpoMcpConfig {
  // Default project path
  project_root?: string;
  
  // EAS configuration
  eas_project_id?: string;
  eas_json_path?: string;
  
  // Development server options
  dev_server?: {
    port?: number;
    host?: string;
    clear_cache?: boolean;
  };
  
  // Device preferences
  preferred_ios_simulator?: string;
  preferred_android_emulator?: string;
  
  // Build preferences
  default_build_profile?: string;
  auto_submit_builds?: boolean;
}

Error Handling Requirements

Device Connection Issues: Clear diagnostics for device/simulator connection problems
Build Failures: Detailed build log analysis with actionable suggestions
Publishing Errors: OTA update publishing troubleshooting
Configuration Validation: Comprehensive app.json/app.config.js validation
Platform-Specific Issues: iOS/Android specific error handling

Example Usage Scenarios

New Project Setup

// AI assistant helping set up new Expo project
const project = await tools.create_project("my-awesome-app", "tabs", {
  typescript: true,
  navigation: true
});
await tools.configure_project("./my-awesome-app", {
  plugins: ["expo-camera", "expo-location"]
});

Development Workflow

// AI managing development workflow
const server = await tools.start_dev_server({ clear: true });
const devices = await tools.list_devices();
await tools.launch_ios_simulator("iPhone 15 Pro");
await tools.connect_device(devices[0].id);

Build and Deployment

// AI handling build and deployment
await tools.configure_eas_build("all");
const build = await tools.start_eas_build("ios", "production");
// Monitor build progress
const status = await tools.get_build_status(build.id);
if (status.status === "finished") {
  await tools.download_build(build.id, "./builds/");
}

Over-The-Air Updates

// AI managing OTA updates
const update = await tools.publish_update("Bug fixes and performance improvements", "production");
const updates = await tools.list_updates("production");
// If issues found, rollback
await tools.rollback_update(updates[1].id);

Testing Requirements

Unit Tests

Expo CLI command execution and output parsing
Device discovery and connection logic
Build configuration validation
Asset optimization algorithms
Update publishing and rollback logic

Integration Tests

Real device connection and app installation
End-to-end build process (iOS and Android)
OTA update publishing and delivery
Multi-platform development workflows
EAS Build integration scenarios

Mock Test Data

Sample Expo project configurations (app.json, eas.json)
Mock device and simulator information
Build status responses and error scenarios
Asset optimization reports
Update publishing responses

Documentation Requirements

User Documentation

Expo + MCP integration setup guide
Common mobile development workflows
Device and simulator setup instructions
Troubleshooting guide for build and deployment issues

Developer Documentation

API reference with TypeScript types
Custom workflow integration patterns
Platform-specific configuration examples
Performance optimization strategies

Success Criteria

Core Functionality ✅

Complete Expo project lifecycle management
Device and simulator connection management
EAS Build integration with status monitoring
Over-the-air update publishing and management

Advanced Features ✅

Multi-platform build coordination
Asset optimization and bundle analysis
Custom plugin integration and configuration
App store submission workflow automation

Quality Standards ✅

Comprehensive error handling with platform-specific guidance
Full TypeScript type coverage with Expo CLI integration
Integration test suite covering real device scenarios
Performance monitoring for development and build processes

Related Resources

Implementation Priority: HIGH

This server is crucial for React Native mobile development workflows and would fill a significant gap in mobile development tooling for AI assistants. It enables end-to-end mobile app development assistance, from project setup through app store deployment.