Skip to main content
Glama
Stefan-Nitu

MCP Xcode

by Stefan-Nitu
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Local

MCP Xcode Server

CI

A Model Context Protocol (MCP) server that enables AI assistants to build, test, run, and manage Apple platform projects through natural language interactions.

Version: 0.6.0

Related MCP server: xcode-mcp-server (drewster99)

Purpose

This MCP server bridges the gap between AI assistants and Apple's development ecosystem. It allows AI tools like Claude to directly execute Xcode and Swift Package Manager commands, enabling automated development workflows without manual intervention. The server is designed for token efficiency, providing concise output while maintaining comprehensive error reporting and debugging capabilities.

Why Use MCP Xcode Server?

Key Advantages

  • AI-Native Development: Enables AI assistants to build, test, and run iOS/macOS apps directly

  • Token Efficiency: Optimized output shows only essential information (errors, warnings, test results)

  • Smart Error Handling: Parses build errors and provides actionable suggestions

  • Visual Debugging: Capture simulator screenshots to verify UI changes

  • Automatic Simulator Management: Intelligently reuses running simulators to save time

  • Xcode Integration: Auto-syncs file operations with Xcode projects via hooks

  • Persistent Logging: All operations saved to ~/.mcp-xcode-server/logs/ for debugging

  • Multi-Platform: Supports iOS, macOS, tvOS, watchOS, and visionOS from a single interface

Use Cases

  • Automated Testing: AI can run your test suites and analyze failures

  • Build Verification: Quickly verify code changes compile across platforms

  • UI Development: Build and screenshot apps to verify visual changes

  • Dependency Management: Add, update, or remove Swift packages programmatically

  • Cross-Platform Development: Test the same code on multiple Apple platforms

  • CI/CD Integration: Automate build and test workflows through natural language

Limitations

What It Can't Do

  • No SwiftUI Previews: Xcode's live preview requires the full IDE

  • No Interactive UI Testing: Cannot simulate user interactions (taps, swipes)

  • No Physical Devices: Simulator-only for iOS/tvOS/watchOS/visionOS

  • No Debugging: No breakpoints, step-through debugging, or LLDB access

  • No Xcode UI Features: Project configuration, storyboard editing require Xcode

  • Platform Requirements: Requires macOS 14+, Xcode 16+, iOS 17+ simulators

When You Still Need Xcode

  • Designing UI with Interface Builder or SwiftUI previews

  • Debugging with breakpoints and variable inspection

  • Profiling with Instruments

  • Managing certificates and provisioning profiles

  • Testing on physical devices

  • Using Xcode-specific features (Playgrounds, AR tools, etc.)

Core Features

Build & Test Automation

  • Build and run Xcode projects/workspaces

  • Execute Swift Package Manager packages

  • Run XCTest and Swift Testing suites

  • Xcode projects: Support for custom build configurations (Debug, Release, Beta, Staging, etc.)

  • Swift packages: Standard SPM configurations (Debug/Release only - SPM limitation)

Simulator Management

  • List and boot simulators for any Apple platform

  • Capture screenshots for visual verification

  • Install/uninstall apps

  • Retrieve device logs with filtering

Error Intelligence

  • Compile Errors: Shows file, line, column with error message

  • Scheme Errors: Suggests using list_schemes tool

  • Code Signing: Identifies certificate and provisioning issues

  • Dependencies: Detects missing modules and version conflicts

File Sync Hooks

  • Automatically syncs file operations with Xcode projects

  • Intelligently assigns files to correct build phases (Sources, Resources, etc.)

  • Respects .no-xcode-sync opt-out files

  • Maintains proper group structure in Xcode

Installation

Prerequisites

  • macOS 14.0 or later

  • Xcode 16.0 or later

  • Node.js 18+

  • Xcode Command Line Tools

  • Simulators for target platforms

Quick Setup

# Install globally
npm install -g mcp-xcode-server

# Run interactive setup
mcp-xcode-server setup

The setup wizard will:

  • Configure the MCP server for Claude

  • Optionally set up Xcode sync hooks

  • Build necessary helper tools

Manual Configuration

Add to ~/.claude.json (global) or .claude/settings.json (project):

{
  "mcpServers": {
    "mcp-xcode-server": {
      "type": "stdio",
      "command": "mcp-xcode-server",
      "args": ["serve"],
      "env": {}
    }
  }
}

Available Tools

Building

  • build_xcode: Build Xcode projects/workspaces (supports custom configurations)

  • build_swift_package: Build Swift packages (Debug/Release only per SPM spec)

  • run_xcode: Build and run on simulator/macOS

  • run_swift_package: Execute Swift package executables

Testing

  • test_xcode: Run XCTest/Swift Testing suites

  • test_swift_package: Test Swift packages

  • Supports test filtering by class/method

Project Information

  • list_schemes: Get available Xcode schemes

  • get_project_info: Comprehensive project details

  • list_targets: List all build targets

  • get_build_settings: Get scheme configuration

Simulator Management

  • list_simulators: Show available devices

  • boot_simulator: Start a simulator

  • shutdown_simulator: Stop a simulator

  • view_simulator_screen: Capture screenshot

App Management

  • install_app: Install app on simulator

  • uninstall_app: Remove app by bundle ID

  • get_device_logs: Retrieve filtered device logs

Distribution

  • archive_project: Create .xcarchive

  • export_ipa: Export IPA from archive

Maintenance

  • clean_build: Clean build artifacts/DerivedData

  • manage_dependencies: Add/remove/update Swift packages

Platform Support

Platform

Simulator Required

Default Device

Min Version

iOS

Yes

iPhone 16 Pro

iOS 17+

macOS

No

Host machine

macOS 14+

tvOS

Yes

Apple TV

tvOS 17+

watchOS

Yes

Apple Watch Series 10

watchOS 10+

visionOS

Yes

Apple Vision Pro

visionOS 1.0+

Architecture

The server follows Clean/Hexagonal Architecture with SOLID principles:

Core Structure

src/
├── features/         # Feature-based vertical slices
│   ├── build/       # Build feature
│   │   ├── domain/  # Build domain objects
│   │   ├── use-cases/
│   │   ├── infrastructure/
│   │   ├── controllers/
│   │   └── factories/
│   ├── simulator/   # Simulator management
│   │   └── ...same structure...
│   └── app-management/ # App installation
│       └── ...same structure...
├── shared/          # Cross-feature shared code
│   ├── domain/      # Shared value objects
│   └── infrastructure/
├── application/     # Application layer ports
│   └── ports/       # Interface definitions
├── presentation/    # MCP presentation layer
│   ├── interfaces/  # MCP contracts
│   └── formatters/  # Output formatting
└── infrastructure/  # Shared infrastructure
    ├── repositories/
    └── services/

Key Design Principles

  • Clean Architecture: Dependency rule - inner layers know nothing about outer layers

  • Domain-Driven Design: Rich domain models with embedded validation

  • Type Safety: Full TypeScript with domain primitives and parse-don't-validate pattern

  • Security First: Path validation, command injection protection at boundaries

  • Error Recovery: Typed domain errors with graceful handling and helpful suggestions

Logging

All operations are logged to ~/.mcp-xcode-server/logs/:

  • Daily folders (e.g., 2025-01-27/)

  • 7-day automatic retention

  • Full xcodebuild/swift output preserved

  • Symlinks to latest logs for easy access

Development

# Build
npm run build

# Test
npm test              # All tests
npm run test:unit    # Unit tests only
npm run test:e2e     # End-to-end tests
npm run test:coverage # With coverage

# Development
npm run dev          # Build and run

Contributing

Contributions welcome! Please ensure:

  • Tests pass (npm test)

  • Code follows SOLID principles

  • New tools include tests

  • Documentation updated

License

MIT

Support

Available Tools

5 tools
boot_simulatorC

Boot a simulator

ParametersJSON Schema
NameRequiredDescriptionDefault
deviceIdYesDevice UDID or name of the simulator to boot

TDQS

C2.7/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Boot a simulator' implies a state-changing action (starting a simulator), but it doesn't describe what happens during boot (e.g., loading an OS, requiring specific permissions, potential timeouts, or effects on other simulators). This leaves significant gaps in understanding the tool's behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise with 'Boot a simulator', a single phrase that front-loads the core action. There is no wasted language or unnecessary elaboration, making it efficient and easy to parse, though this conciseness contributes to gaps in other dimensions.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (a state-changing operation with no annotations and no output schema), the description is incomplete. It lacks details on behavioral traits, output expectations, error handling, and integration with sibling tools. The high schema coverage helps with parameters, but overall, the description doesn't provide enough context for effective use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the 'deviceId' parameter documented as 'Device UDID or name of the simulator to boot'. The description adds no additional meaning beyond this, as it doesn't elaborate on parameter usage or constraints. With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Boot a simulator' clearly states the action (boot) and target (simulator), but it's vague about what 'boot' entails (e.g., starting a virtual device) and doesn't differentiate from sibling tools like 'shutdown_simulator' or 'list_simulators'. It provides a basic purpose but lacks specificity and sibling distinction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing a simulator to be available), exclusions, or relationships to sibling tools like 'shutdown_simulator' for stopping or 'list_simulators' for selecting a device. Usage context is implied but not explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

build_xcodeC

Build an Xcode project or workspace

ParametersJSON Schema
NameRequiredDescriptionDefault
projectPathYesPath to the Xcode project or workspace
schemeYesXcode scheme to build
destinationYesBuild destination - Simulator: current architecture only (fast). Device: physical device. SimulatorUniversal: all architectures (slower but compatible)iOSSimulator
configurationNoBuild configuration (e.g., Debug, Release, Beta, or any custom configuration)Debug
derivedDataPathNoCustom derived data path (optional)

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Build') but lacks details on execution behavior, such as whether it runs locally or remotely, timeouts, error handling, or output format. This is inadequate for a tool with potential complexity and no structured safety hints.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and wastes no space, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of building Xcode projects (which can involve compilation, dependencies, and errors) and the lack of annotations and output schema, the description is insufficient. It doesn't cover behavioral aspects, error cases, or what to expect upon completion, leaving significant gaps for an AI agent to understand the tool fully.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, so parameters are well-documented in the schema itself. The description adds no additional parameter semantics beyond the schema, but since the schema is comprehensive, a baseline score of 3 is appropriate as it doesn't need to compensate for gaps.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Build') and resource ('Xcode project or workspace'), providing specific intent. However, it doesn't differentiate from sibling tools like 'install_app' or 'list_simulators', which are related but distinct operations in the Xcode ecosystem.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. While sibling tools exist (e.g., 'install_app', 'list_simulators'), the description doesn't mention them or explain scenarios where building is appropriate versus other actions, leaving usage context unclear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

install_appC

Install an app on the simulator

ParametersJSON Schema
NameRequiredDescriptionDefault
appPathYesPath to the .app bundle
simulatorIdNoDevice UDID or name of the simulator (optional, uses booted device if not specified)

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'install' implies a write/mutation operation, the description doesn't specify permissions needed, whether installation is reversible, error conditions (e.g., invalid app path), or what happens on success/failure. This leaves significant gaps for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations and no output schema, the description is inadequate. It lacks critical context such as what 'install' entails (e.g., overwriting existing apps?), expected return values, error handling, or dependencies on other tools (e.g., requiring a booted simulator). The high schema coverage doesn't compensate for these behavioral gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with both parameters clearly documented in the schema. The description doesn't add any parameter-specific details beyond what's in the schema (e.g., format examples for appPath or simulatorId). With high schema coverage, the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('install') and target resource ('app on the simulator'), making the purpose immediately understandable. It doesn't specifically differentiate from sibling tools like 'boot_simulator' or 'list_simulators', but the verb 'install' is distinct enough for basic differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether the simulator needs to be booted first), exclusions, or relationships with sibling tools like 'boot_simulator' or 'list_simulators'.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_simulatorsC

List available iOS simulators

ParametersJSON Schema
NameRequiredDescriptionDefault
platformNoFilter by platform
stateNoFilter by simulator state
nameNoFilter by device name (partial match, case-insensitive)

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('List') but doesn't describe what the output looks like (e.g., a list of simulator objects with properties), whether it's a read-only operation, or any constraints like rate limits. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that gets straight to the point without any fluff. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place in conveying the essential purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations and no output schema, the description is incomplete for a tool with three parameters and potential behavioral complexity. It doesn't explain the output format, error conditions, or how filtering works beyond what's in the schema. For a listing tool in a developer context, more context on return values or usage patterns would be helpful.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents all three parameters with descriptions and enums. The description adds no parameter-specific information beyond implying filtering (via 'available'), which is already covered by the schema. This meets the baseline for high schema coverage but doesn't provide extra semantic value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('List') and resource ('available iOS simulators'), making the purpose immediately understandable. However, it doesn't distinguish this tool from potential sibling tools like 'boot_simulator' or 'shutdown_simulator' beyond the listing action, and the mention of 'iOS' in the description is slightly misleading since the schema shows support for multiple Apple platforms.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention that this is for listing simulators (vs. booting or shutting them down with sibling tools), nor does it explain prerequisites or typical use cases. The agent must infer usage from the name and context alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

shutdown_simulatorC

Shutdown a simulator

ParametersJSON Schema
NameRequiredDescriptionDefault
deviceIdYesDevice UDID or name of the simulator to shutdown

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. 'Shutdown' implies a destructive action, but the description doesn't clarify if this requires specific permissions, whether it's reversible, what happens to running processes, or error conditions. It lacks essential context for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise with just three words, front-loading the essential information without any wasted text. Every word earns its place in communicating the core function.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a destructive tool with no annotations and no output schema, the description is inadequate. It doesn't explain what 'shutdown' entails behaviorally, what the response looks like, or error handling. Given the complexity of a mutation operation, more context is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with the single parameter 'deviceId' well-documented in the schema. The description doesn't add any parameter details beyond what the schema provides, so it meets the baseline score when schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Shutdown a simulator' clearly states the action (shutdown) and target resource (simulator), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'boot_simulator' or 'list_simulators' beyond the obvious action difference, so it doesn't reach the highest score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'boot_simulator' or prerequisites for shutdown. It merely states what the tool does without context about appropriate usage scenarios or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.4/5.0
Disambiguation5/5

Each tool has a clearly distinct purpose with no overlap: booting, building, installing, listing, and shutting down are all separate operations in the Xcode/simulator workflow. An agent can easily distinguish between them based on their specific actions.

Naming Consistency5/5

All tools follow a consistent verb_noun pattern (e.g., boot_simulator, build_xcode, install_app), using snake_case throughout. This predictable naming makes the tool set easy to navigate and understand.

Tool Count5/5

With 5 tools, the server is well-scoped for managing Xcode projects and simulators. Each tool serves a clear, essential function in this domain, avoiding bloat or thin coverage.

Completeness4/5

The tool set covers core operations for building and simulator management, but minor gaps exist, such as running tests or configuring project settings. However, agents can likely work around these with the provided tools for basic workflows.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • Xcode MCP Server

    ebowwa
    A
    license
    B
    quality
    C
    maintenance
    Provides programmatic access to Xcode functionality, enabling AI assistants to create, build, test, and manage iOS/macOS projects directly.
    33
    7
    5
    MIT

  • xcode-mcp-server (drewster99)

    drewster99
    A
    license
    A
    quality
    B
    maintenance
    Enable Claude Code, Cursor, or your favorite LLM to interact with Xcode, building your projects the same way you do, and seeing the same errors. Greatly increases productivity when working on iOS, iPadOS, macOS, visionOS, tvOS projects & Swift packages - or any time you might use Xcode.
    29
    5
    MIT

  • Xcode MCP Server

    airdrop-alpha
    A
    license
    A
    quality
    C
    maintenance
    Enables AI assistants to manage Xcode projects by listing targets, reading configurations, and triggering builds via the Model Context Protocol. It facilitates natural language interaction with macOS developer tools to streamline iOS app development processes.
    6
    234
    MIT

Appeared in Searches

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Stefan-Nitu/mcp-xcode-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server