mac-messages-mcp

by carterlasalle

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes, but tool_check_addressbook and tool_check_contacts could cause confusion as both relate to address book diagnostics and listing. The other tools like send_message, fuzzy_search_messages, and get_recent_messages are clearly differentiated by their specific functions.
Naming Consistency4/5
The naming follows a consistent verb_noun pattern with snake_case throughout, such as tool_check_addressbook and tool_send_message. However, there is a minor deviation with tool_find_contact (using 'find' instead of 'check' or 'get'), which slightly breaks the pattern but remains readable.
Tool Count5/5
With 9 tools, the count is well-scoped for a Messages app integration, covering diagnostics, contact management, message retrieval, and sending. Each tool serves a clear purpose without feeling excessive or insufficient for the domain.
Completeness4/5
The toolset provides good coverage for messaging operations, including sending, searching, and retrieving messages, as well as contact management and diagnostics. A minor gap is the lack of tools for updating or deleting messages, but agents can work around this for typical use cases.
Average 3.2/5 across 9 of 9 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 6 of 6 community issues answered or closed in the last 6 months
- 13 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
This repository includes a glama.json configuration file.
This server has been verified by its author.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

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 tool diagnoses issues but does not specify what 'diagnose' entails—e.g., whether it performs read-only checks, requires permissions, returns error details, or has side effects. This leaves critical behavioral traits unclear for safe and effective use.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence ('Diagnose AddressBook access issues.') that is front-loaded and wastes no words. It could be slightly improved by adding context or usage hints, but it effectively conveys the core purpose without unnecessary elaboration, earning a high score for conciseness.
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 diagnostic nature, lack of annotations, and no output schema, the description is incomplete. It does not explain what the diagnosis returns, how results are structured, or any behavioral constraints. For a tool that likely involves system checks, more context is needed to ensure the agent understands its operation and outputs.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, meaning no parameters need documentation. The description does not add parameter details, which is appropriate here. A baseline score of 4 is assigned as the description does not need to compensate for any parameter gaps, aligning with the rule for zero parameters.
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 'Diagnose AddressBook access issues' clearly states the tool's purpose with a specific verb ('diagnose') and target ('AddressBook access issues'), avoiding tautology. However, it does not distinguish this from sibling tools like 'tool_check_contacts' or 'tool_check_db_access', which might have overlapping diagnostic functions, leaving room for ambiguity in tool selection.
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 does not mention prerequisites, context for diagnosing access issues, or refer to sibling tools for related tasks, such as 'tool_check_contacts' for contact-specific checks. This lack of usage context could lead to incorrect tool selection by an agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It implies a read-only diagnostic operation but doesn't disclose traits like whether it performs active tests, returns structured results, requires permissions, or has side effects, which is inadequate for a tool with zero annotation coverage.
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 with zero waste, front-loading the core purpose without unnecessary elaboration. It's appropriately sized for a simple diagnostic tool with no parameters.
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 lack of annotations and output schema, the description is incomplete. It doesn't explain what 'diagnose' entails behaviorally, what results to expect, or how it differs from other check tools, leaving significant gaps for an agent to understand its use in context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description doesn't add param details, but this is appropriate given the empty schema, warranting a baseline score above minimum viable.
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 'Diagnose database access issues' clearly states the tool's purpose with a specific verb ('diagnose') and target ('database access issues'), avoiding tautology. However, it doesn't differentiate this diagnostic tool from other 'check' siblings like tool_check_addressbook or tool_check_contacts, leaving ambiguity about scope.
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 specify prerequisites, context (e.g., after connection errors), or exclusions, nor does it reference sibling tools for comparison, leaving usage entirely implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 mentions 'fuzzy matching,' which hints at approximate search behavior, but fails to detail critical aspects like error handling, permissions needed, rate limits, or what happens if no matches are found. For a search tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, with the core purpose stated first. The two-sentence structure is efficient, and the 'Args:' section adds clarity without redundancy. While it could be slightly more detailed, it avoids unnecessary verbosity, earning a high score for conciseness.
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 search operation), lack of annotations, and no output schema, the description is incomplete. It doesn't explain return values, error cases, or behavioral nuances like how 'fuzzy matching' works. This leaves gaps that could hinder an AI agent's ability to use the tool effectively, especially compared to more comprehensive descriptions.
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 description adds minimal semantics beyond the input schema. It explains that 'name' is 'The name to search for,' which clarifies the parameter's purpose. However, with 0% schema description coverage and only one parameter, this is adequate but not exceptional. The baseline for a single parameter with low coverage is met, but no additional details like format or constraints are provided.
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 tool's purpose: 'Find a contact by name using fuzzy matching.' It specifies the verb ('Find'), resource ('contact'), and method ('fuzzy matching'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'tool_check_contacts' or 'tool_fuzzy_search_messages', which prevents a perfect 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. It doesn't mention sibling tools like 'tool_check_contacts' or 'tool_fuzzy_search_messages', nor does it specify prerequisites, exclusions, or contextual cues for selection. This lack of comparative information limits its utility for an AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 tool lists contacts but doesn't reveal any behavioral traits like whether it requires permissions, how it handles errors, or what the output format might be. This is a significant gap for a tool with zero annotation coverage.
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 any wasted words. It is 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?
Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'available contacts' means, how results are returned, or any limitations, which is inadequate for a tool that interacts with data. More context is needed to fully understand its behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, and a baseline of 4 is appropriate as it doesn't mislead or omit necessary information in this context.
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 ('List') and resource ('available contacts in the address book'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'tool_check_addressbook' or 'tool_find_contact', which likely have overlapping functionality, so it doesn't achieve full 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?
The description provides no guidance on when to use this tool versus alternatives such as 'tool_find_contact' or 'tool_check_addressbook'. It lacks explicit context, exclusions, or prerequisites, leaving the agent without direction on tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 ('List') but does not specify whether this is a read-only operation, what permissions are needed, how results are returned (e.g., pagination, format), or any rate limits. This leaves significant gaps for an agent to understand 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 a single, clear sentence with no wasted words. It is front-loaded with the core action and resource, making it highly efficient and easy to parse for an agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
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, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on behavior, output format, and usage context, which are needed for full completeness in a no-annotation scenario.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description does not need to add parameter semantics, and it appropriately avoids unnecessary details, earning a high baseline score for this dimension.
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 group chats from the Messages app'), making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'tool_get_recent_messages' or 'tool_fuzzy_search_messages', which prevents a perfect 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 such as 'tool_get_recent_messages' for recent messages or 'tool_fuzzy_search_messages' for searching. There is no mention of prerequisites, context, or exclusions, leaving usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 mentions the tool sends messages but doesn't cover critical aspects like whether it requires authentication, potential rate limits, error conditions (e.g., invalid recipient), or what happens on success/failure. The description adds some context about recipient formats but misses key behavioral traits needed for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the core purpose in the first sentence. The parameter explanations are organized in a clear list format, making it easy to scan. While efficient, it could be slightly more concise by integrating the parameter details more seamlessly, but overall it avoids unnecessary verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a message-sending tool with 3 parameters, 0% schema coverage, no annotations, and no output schema, the description is moderately complete. It covers parameter semantics well but lacks behavioral context (e.g., side effects, errors) and output information. For a tool that performs a write operation, more completeness around success criteria and potential impacts would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate. It provides meaningful semantics for all three parameters: 'recipient' explains formats (phone, email, contact name, 'contact:N'), 'message' clarifies it's text to send, and 'group_chat' indicates it uses chat ID instead of buddy. This adds substantial value beyond the bare schema, though it could include examples for the message parameter or more details on group_chat behavior.
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 ('Send a message') and resource ('using the Messages app'), making the purpose immediately understandable. It distinguishes itself from sibling tools like tool_fuzzy_search_messages or tool_get_recent_messages by focusing on sending rather than retrieving messages. However, it doesn't explicitly differentiate from potential message-related tools that might exist elsewhere.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through the parameter explanations (e.g., 'contact:N' for selecting from matches), suggesting when to use certain recipient formats. However, it lacks explicit guidance on when to use this tool versus alternatives like tool_get_chats for viewing chats or tool_find_contact for contact lookup, and doesn't mention prerequisites such as needing the Messages app available.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 mentions the tool's purpose and use cases but lacks details on behavioral traits like what 'availability' means (e.g., online status, service registration), potential errors (e.g., invalid recipient format), or side effects (e.g., rate limits, privacy implications). For a tool with no annotation coverage, this is a significant gap.
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 appropriately sized and front-loaded: it starts with the core purpose, followed by usage context and parameter details in a structured 'Args:' section. Every sentence adds value without redundancy, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (1 parameter, no output schema, no annotations), the description is adequate but incomplete. It covers purpose, usage, and parameter semantics but lacks behavioral details (e.g., return format, error handling) and doesn't leverage sibling context to clarify distinctions. It meets minimum viability but has clear 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?
The schema description coverage is 0%, so the description must compensate. It adds meaning by explaining that the 'recipient' parameter is a 'Phone number or email to check for iMessage availability,' which clarifies the expected input format beyond the schema's generic string type. However, it doesn't cover validation rules or examples, leaving some ambiguity.
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 tool's purpose: 'Check if a recipient has iMessage available.' It specifies the verb ('check') and resource ('iMessage availability'), making the action explicit. However, it doesn't distinguish this tool from sibling tools like 'tool_check_contacts' or 'tool_check_addressbook' in terms of scope or domain, which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool: 'Useful for debugging delivery issues or choosing the right service.' It implies usage scenarios (debugging and service selection) but does not explicitly state when not to use it or name alternatives among siblings, such as 'tool_send_message' for actual sending, which would be needed for a score of 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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. It mentions default values and optional filtering, but doesn't disclose critical behavioral traits such as rate limits, authentication needs, pagination, error handling, or what 'recent messages' includes (e.g., message count limits). This leaves significant gaps for an agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the purpose, followed by structured parameter details. Every sentence adds value, though it could be slightly more concise by integrating the purpose and parameters more seamlessly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (2 parameters, no annotations, no output schema), the description is partially complete. It covers parameters well but lacks information on return values, error cases, and behavioral constraints, making it adequate but with clear gaps for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by explaining both parameters: 'hours' as 'Number of hours to look back (default: 24)' and 'contact' with detailed filtering options including a specific syntax. This adds substantial meaning beyond the bare schema.
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 tool's purpose: 'Get recent messages from the Messages app.' It specifies the verb ('Get') and resource ('recent messages'), but doesn't explicitly distinguish it from sibling tools like 'tool_fuzzy_search_messages' or 'tool_get_chats', which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through parameter explanations (e.g., 'hours' for time range, 'contact' for filtering), but doesn't explicitly state when to use this tool versus alternatives like 'tool_fuzzy_search_messages' or 'tool_get_chats'. It provides some context but lacks clear when/when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 mentions the tool returns messages with similarity scores, which is useful, but lacks critical details like whether this is a read-only operation, potential rate limits, authentication requirements, pagination behavior, or what happens if no matches are found. The description provides basic functionality but misses important operational context.
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 efficiently structured with a clear purpose statement followed by a parameter breakdown. Every sentence adds value: the first defines the tool's function, and the parameter explanations provide necessary context without redundancy. It's appropriately sized for a 3-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (fuzzy search with scoring), no annotations, and no output schema, the description is partially complete. It covers parameters well but lacks behavioral details (e.g., read-only status, error handling) and output format clarification (e.g., structure of returned messages with scores). For a search tool with no structured output documentation, this leaves gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant value beyond the input schema, which has 0% description coverage. It explains the purpose of each parameter: search_term ('text to search for in messages'), hours ('how many hours back to search'), and threshold ('similarity threshold for matching') with practical guidance like 'Lower is more lenient' and default values. This fully compensates for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('fuzzy search for messages'), resource ('messages'), and scope ('within the last N hours'). It distinguishes from siblings like tool_get_recent_messages (which likely retrieves without search) and tool_get_chats (which focuses on chat threads rather than message content).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through the time-bound search context ('within the last N hours') but doesn't explicitly state when to use this tool versus alternatives like tool_find_contact (for contacts) or tool_get_recent_messages (for unfiltered recent messages). No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![mac_messages_mcp MCP server](https://glama.ai/mcp/servers/carterlasalle/mac_messages_mcp/badges/card.svg)](https://glama.ai/mcp/servers/carterlasalle/mac_messages_mcp)

Score Badge

Copy to your README.md:

[![mac_messages_mcp MCP server](https://glama.ai/mcp/servers/carterlasalle/mac_messages_mcp/badges/score.svg)](https://glama.ai/mcp/servers/carterlasalle/mac_messages_mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/carterlasalle/mac_messages_mcp'

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