Add Nylas as a Manus MCP Server (manus-mcp-cli)

What this guide covers

The manus-mcp-cli tool is the command-line interface built into the Manus AI sandbox for managing Model Context Protocol (MCP) server connections. MCP is a standard that lets AI agents call external tools through a typed, discoverable interface. Registering Nylas as an MCP server exposes 16 email and calendar tools that Manus agents can call with structured JSON input and output.

The specific goal is to register nylas mcp serve so Manus can discover Nylas tools automatically. MCP server registration typically takes under 2 minutes once the Nylas CLI is installed. Provider-specific configuration for Gmail, Yahoo, and Exchange is also covered.

Confirm manus-mcp-cli is available in Manus

Every Manus sandbox ships with manus-mcp-cli pre-installed and on the system PATH, so no separate installation step is needed. When Manus creates a sandbox for a task, the binary is ready immediately. The sandbox environment runs Ubuntu Linux and provides a standard shell where you can verify the binary and list any servers that are already registered.

The verification commands take less than 1 second to run. Checking the version confirms the binary exists, and listing servers shows whether any MCP servers were registered in a previous session.

# Verify manus-mcp-cli is available
manus-mcp-cli --version

# List currently registered servers
manus-mcp-cli list servers

If you are working outside the Manus sandbox (for example, testing locally), manus-mcp-cli won't be available. Use the Nylas CLI's own nylas mcp install command to register with a local AI assistant such as Claude Desktop or Cursor. The MCP setup guide covers local configuration for those environments.

Register the Nylas MCP server with manus-mcp-cli

MCP server registration tells Manus the binary path, arguments, and environment variables needed to launch the Nylas MCP server process. After registration, Manus automatically discovers all 16 Nylas tools and makes them callable during any conversation. The registration command accepts either inline JSON or a config file, both following the MCP server specification.

The inline JSON approach works well for single-server setups. The name field becomes the server identifier you reference in later manus-mcp-cli call commands. The env object passes environment variables to the spawned process.

# Register a server with inline JSON config
manus-mcp-cli register server --config '{
  "name": "nylas",
  "command": "nylas",
  "args": ["mcp", "serve"],
  "env": {}
}'

For setups with multiple servers or environment variables, a configuration file keeps the registration command readable. Manus persists the registration for the duration of the sandbox session, so you only need to register once per sandbox.

# Register from a config file
manus-mcp-cli register server --config-file /path/to/mcp-config.json

After registration, verify the server appears in the list. The list tools command should return 16 Nylas tools if the server started successfully.

# List registered servers
manus-mcp-cli list servers

# List tools exposed by the nylas server
manus-mcp-cli list tools --server nylas

Install and register Nylas CLI as a Manus MCP server

Installing the Nylas CLI inside the Manus sandbox and registering it as an MCP server is a 3-step process that takes under 2 minutes. The install script downloads the latest release from GitHub, verifies the SHA-256 checksum, and places the binary at ~/.config/nylas/bin. After API key configuration, the MCP server exposes 16 structured tools for email and calendar operations.

The install script auto-detects the sandbox architecture (typically linux/amd64). Step 2 stores your Nylas API key locally so the MCP server can authenticate requests. Step 3 registers the server with manus-mcp-cli and includes the install path in the PATH environment variable so Manus can locate the binary.

# Step 1: Install the Nylas CLI in the Manus sandbox
curl -fsSL https://cli.nylas.com/install.sh | bash
export PATH="$PATH:$HOME/.config/nylas/bin"

# Step 2: Configure your Nylas API key
nylas auth config --api-key YOUR_NYLAS_API_KEY

# Step 3: Register the Nylas CLI as an MCP server
manus-mcp-cli register server --config '{
  "name": "nylas",
  "command": "nylas",
  "args": ["mcp", "serve"],
  "env": {
    "PATH": "/usr/local/bin:/usr/bin:/bin:$HOME/.config/nylas/bin"
  }
}'

Saving the configuration as a JSON file lets you re-register the server in future sandbox sessions without re-typing the config. The timeout field sets the maximum time in milliseconds that Manus waits for a tool response. The default of 30000ms (30 seconds) handles most email operations, including searches across mailboxes with 50,000+ messages.

{
  "name": "nylas",
  "command": "nylas",
  "args": ["mcp", "serve"],
  "env": {
    "PATH": "/usr/local/bin:/usr/bin:/bin:$HOME/.config/nylas/bin"
  },
  "description": "Email and calendar tools via Nylas CLI",
  "timeout": 30000
}

Once registered, the Manus agent has access to tools like nylas_send_email, nylas_list_emails,nylas_create_event, and nylas_check_availability. The command reference lists all 16 available tools with their parameters.

Send email through the Nylas MCP server

The nylas_send_email MCP tool sends email through whichever provider is connected to the active Nylas grant, whether that is Gmail, Outlook, Yahoo, or any IMAP server. Manus agents can call the tool directly via manus-mcp-cli call, or you can prompt the agent in natural language and it selects the correct tool automatically. Tool calls typically complete in under 3 seconds for plain-text messages.

The manus-mcp-cli call syntax requires the server name (nylas), the tool name (nylas_send_email), and a JSON object with the message fields. The reply_to field is optional and defaults to the grant's primary email address if omitted.

# Send email via manus-mcp-cli tool call
manus-mcp-cli call nylas nylas_send_email '{
  "to": "recipient@example.com",
  "subject": "Weekly report",
  "body": "Hi team, here is the weekly status update.",
  "reply_to": "me@example.com"
}'

HTML email with file attachments works the same way. The content_type field switches the body parser from plain text to HTML. Attachments are read from the sandbox filesystem, so the file must exist at the specified path. The maximum attachment size depends on the provider: Gmail allows up to 25 MB per message, while Outlook allows 150 MB.

# Send HTML email with an attachment
manus-mcp-cli call nylas nylas_send_email '{
  "to": "client@example.com",
  "subject": "Project proposal",
  "body": "<h1>Proposal</h1><p>Please find the proposal attached.</p>",
  "content_type": "text/html",
  "attach": ["/tmp/proposal.pdf"]
}'

Natural language also works: prompt Manus with “Send an email to alice@example.com with the meeting notes from today.” The agent composes the message and calls the MCP tool. Manus asks for confirmation before sending unless you include --yes in the tool configuration.

Configure Gmail for Nylas in Manus

Gmail access in the Manus sandbox comes from grants already connected to a Nylas application. Configuring the CLI with the API key and verifying a Gmail grant with nylas auth list is all that's needed before the MCP server can read and send Gmail messages.

The nylas auth list command shows all connected grants, including the provider type (Google, Microsoft, etc.) and the email address. If the Gmail grant doesn't appear, the account needs to be connected in the Nylas dashboard first. Once a Gmail grant is confirmed, the MCP server auto-selects it when you call email or calendar tools.

# Configure your API key once in Manus
nylas auth config --api-key YOUR_NYLAS_API_KEY

# Verify that a Gmail-connected grant is available
nylas auth list

# The MCP server auto-detects your Gmail grant
manus-mcp-cli call nylas nylas_list_emails '{
  "limit": 5,
  "folders": ["INBOX"]
}'

Configure Yahoo Mail for Nylas in Manus

Yahoo Mail configuration follows the same grant-based pattern as Gmail: connect the Yahoo account in the Nylas dashboard, then configure the CLI with the API key inside the Manus sandbox. Yahoo Mail has approximately 225 million monthly active users as of 2024, making it a common secondary mailbox for consumer-facing applications. The MCP server uses the connected Yahoo grant automatically once it appears in nylas auth list.

Yahoo connects through IMAP under the hood, which Nylas normalizes into the same API surface as Gmail and Outlook. The query parameter in nylas_list_emails supports full-text search across message subject, body, and sender fields.

# Configure your API key once in Manus
nylas auth config --api-key YOUR_NYLAS_API_KEY

# Verify that a Yahoo-connected grant is available
nylas auth list

# Read Yahoo inbox through manus-mcp-cli
manus-mcp-cli call nylas nylas_list_emails '{
  "limit": 10,
  "query": "from:support@yahoo.com"
}'

Configure Exchange and Microsoft 365 for Nylas in Manus

Microsoft 365 and Exchange access use the same grant-based pattern as other providers. Microsoft deprecated Basic Auth for Exchange Online in October 2022, so all connections go through OAuth 2.0 via Microsoft Graph API. The Nylas dashboard handles the Azure AD app registration and token management. In the Manus sandbox, the only step is configuring the API key and verifying the Microsoft-connected grant before calling MCP tools.

Microsoft 365 has over 400 million paid seats (as reported by Microsoft in Q2 2024), making it the most common enterprise provider. The example below shows both mailbox search and calendar event creation. The participants field in nylas_create_event sends calendar invitations to the listed email addresses.

# Configure your API key once in Manus
nylas auth config --api-key YOUR_NYLAS_API_KEY

# Verify that a Microsoft-connected grant is available
nylas auth list

# Search Exchange mailbox through manus-mcp-cli
manus-mcp-cli call nylas nylas_list_emails '{
  "query": "subject:quarterly review",
  "limit": 20
}'

# Create a calendar event
manus-mcp-cli call nylas nylas_create_event '{
  "title": "Sprint planning",
  "start": "2026-03-17T10:00:00",
  "end": "2026-03-17T11:00:00",
  "participants": ["team@company.com"]
}'

Should you add a Manus Skill alongside the Nylas MCP server?

Manus Skills are instruction packages that teach an agent specific workflows, complementing the raw tool access that MCP provides. An MCP server gives the agent 16 callable tools, but a Skill tells the agent when and how to chain those tools for a multi-step task like triaging an inbox or scheduling a meeting series. Adding a Skill typically reduces prompt length by 40-60% for repetitive workflows because the agent doesn't need step-by-step instructions each time.

A Skill directory contains a SKILL.md file with instructions and metadata, optional helper scripts for setup and common operations, and a references directory listing the available MCP tools. The register skill command loads the Skill into the Manus agent's context for the current session.

# Register a Nylas email skill
manus-mcp-cli register skill --path /path/to/nylas-email-skill/

# The skill directory should contain SKILL.md:
# nylas-email-skill/
#   SKILL.md         <- Instructions and metadata
#   scripts/
#     setup.sh       <- Install and auth Nylas CLI
#     send-email.sh  <- Email sending wrapper
#   references/
#     tools.md       <- Available MCP tools

The Manus AI Skills guide covers creating a full Skill for email and calendar workflows step by step.

Example Nylas MCP server configurations for Manus

MCP server configurations are JSON objects that define how Manus launches and communicates with the Nylas CLI process. The three most common patterns are a default single-region server, a multi-region setup for organizations with EU data residency requirements, and a grant-pinned server for routing to a specific email account. Each configuration includes a timeout value in milliseconds, typically set to 30000ms (30 seconds).

The multi-server configuration below registers two servers: one for the default US region and one for the EU region. Manus can address each server by name when calling tools. The --region eu flag routes API requests through Nylas's EU data center, which is required for organizations subject to GDPR data residency rules.

{
  "servers": [
    {
      "name": "nylas",
      "command": "nylas",
      "args": ["mcp", "serve"],
      "env": {
        "PATH": "/usr/local/bin:/usr/bin:/bin:$HOME/.config/nylas/bin"
      },
      "description": "Email and calendar tools",
      "timeout": 30000
    },
    {
      "name": "nylas-eu",
      "command": "nylas",
      "args": ["mcp", "serve", "--region", "eu"],
      "env": {
        "PATH": "/usr/local/bin:/usr/bin:/bin:$HOME/.config/nylas/bin"
      },
      "description": "Email and calendar tools (EU region)",
      "timeout": 30000
    }
  ]
}

For multi-account setups, the --grant flag pins the server to a specific email address. This is useful when a Nylas application has 2 or more connected grants and you want Manus to target a specific mailbox without ambiguity. Register one server per grant you want to expose.

{
  "name": "nylas-work",
  "command": "nylas",
  "args": ["mcp", "serve", "--grant", "work@company.com"],
  "env": {
    "PATH": "/usr/local/bin:/usr/bin:/bin:$HOME/.config/nylas/bin"
  },
  "description": "Work email and calendar"
}

Nylas MCP vs Manus Skills vs direct Nylas CLI

Manus agents can access Nylas email and calendar through three approaches: MCP server registration for structured tool calls, Manus Skills for procedural multi-step workflows, and direct CLI execution for ad hoc shell commands. MCP is the fastest to set up (under 2 minutes) and provides typed JSON schemas for all 16 tools. Skills add procedural instructions on top. Direct CLI execution offers maximum flexibility but no automatic tool discovery.

For most Manus users, the recommended approach is MCP via manus-mcp-cli for tool access, combined with a Skill for any multi-step workflows you repeat often. See the Skills guide and the MCP guide for the full setup of each approach.

Troubleshooting Nylas MCP setup in Manus

Four issues account for roughly 90% of Nylas MCP setup failures in the Manus sandbox: PATH misconfiguration, missing grants, tool call timeouts, and wrong-account routing. Each has a specific fix that resolves the problem in under a minute. The solutions below are listed from most common to least common.

Server not found after registration

A PATH misconfiguration is the most frequent cause. The Nylas CLI installs to ~/.config/nylas/bin, which is not on the default sandbox PATH. When manus-mcp-cli spawns the server process, it uses the env object from the server config to set the process environment. If the Nylas binary path is missing from that object, the spawn fails silently.

# Check if nylas is on the PATH
which nylas

# If not found, add it
export PATH="$PATH:$HOME/.config/nylas/bin"

# Re-register with explicit PATH in env
manus-mcp-cli register server --config '{
  "name": "nylas",
  "command": "/home/user/.config/nylas/bin/nylas",
  "args": ["mcp", "serve"],
  "env": {
    "PATH": "/usr/local/bin:/usr/bin:/bin:/home/user/.config/nylas/bin"
  }
}'

No authenticated grants found

The MCP server requires at least 1 connected grant on the Nylas application behind the API key. Run nylas auth config --api-key YOUR_NYLAS_API_KEY to store the key, then verify connected accounts with nylas auth list. If the list is empty, connect an email account through the Nylas dashboard before retrying.

# Check existing grants
nylas auth list

# If empty, configure your Nylas API key
nylas auth config --api-key YOUR_NYLAS_API_KEY

# Then test the MCP server manually
echo '{"jsonrpc":"2.0","method":"initialize","id":1,"params":{"capabilities":{}}}' | nylas mcp serve

Tool calls timing out

Increase the timeout value in the server configuration. Operations on mailboxes with 50,000+ messages or attachments larger than 10 MB can exceed the default timeout. Set it to 30000ms (30 seconds) or 60000ms (60 seconds) for large-mailbox operations.

Wrong email account used

When multiple grants are connected, the MCP server picks the first one by default. Pin a specific account using the --grant flag in the server args. This is especially common when a Nylas application has both a personal Gmail and a work Outlook account connected.

# Register with a specific grant
manus-mcp-cli register server --config '{
  "name": "nylas-personal",
  "command": "nylas",
  "args": ["mcp", "serve", "--grant", "personal@gmail.com"],
  "env": {}
}'

Next steps

• Create a Manus Skill for Email and Calendar for reusable multi-step workflows
• Give AI Agents Email Access via MCP for local setup with Claude Desktop, Cursor, or VS Code
• Automate Email with Manus AI: Beginner Guide if you are new to Manus
• Command Reference for the complete list of CLI commands and MCP tools
• Model Context Protocol specification — the canonical wire format Manus uses to call CLI tools
• Manus: Playbook reference — structure for Manus task definitions that invoke the CLI