How to create a mcp client using Swift?

[MenJH]

hello, @mattt , I am a swift beginner, I want to write a swift version of client that mimics the python example

Now that I have started a python server before swift client initialization, I wonder if I need to inject something into StdioTransport() before client initialization? Do the initialization directly as in the documentation?

python client link: https://modelcontextprotocol.io/quickstart/client
swift client link: https://github.com/modelcontextprotocol/swift-sdk?tab=readme-ov-file#basic-client-setup

[MenJH]

In kotlin's example, StdioClientTransport() is set this way, and I was wondering how it should be set in swift?

[sebsto]

Actually, an example of code that launches the process, creates the Pipe() for stdin and stdout and connect them correctly to the transport would be appreciated. The Example in the README is not detailed enough to get started.
It is surprisingly hard to get it working in Swift.

One thing which is unclear to me is whose input and output is it ? The client ? The server ? The above kotlin code seems to imply these are the server ones.

But the StdioClientTransport code send() function writes on the output (which should be the input of the server)
I’m confused.

[sebsto]

I tried to spawn the process using the new Subprocess package from Swift Lang.
https://github.com/swiftlang/swift-subprocess

It blocks on client.initailize(). Is this expected ? Should I launch this in a separate task ? @mattt

    // Initialize the MCPclient
    let client = Client(name: ""MyClientName, version: "1.0.0")

    let toolConfig = try getMCPToolCommand(for: "MyTool")
    let command = toolConfig.command

    let serverInput: FileDescriptor = FileDescriptor(
      rawValue: Pipe().fileHandleForReading.fileDescriptor)
    let serverOutput: FileDescriptor = FileDescriptor(
      rawValue: Pipe().fileHandleForWriting.fileDescriptor)

    let pid = try runDetached(.path(FilePath(command)), input: serverInput, output: serverOutput)

    let transport = StdioTransport(
      input: serverInput,
      output: serverOutput,
      logger: logger)
    try await client.connect(transport: transport)

    let result = try await client.initialize() // blocks here, this call never returns 

This outputs

2025-04-20T17:02:14+0200 info BedrockCLI : [MCP] Transport connected successfully
2025-04-20T17:02:14+0200 info BedrockCLI : name=MyClientName version=1.0.0 [MCP] Client connected

[phimage]

More than just an example, some other language SDKs treat process as a first-class citizen for std io, allowing you to launch tools like npx, uv, etc easily

I’m using that approach for now:

extension Process {

    func stdioTransport(logger: Logger? = nil) -> StdioTransport {
        let input = Pipe()
        let output = Pipe()
        self.standardInput = input
        self.standardOutput = output
        // XXX: maybe be std err too (option); some return some log "message"

        return StdioTransport(
            input: FileDescriptor(rawValue: output.fileHandleForReading.fileDescriptor),
            output: FileDescriptor(rawValue: input.fileHandleForWriting.fileDescriptor),
            logger: logger)
    }

}

with

• full path for npx, uv etc... (using /usr/bin/which <exeName>) if simple name without /)
• correct PATH in process env (for instance npx must be able to launch node, so I add npx parent directory to PATH)

[sebsto]

@phimage thank youf or having shared the portion of code. That pat I have and is similar to yours. What I'm struggling with is the rest: launching the process, creating the MCP client, connecting, initializing it.

I launch the process, create the MCP client, connect it (and it works). But then the call to client.initialize() blocks.

Do you have the full code snippet ?

[phimage]

Do you have the full code snippet ?

I share here https://github.com/phimage/mcp-cli-test a macOS CLI test app that launch a "npx" mcp server (npx installed with homebrew)

[sebsto]

Thank you so much.
I made two mistakes.

• The input and output must be inverted on the StdioTransport (input goes to output and the opposite)
• The transport must be created before the process is launched.

Merci Beaucoup. I hope it will help others too.

[Keoooo]

Hello, is there documentation anywhere that will help me understand how to run npm and Python MCP servers from within Swift applications?

[mattt]

@Keoooo You can use Process to run another program like uvx or npx as a subprocess from a Swift program. If you're distributing on the App Store, you'll need to work within the App Sandbox, which has additional caveats.

[Keoooo]

@Keoooo You can use Process to run another program like uvx or npx as a subprocess from a Swift program. If you're distributing on the App Store, you'll need to work within the App Sandbox, which has additional caveats.

Given how common it is to use subprocesses (especially for Node/Python-based MCP servers), do you envision the Swift SDK eventually providing a helper or utility function to abstract this setup?

[mattt]

@Keoooo Perhaps. There's a balance to strike between convenience and expressiveness. There are a lot of things that one might want configure when launching a subprocess, which many / most users won't need to know about that are essential to other users. I suspect a mix of documentation and API affordances will be the best approach here.

[sebsto]

@Keoooo Here is the code I use and that works for me (I want to migrate to the new SubProcess library from SwiftLang group)

    package init(
        with toolConfig: MCPConfiguration.ToolConfiguration,
        name: String,
        for server: String,
        version: String = "1.0.0",
        logger: Logger
    ) async throws {
        self.name = name
        self.client = Client(name: name, version: version)
        self.logger = logger

        logger.trace(
            "Launching process",
            metadata: [
                "command": "\(toolConfig.command)",
                "arguments": "\(toolConfig.args.joined(separator: " "))",
            ]
        )

        // Create pipes for the server input and output
        let serverInputPipe = Pipe()
        let serverOutputPipe = Pipe()
        let serverInput: FileDescriptor = FileDescriptor(
            rawValue: serverInputPipe.fileHandleForWriting.fileDescriptor
        )
        let serverOutput: FileDescriptor = FileDescriptor(
            rawValue: serverOutputPipe.fileHandleForReading.fileDescriptor
        )

        self.process = Process()
        process.executableURL = URL(fileURLWithPath: toolConfig.command)
        process.arguments = toolConfig.args
        process.standardInput = serverInputPipe
        process.standardOutput = serverOutputPipe

        let transport = StdioTransport(
            input: serverOutput,
            output: serverInput,
            logger: logger
        )

        try process.run()
        logger.trace("Process launched")

        try await client.connect(transport: transport)
        logger.trace("Connected to MCP server")

        // Initialize the connection
        let result = try await client.initialize()
        logger.trace("Connection initialized", metadata: ["result": "\(result)"])

        // collect the list of tools available in the MCP server
        // var cursor: String? = nil
        (self.tools, _) = try await client.listTools()
        logger.trace("Available tools", metadata: ["toolsCount": "\(self.tools.count)"])
    }