M
MCP Directory CURATED DIRECTORY
911 MCP servers indexed
中文
← Back to directory
A

Atomic-Mail MCP

Community
Programmable email inbox for AI agents
How to install ↓ Compare GitHub source repository ↗
Category
Other
Stars
★ 265 Popular
Transport
stdio (local process)
Runtime
Node.js 20+
Credentials
No credential needed
License
MIT
Last commit
Tools
3
56FMRS · C

Atomic Mail provides autonomous email for AI agents using JMAP and proof-of-work signup, enabling hands-free inbox management. It is suitable for automating email workflows but requires attention to security and the alpha-stage limitations.

Strongest · Documentation 13/20 Weakest · Reliability 8/20

Reliability
8/20
Security and permissions
13/20
Maintenance
12/20
Documentation
13/20
Setup experience
10/20
Why each score
Reliability 8/20
Evidence shows: the manifest is well-formed (valid schema reference, stdio transport, environment variables with isSecret flags, pinned npm version 0.3.4), and the declared tool surface (register, jmap_request, help) is consistent across the manifest and the README's description; the happy path is plausible. Deductions: the manifest declares package @atomicmail/mcp-modelcontextprotocol while the README instructs installing @atomicmail/mcp-github — a real contradiction; only the README and manifest were supplied, with no verifiable CI workflows, committed tests, or server source, so the init/tool-list handshake, error handling, and edge cases cannot be confirmed. Under the static calibration, missing execution evidence lowers the score, and the package contradiction pushes it below the 10 midpoint.
Security and permissions 13/20
Evidence shows: no red-line issue is evident — no real tokens in examples, no code-level exfiltration or covert data transfer, no irreversible destructive defaults; the intended data flow is disclosed (PoW auth service, JMAP API, local credential directory ~/.atomicmail/). Positives: ATOMIC_MAIL_API_KEY is flagged isSecret, credential files are written mode 0600, the README explicitly warns that inbound email is untrusted and scopes installation to the @atomicmail namespace. Deductions: the PoW protocol and credential lifecycle are only described at a high level; key rotation/revocation and a security contact channel are undocumented; no documented confirmation step exists for side-effecting operations such as sending mail (autonomous operation is the stated product goal, but an irreversible send lacks confirmation design); operational security processes are incomplete even though data-flow disclosure is clear.
Maintenance 12/20
Evidence shows: the repository carries an MIT license, is not archived, has 0 open issues, and the manifest and release badge indicate a versioned release path (0.3.4); the breadth of maintained integration surfaces (MCP, AgentSkill, LangChain, Dify, ClawHub) implies ongoing activity and clear version management. Deductions: commit frequency, dependency-update cadence, and issue-response behavior cannot be verified from the static material provided; the file-structure listing shows only CONTRIBUTING.md and LICENSE — no SECURITY.md or documented security-response channel; the CI/release badges are untrusted evidence and cannot directly prove activity.
Documentation 13/20
Evidence shows: the README is layered and substantive — quick install for multiple hosts, a docs-by-goal index table, example workflows, bundled JSON presets, a help tool with embedded cheatsheets, and disclosure of alpha status, the 100MB quota, and strict rate limits, plus an error-messages-with-hints design. Deductions: the install example contradicts the manifest's package name (@atomicmail/mcp-github vs @atomicmail/mcp-modelcontextprotocol), which can directly mislead users; pricing/cost beyond the free tier is not stated; the referenced docs/ files cannot be verified from the supplied material, so troubleshooting depth is only as strong as what the README itself demonstrates.
Setup experience 10/20
Evidence shows: as described, setup is short — paste an npx-based mcpServers JSON block into the host config and restart, after which the agent self-registers via PoW with no manual API key entry; all environment variables are optional and are documented with descriptions; stdio + npx has cross-platform potential. Deductions: the README install package name does not match the manifest's declared package, so users cannot tell which package is canonical — the path is ambiguous and fragile; setup depends on the external auth service's availability, the PoW protocol, and a Node.js 20+ environment; under the static calibration, the absence of verified CI workflows and committed tests caps this dimension below 15, and the package-name ambiguity further reduces the score.

Static review · not runListed 2026-08-07

Read the FMRS scoring method →

Fit and risk

What it can accessUses the networkChanges third-party account data

Best for

  • Workflows where AI agents need their own email inbox for autonomous operation.
  • Automated email handling without human intervention, especially with Claude, Codex, Cursor, etc.
  • Developers who prefer standard protocols (JMAP) to avoid vendor lock-in.

Not for

  • Scenarios requiring human review of every email, since agents can autonomously send and receive.
  • Mission-critical email for enterprises that cannot rely on third-party deliverability guarantees.
  • Organizations that need full control over their email infrastructure or offline operation.

Required permissions

  • Read and write local credential files (default at `~/.atomicmail/credentials.json`).
  • Network access: communicate with Atomic Mail's auth service and JMAP API.
  • Environment variables: may require `ATOMIC_MAIL_API_KEY` to skip registration.

Risks and side effects

  • API keys stored locally could be misused if leaked.
  • Email content is untrusted; agents might be tricked into executing malicious instructions (e.g., phishing).
  • Service is in alpha with storage quotas and rate limits; may be unstable.
  • Dependency on external service; if Atomic Mail is down, agent email functionality is affected.

Setup

Before you start

Runtime：Node.js 20+

ATOMIC_MAIL_API_KEY optionalsecret Optional; an existing API key that skips PoW registration. Comes from credentials saved after an Atomic Mail signup.
Other optional settings (4)
ATOMIC_MAIL_CREDENTIALS_DIR optional Optional; overrides the default credential directory (~/.atomicmail/). Nothing to obtain externally.
ATOMIC_MAIL_AUTH_URL optional Optional; overrides the auth service base URL. Usually not needed.
ATOMIC_MAIL_API_URL optional Optional; overrides the JMAP API base URL. Usually not needed.
ATOMIC_MAIL_INBOX_DOMAIN optional Optional; default inbox domain when inboxId has no @ (default: atomicmail.ai).
  1. Add the following JSON to your MCP client config (e.g., for Claude Desktop, edit claude_desktop_config.json): set command to npx and args to ["-y", "@atomicmail/mcp-github"].
  2. Restart the client.
  3. Ask your agent to create an inbox (e.g., prompt it to read https://atomicmail.ai and register).
claude_desktop_config.json 
{
  "mcpServers": {
    "atomicmail": {
      "command": "npx",
      "args": [
        "-y",
        "@atomicmail/mcp-github"
      ]
    }
  }
}

Shown for Claude Desktop. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "atomicmail": {
      "command": "npx",
      "args": [
        "-y",
        "@atomicmail/mcp-github"
      ]
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add atomicmail -- npx -y @atomicmail/mcp-github

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

After restarting the MCP host, check that the tools register, jmap_request, and help appear in the client's tool list; calling help and getting usage docs confirms the connection works.

Troubleshooting

  1. Check that Node.js 20+ or Deno 2.7+ is installed.
  2. Verify MCP client configuration and restart the host.
  3. Check if `~/.atomicmail/credentials.json` exists and has permissions 0600.
  4. If registration fails, try deleting `~/.atomicmail` and re-register.
  5. Use the `help` tool for built-in troubleshooting guidance.

Things to try

Once connected, you can ask your AI assistant things like:

  • Register an @atomicmail.ai inbox for me with the username myagent
  • Use jmap_request to list the latest emails in my inbox
  • Use the send_mail preset to email a test message to [email protected]
  • Call help to show the available JMAP presets and examples

Tools 3

register writes
Registers a new Atomic Mail inbox and obtains an API key.
jmap_request writes
Sends JMAP requests to read, send, reply, and manage emails.
help read-only
Displays embedded documentation, presets, and troubleshooting information.

Use cases

Have an AI agent subscribe your inbox to newsletters, read them, and send you a daily digest.
Agent monitors a support inbox, replies to common tickets, and only escalates difficult cases to humans.
Agent sends survey emails, follows up based on replies, and summarizes findings.

Supported clients

Claude Desktop
Claude Code
Codex
GitHub Copilot
Cursor
Kilo Code

Listed from the project's documentation, not tested by this site.

Overview

Atomic Mail is an email service provider designed for autonomous AI agents. Agents can register and manage their own @atomicmail.ai inbox via the JMAP standard protocol, without human involvement. It uses proof-of-work (PoW) for signup to prevent abuse, and offers multiple integration paths including MCP, CLI, AgentSkill, and more. This repository contains the MCP server, CLI tools, and integrations for Dify, ClawHub, and others.

Similar servers

Telegram MCP Server 70 · B

Telegram MCP server powered by Telethon to let MCP clients read chats, manage groups, and send/modify messages, media, contacts, and settings.

★ 1.8k · Tools 76 Compare with this →
Compare with other MCP servers

Source revision e4a072940989 Data synced 2026-10-12 Read the FMRS scoring method