io.github.p-w-4-z/inbox-mcp
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@io.github.p-w-4-z/inbox-mcpshow me unread emails from the last week"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
inbox-mcp
Provider-agnostic email MCP server for AI assistants. Connect any IMAP mailbox to Claude Desktop, Cursor, VS Code, or any MCP-compatible client.
Features
8 email tools: get_summary, list_messages, read_message, search, list_folders, mark_read, move_message, create_folder
Provider auto-detection: Automatically configures Gmail, Outlook, GMX from your email address
Any IMAP server: Works with any standard IMAP provider out of the box
Read-only mode: Optional safety mode that disables all write operations
Security-first: No delete operations exposed. Ever.
Related MCP server: productivity-mcp
Quick Start
pip install inbox-mcpConfiguration
Set two environment variables:
export INBOX_MCP_EMAIL="you@gmail.com"
export INBOX_MCP_PASSWORD="your-app-password"All Environment Variables
Variable | Required | Default | Description |
| Yes | — | Your email address |
| Yes | — | Password or app password |
| No | Auto-detected | IMAP server hostname |
| No | 993 | IMAP port |
| No | Auto-detected | Force provider: gmail, outlook, gmx, generic |
| No | false | Set to |
Provider Auto-Detection
Email Domain | Provider | IMAP Host |
gmail.com, googlemail.com | gmail | imap.gmail.com |
outlook.com, hotmail.com, live.com | outlook | outlook.office365.com |
gmx.net, gmx.at, gmx.de, gmx.ch, gmx.com | gmx | imap.gmx.net |
yahoo.com, ymail.com, rocketmail.com | yahoo | imap.mail.yahoo.com |
anything else | generic | imap.{domain} |
Gmail Setup
Gmail requires an App Password:
Enable 2-Step Verification on your Google account
Go to App Passwords
Generate a password for "Mail"
Use that as
INBOX_MCP_PASSWORD
Client Configuration
Claude Desktop
Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"inbox": {
"command": "inbox-mcp",
"env": {
"INBOX_MCP_EMAIL": "you@gmail.com",
"INBOX_MCP_PASSWORD": "your-app-password"
}
}
}
}Claude Code
claude mcp add -e INBOX_MCP_EMAIL=you@gmail.com -e INBOX_MCP_PASSWORD=your-app-password inbox inbox-mcpCursor / VS Code
Add to .cursor/mcp.json or .vscode/mcp.json:
{
"mcpServers": {
"inbox": {
"command": "inbox-mcp",
"env": {
"INBOX_MCP_EMAIL": "you@gmail.com",
"INBOX_MCP_PASSWORD": "your-app-password"
}
}
}
}Running Directly
# As entry point
inbox-mcp
# As module
python -m inbox_mcpTools
Tool | Description | Write? |
| Inbox stats: total, unread, last 7 days | No |
| List messages with filters (all, unread, today, week) | No |
| Full message body by sequence number | No |
| Search by subject or sender | No |
| List all IMAP folders/labels | No |
| Set messages as read | Yes |
| Move messages between folders | Yes |
| Create a new IMAP folder | Yes |
Write tools are disabled when INBOX_MCP_READ_ONLY=true.
Multiple Accounts
Run multiple instances with different names:
{
"mcpServers": {
"work-email": {
"command": "inbox-mcp",
"env": {
"INBOX_MCP_EMAIL": "you@company.com",
"INBOX_MCP_PASSWORD": "work-password",
"INBOX_MCP_HOST": "mail.company.com"
}
},
"personal-email": {
"command": "inbox-mcp",
"env": {
"INBOX_MCP_EMAIL": "you@gmail.com",
"INBOX_MCP_PASSWORD": "gmail-app-password"
}
}
}
}License
Dual-licensed:
AGPL-3.0 — free for open-source use (see LICENSE)
Commercial — for proprietary use (see LICENSE-COMMERCIAL)
If your project is open-source, you can use inbox-mcp under AGPL-3.0 at no cost. For proprietary/closed-source use, contact hello@breact.com for a commercial license.
Available Tools
8 toolscreate_folderB
Create a new IMAP folder.
Args: folder_name: Name of the folder to create (e.g. 'Archive/2024')
| Name | Required | Description | Default |
|---|---|---|---|
| folder_name | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only states creation, but doesn't mention idempotency, error behavior (e.g., if folder exists), permissions, or side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise with two sentences front-loaded. Every word serves a purpose, and the example is placed immediately after the parameter name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Tool is simple with one parameter and an output schema, so the description is nearly adequate. But missing contextual aspects like prerequisites, error states, or notes about case sensitivity or special characters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries the burden. It explains 'folder_name' with an example path, adding meaning beyond the schema. However, it lacks details like validation rules or format restrictions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states 'Create a new IMAP folder' with a specific verb and resource. The example 'Archive/2024' differentiates it from sibling tools like list_folders or move_message.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, such as checking folder existence with list_folders first or considerations about parent folders. Lacks any contextual hints.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_summaryA
Get inbox statistics: total messages, unread count, and messages from the last 7 days.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description clearly indicates a read-only operation without side effects. Since no annotations are provided, the description adequately covers the behavioral context by listing the returned data. It could mention any required authentication or data freshness, but remains sufficient for a simple stats tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence of 13 words, front-loading the core action and output. Every word contributes meaning, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters and an output schema present), the description provides sufficient context about what the tool returns. It could hint at the output structure, but the output schema likely covers that. The description is adequate for an agent to understand the tool's role.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the input schema is empty. The description does not need to add parameter information. Per guidelines, 0 parameters receives a baseline score of 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves inbox statistics, specifying the exact fields: total messages, unread count, and messages from the last 7 days. It distinguishes itself from sibling tools by focusing on aggregated data rather than individual message operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when needing summary statistics, but does not explicitly state when to use this tool versus alternatives like list_messages or search. No guidance on prerequisites or exclusions is provided, leaving room for misuse.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_foldersA
List all available IMAP folders/labels in the email account.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must convey behavioral traits. It only states the action without disclosing side effects, authentication needs, or any limitations. The tool is presumably read-only, but this is not explicitly stated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that immediately conveys the tool's purpose. Every word earns its place, with no redundancy or unnecessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with an output schema, the description is adequate. It could be slightly more specific about the response format, but the presence of an output schema reduces the need for such details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description adds meaning by emphasizing 'all available' folders/labels, confirming no filtering or input is needed. This provides clarity beyond the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists all available IMAP folders/labels, specifying the verb 'list' and the resource 'IMAP folders/labels'. It effectively distinguishes itself from sibling tools like create_folder or list_messages, which have different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 like search or get_summary. The description does not include any usage context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_messagesA
List messages from a mailbox folder.
Args: folder: IMAP folder to read from (default: INBOX) filter: Message filter — 'all', 'unread', 'today', or 'week' (default: unread) limit: Maximum number of messages to return, up to 50 (default: 20)
| Name | Required | Description | Default |
|---|---|---|---|
| folder | No | INBOX | |
| filter | No | unread | |
| limit | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full burden. It discloses filter behavior (e.g., 'unread') and limit caps, but does not clarify if listing mutates message states (e.g., marks as read) or other side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, with a clear one-line purpose followed by a structured Args list. Every sentence earns its place with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given three parameters, no required fields, and an existing output schema, the description covers the key inputs well. It could mention return ordering or pagination, but the output schema likely covers return structure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description adds crucial meaning: it defines valid filter values, clarifies that folder is an IMAP folder, and specifies the limit range (max 50). This goes well beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists messages from a mailbox folder, with specific parameters (folder, filter, limit). It effectively distinguishes itself from siblings like search or get_summary by focusing on listing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly state when to use this tool versus alternatives like search or get_summary. While the parameter details imply typical usage, no guidance on exclusions or preferred contexts is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
mark_readA
Mark one or more messages as read (sets the IMAP Seen flag).
Args: message_ids: List of IMAP sequence numbers to mark as read folder: IMAP folder containing the messages (default: INBOX)
| Name | Required | Description | Default |
|---|---|---|---|
| message_ids | Yes | ||
| folder | No | INBOX |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that the tool sets the IMAP Seen flag (a write operation), but does not mention any prerequisites, permissions, or side effects (e.g., triggering notifications). This is adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is minimal and front-loaded with the main action, followed by a clear 'Args:' section. Every sentence serves a purpose with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple operation and presence of an output schema (for return values), the description covers the essential inputs and behavior. It does not detail return structure, but that is handled by the output schema. Minor improvement could include noting the effect on message state.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description explains that 'message_ids' are IMAP sequence numbers and 'folder' is the IMAP folder with a default of INBOX. This adds meaning beyond the schema's title and type, compensating well for lack of schema description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'mark' and the resource 'messages as read', explicitly linking to IMAP Seen flag. It is specific and distinguishable from siblings like 'read_message' (which reads content) and 'move_message'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description directly states the action and the default folder (INBOX), implying its typical use. It does not explicitly mention when not to use it or list alternatives, but the purpose is sufficiently clear for an agent to decide.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
move_messageA
Move one or more messages to a different folder. Creates the target folder if needed.
Args: message_ids: List of IMAP sequence numbers to move target_folder: Destination IMAP folder source_folder: Source IMAP folder (default: INBOX)
| Name | Required | Description | Default |
|---|---|---|---|
| message_ids | Yes | ||
| target_folder | Yes | ||
| source_folder | No | INBOX |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses that target folder is created if needed, which adds behavioral context beyond the schema. However, no annotations exist, and the description doesn't mention side effects like deletion from source or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Very concise: one sentence for main action, one for auto-create, then clear args list. No wasted words, front-loaded with core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Provides enough context for core functionality and auto-creation, but lacks details on success/error response, permissions, or rate limits. Output schema may cover return values, so this is adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explains each parameter beyond the schema names: message_ids are IMAP sequence numbers, target_folder is destination, source_folder is source with default INBOX. This compensates for the 0% schema description coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool moves messages to a different folder and mentions automatic folder creation. It distinguishes from siblings like create_folder or list_messages.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implied usage for moving messages, but no explicit when to use or not, nor alternatives mentioned. Lacks prerequisites or context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
read_messageA
Read the full body of a specific email by its sequence number.
Args: message_id: The IMAP sequence number of the message (from list_messages) folder: IMAP folder containing the message (default: INBOX)
| Name | Required | Description | Default |
|---|---|---|---|
| message_id | Yes | ||
| folder | No | INBOX |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description indicates a non-destructive read operation but does not disclose additional behavioral traits like encoding, size limits, or authentication needs. With no annotations, the description carries the burden but provides minimal extra transparency beyond the obvious.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with no redundant words, front-loads the main purpose, and uses a clear parameter list. Every sentence adds necessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers both parameters well and, given the existence of an output schema, does not need to detail return values. However, it omits discussion of potential encoding or attachments, leaving room for ambiguity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds key meaning: message_id is an IMAP sequence number from list_messages, and folder specifies the IMAP folder (default INBOX). This goes beyond the schema's type-only definitions, compensating for 0% schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'read' and the resource 'full body of a specific email', distinguishing it from siblings like list_messages (listing headers) and search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explains how to obtain the message_id (from list_messages) and the folder parameter, implying when to use the tool (when you need full email body). It lacks explicit when-not or alternatives, but the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
searchA
Search messages by subject or sender.
Args: query: Search term to look for in subject and sender fields folder: IMAP folder to search in (default: INBOX) limit: Maximum number of results, up to 50 (default: 20)
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| folder | No | INBOX | |
| limit | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the tool searches subject and sender only (not body), constrains results up to 50, and defaults to INBOX folder. This is good transparency, though it doesn't mention return format or ordering.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: a one-line purpose followed by a structured argument list. Every sentence adds necessary information with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, return values need not be described. The description covers purpose, parameters, and key constraints like field scope and result limits. It could mention error handling or authentication, but for a search tool it is sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must add meaning. It explains each parameter: query as search term for subject/sender, folder as IMAP folder with default, limit up to 50 with default 20. This adds significant value beyond the schema's names and types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Search messages by subject or sender', which includes a specific verb and resource. It distinguishes from siblings like list_messages by narrowing the scope to subject and sender fields.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly provide usage guidance or alternatives. It implies usage through its description but lacks 'when to use' or 'when not to use' context relative to siblings like list_messages or read_message.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
8 tool updates
v1.0.0- First observed
create_folder - First observed
get_summary - First observed
list_folders - First observed
list_messages - First observed
mark_read - First observed
move_message - First observed
read_message - First observed
search
TDQS
Each tool has a clearly distinct purpose: folder creation, summary stats, folder listing, message listing, marking read, moving, reading, and searching. No overlaps.
All tool names follow a consistent verb_noun snake_case pattern (e.g., create_folder, list_messages, mark_read). 'search' is a verb but fits the pattern.
8 tools cover the core inbox management operations without bloat. The count is appropriate for the domain.
Covers main actions: folder creation, listing, message reading, marking read, moving, searching. Missing delete/mark unread/send are minor gaps but not critical for the stated purpose.
Maintenance
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
Email infrastructure for AI agents — send, receive, search, and reply to email over MCP.
Email inboxes for AI agents: send, receive, reply, search, and manage threaded email over MCP.
Shipmail MCP server for AI agent custom-domain email inboxes with REST API and webhooks.
Hosted email for AI agents: create inboxes, send, receive, and reply over MCP with scoped API keys
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceA generic IMAP and SMTP MCP server that enables AI agents to interact with email accounts for reading, searching, and sending messages. It provides high-level tools for managing email workflows like daily digests and folder organization across any standard email provider.1MIT
- AlicenseBqualityDmaintenanceA local MCP server that provides LLM clients with read/write access to email and calendar data from Gmail, iCloud, and generic IMAP providers. It runs entirely on your machine, keeping data private while enabling email management, calendar operations, and task handling through natural language.39MIT
- AlicenseNot gradedqualityFmaintenanceAn MCP server that receives emails on your domain and allows AI assistants to search, read, and manage them via natural language queries.1,234MIT
- AlicenseNot gradedqualityCmaintenanceAn MCP server that gives AI assistants comprehensive access to Apple Mail accounts, enabling email discovery, reading, flag management, and server-side message retrieval.MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/p-w-4-z/inbox-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server