meetmyagent-mcp

Server Quality Checklist

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

Latest release: v0.2.0
Disambiguation5/5
Each tool has a clearly distinct purpose: listing CRUD, catalog schema, blog, provider profiles, search, requests, etc. No two tools overlap in their intended action or resource.
Naming Consistency5/5
All tools follow the 'mma_verb_noun' snake_case pattern (e.g., mma_create_listing, mma_describe_catalog). This is highly consistent and predictable.
Tool Count5/5
10 tools is a well-scoped set for a marketplace server. Each tool serves a necessary function without being overwhelming or too sparse.
Completeness4/5
The core listing lifecycle is covered (create, import, read, search, my listings), but update and delete operations are absent, which agents may need.
Average 4/5 across 10 of 10 tools scored. Lowest: 3.2/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 6 commits in the last 12 weeks
- Last stable release on August 19, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is failing
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.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
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?
No annotations are provided, and the description does not mention side effects, permissions, or idempotency. As a read-only operation implied by 'get', it lacks explicit transparency about safety or failure modes, placing the burden on the description, which it does not meet.
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, concise sentence without unnecessary fluff. It efficiently conveys the core functionality and key details (provider as agent, verified domains) without redundancy.
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?
While the tool is simple, the description omits critical context about the parameter and any potential variations in output or failure conditions. It gives some context about the provider but lacks completeness due to the missing parameter explanation and no mention of output structure or error cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema includes a single required parameter 'id', but the description does not explain what 'id' refers to (e.g., provider ID). With 0% schema coverage for parameters, the description provides no help in understanding how to use the parameter, making it a significant gap.
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 that the tool retrieves the public profile of a provider, specifying that it is the 'agent' behind listings and includes verified domains. This distinguishes it from sibling tools like get_listing and get_blog, making its purpose unambiguous.
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 does not provide explicit guidance on when to use this tool versus alternatives. It only describes what the tool returns, leaving the agent to infer usage context from the tool name and description alone.
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 must carry the full burden. It mentions filters but doesn't disclose return behavior (e.g., pagination, sorting, result limits), or whether responses are summarized or full. It also doesn't state if 'answered' status implies the request is still viewable. This is a gap for a read-only browsing tool.
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 very concise (two sentences) and front-loaded with the core purpose. The second sentence provides a specific user-facing instruction. No wasted words, though it could add a sentence on behavior without hurting conciseness.
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 that there is an output schema (though its contents are unknown), and the tool has only 3 optional params, the description is somewhat minimal. It doesn't explain the difference between answering a request and browsing, nor does it clarify if the tool can directly answer requests (e.g., by posting a response). The link to meetmyagent.io suggests external action but doesn't clarify the tool's role in completing a request.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so description must compensate. It mentions 'status, category or tag' but doesn't explain the enum values for status (e.g., what does 'answered' mean? vs 'closed'?). It also doesn't clarify how tags/categories are specified or whether any are required. The description adds minimal value beyond the 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: browsing the demand side (requests) and filtering by status, category, or tag. It distinguishes from siblings like mma_search (which searches listings) and mma_get_listing (which gets specific listings), but doesn't explicitly name them as alternatives.
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 for browsing demand-side requests, but it doesn't explicitly state when to use this versus mma_search or mma_get_listing. It does provide a specific action: 'Answer one by pointing the user to https://...' which gives a concrete follow-up, but lacks formal when-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/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 adds the authentication requirement ('needs your API key') and implies a read-only operation via 'List.' It does not disclose potential gaps like pagination, result limits, or error behavior, but for a simple zero-parameter list tool, the auth note provides meaningful 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?
A single, front-loaded sentence delivers the core action, scope, and a prerequisite without any filler or redundancy. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (0 params), the presence of an output schema (which covers return values), and the auth note, the description is largely sufficient. The only minor gaps are unspecified behaviors like pagination or rate limits, which are common for list operations but not critical for this simple tool.
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 zero parameters, and the rubric sets a baseline of 4 when params = 0. The description doesn't need to explain parameters since the input schema is empty and there's nothing to elaborate beyond scope ('your own account').
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 the resource scope ('listings under your own account'), which distinguishes it from siblings like mma_search (all listings) and mma_get_listing (single listing). However, it doesn't explicitly name or contrast sibling tools, so it falls short of a 5.
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 context—this tool retrieves only your own account's listings, and it flags the API key prerequisite. Yet it provides no explicit when/when-not guidance or named alternatives (e.g., mma_search vs. mma_my_listings), so it stays at implied usage level.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of communicating behavior. It makes clear this is a read-style 'fetch' that returns a single listing's full detail, including agent/provider and follow-up links. It does not discuss auth, rate limits, or failure behavior, but for a simple one-item get operation it is reasonably transparent.
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 compact, front-loaded with the main action, and scannable. The human-readable page URL adds extra context but is not essential for API usage, keeping it from a perfect conciseness score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter read tool, the description covers purpose, result scope, notable included fields, and even provides a related human-facing resource. With an output schema present, it does not need to enumerate every return field, so this is a complete enough description for selection and invocation in most cases.
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 only defines one required string 'id' with no per-parameter description, so the phrase 'by id' provides the essential mapping from the parameter to the listing identity. However, it does not clarify id format, whether it is an internal id only, or how to obtain it beyond the human-readable URL hint. This is adequate but not value-adding beyond the schema.
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 states a specific action ('Fetch one listing by id'), a clear resource ('listing'), and a meaningful scope ('full detail') that distinguishes it from broader or sibling tools. It also names the included entities (agent/provider, verified-business badge, links), making the tool's purpose concrete.
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 the right context—when you have a listing id and need full listing details—but it does not explicitly mention when not to use it or point to sibling alternatives like mma_search or mma_get_provider. The usage signal is clear but not fully spelled out.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/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 discloses that extraction is 'quarantined' (implying safety), that it returns a draft and a gapReport, and that publishing is done from the console (not via this tool). It also states the auth scope requirement. This is good behavioral disclosure for a tool with no annotations.
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 two sentences, front-loaded with the core purpose, and every clause adds value. It covers the workflow, the return value, and the auth requirement without waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has an output schema (which likely describes the draft and gapReport), so the description doesn't need to detail return values. It explains the workflow (import, fill gaps, publish from console) and the auth requirement. It could mention what 'quarantined' means in terms of behavior, but overall it's complete for a tool with an output schema.
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?
Schema description coverage is 100%, so the schema already documents both parameters. The description adds the context that these are alternatives ('or') and that they are for importing a draft, but doesn't add much beyond the schema. Baseline 3 is appropriate.
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 tool's purpose: 'Zero-form listing: import a draft from a URL or pasted text (quarantined extraction).' It specifies the verb (import), the resource (listing draft), and the method (URL or text). It distinguishes from siblings like mma_create_listing by emphasizing 'zero-form' and 'quarantined extraction'.
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 on when to use: 'import a draft from a URL or pasted text' and mentions the workflow: 'fill the gaps, then publish from the console.' It doesn't explicitly state when not to use or name alternatives, but the context is clear enough. It also mentions the API key requirement, which is a prerequisite.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of explaining behavior, and it does disclose cursor pagination semantics and the need to use real facet keys. However, it mentions an 'optional geo radius' without exposing a matching schema parameter, which could mislead an agent; it also does not explicitly state that search is read-only or safe to execute.
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 compact, front-loaded with the core purpose, and every sentence earns its place. No filler or redundant restatement of the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 6-parameter search tool with no annotations and a 50% schema description coverage, the description provides the main search model, pagination approach, and prerequisite setup. It is almost complete, but the unresolved 'geo radius' mention and unanswered sort/limit behavior leave some gaps.
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 description goes beyond the schema by clarifying that q is natural-language with semantic ranking, filters are structured facet filters, and that cursor should be passed back until null. It also tells the agent to use mma_describe_catalog for valid facet keys, which adds practical meaning to the filters parameter. However, sort and limit are left to the schema/enum, and the 'geo radius' is not mapped to any parameter.
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 identifies a structured marketplace search with category, facet filters, natural-language query, and geo radius. It also suggests a prerequisite catalog call (mma_describe_catalog), which distinguishes it from lookup/get siblings like mma_get_listing and mma_get_provider.
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?
It gives explicit usage guidance: call mma_describe_catalog first to obtain real facet keys, and pass cursor back until null for pagination. It does not explicitly contrast with siblings, but the search-vs-specific-lookup distinction is strongly implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden. It discloses that listings are free, facet-validated, require a specific API scope, and must be written in third-person voice. This is substantial transparency, though it omits details like error handling or duplicate 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 four tight sentences, front-loaded with the core purpose and followed by prerequisites, style, and auth. Every sentence adds necessary information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 params, nested objects, no annotations), the description covers the essential contextual elements: prerequisites, auth scope, attribute validation, and writing style. The output schema handles return values, so no need to describe them.
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?
Schema coverage is only 43%, so the description compensates by clarifying the attributes object (must use catalog facet keys/enums) and the expected writing style for description/title. It adds critical meaning beyond the basic schema, even if it doesn't explain every parameter.
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 tool's purpose: listing a business, service, or product on MeetMyAgent. It uses a specific verb ('List') and resource, and distinguishes from sibling tools like import or search by emphasizing 'create' context and facet-validation.
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?
It provides explicit usage guidance: call mma_describe_catalog first and use only its facet keys/enum values in attributes, plus a required API scope. It doesn't name alternatives (e.g., mma_import_listing), but the prerequisite and style instructions give clear when-to-use context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must cover behavioral disclosure. It explains the key behavior: the presence/absence of the slug changes the output structure (single post vs. list). It also implies the read-only nature (reading is safe), but does not explicitly state that it is non-destructive retically. However, the behavior is well described for a read operation, and the output schema is available to clarify return types, so score is 4 instead of 5 because it lacks explicit mention of idempotency or side effects (though that is not critical here).
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 one short sentence with a semicolon that efficiently conveys both modes. It front-loads the purpose and provides the key distinction between no-slug and with-slug. Every word is necessary; no waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (2 optional params, output schema exists) and the description explains the main behavior sufficiently. It misses a few details like the locale parameter's effect and potential error cases, but the output schema helps. Since the tool is a blog reader, this level of completeness is adequate; a 4 is appropriate because the description is not exhaustive but covers the core usage.
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?
Schema description coverage is 0%, so the description must explain parameters. It explains 'slug' semantically (identifies a single post) and 'locale' implicitly through the enum in the schema, but the description does not explicitly mention locale affects language or filtering. However, the schema provides an enum for locale, which gives some meaning; the description adds the slug semantics that are not self-evident from the schema (just a string). Since there are only 2 params and the description covers one well)Skip because locale is not mentioned in description but is covered by the enum, overall it compensates adequately.
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 what the tool does: reads the blog, with a specific verb (read), and explains the two modes: with a slug returns one post, without returns a list of posts. It distinguishes itself from siblings like mma_get_listing (which is listing-specific) and mma_search, making the purpose unambiguous.
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 implies usage: provide a slug to get a single post, omit it to list posts. It does not explicitly mention when not to use it or alternatives, but the context is clear enough for the agent to decide. Since there are other read tools (mma_get_provider, mma_get_listing), a bit more guidance on when to choose this over those would have been ideal, but not necessary for a blog tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It transparently specifies the tool returns a manual and instructs the agent to read it back, revealing expected usage behavior. It doesn't discuss side effects or error handling, but for a read-only guide, that's adequate.
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?
Two sentences, front-loaded with the critical 'ALWAYS call this first' instruction, then a concise explanation of what it returns and how to proceed. No unnecessary details, every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (no params) and has an output schema. The description covers the purpose, usage trigger, and follow-up action, which is sufficient. It doesn't detail the output schema contents, but the output schema is available to the agent, so completeness is high.
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 zero parameters, so the schema provides no details. The description does not need to add parameter semantics, and per the rubric, 0 params baselines at 4. The description is irrelevant to parameters but correctly omits them.
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 tool returns the 'live agent operator manual' and explicitly instructs to call it first when a user connects or asks about MeetMyAgent. It distinguishes from siblings by positioning it as an onboarding/reference tool, while siblings handle search, listings, and other actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides an explicit trigger condition ('ALWAYS call this first when a user connects or asks what MeetMyAgent is') and subsequent guidance ('Read it back to the user, then help them list or find something'), which implies when to use other tools. This is direct and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description explains the behavior with and without the category parameter, including live counts and returned facet types and enum values. It warns against inventing values, which is helpful, though it does not explicitly mention side effects or permissions; as a read operation, that is implicit.
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 concise, using two sentences to convey all necessary information without redundancy. It is well-structured and easily scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description fully explains the tool's role in the context of searching and listing, including its prerequisite nature and the rule against inventing facets. It is complete for an agent to know when and how to use it effectively.
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 sole parameter 'category' is well-described in both the schema and the main description, with examples and a clear explanation of its effect on the output. Schema coverage is 100% and the description adds functional meaning.
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 that the tool reads the self-describing facet schema, distinguishing it from search or listing operations. It explicitly says 'BEFORE searching or listing,' making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides explicit when-to-use guidance ('BEFORE searching or listing') and instructs users to only use facet keys and values returned by the tool, preventing misuse. This effectively differentiates it from sibling tools like search and listing.
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:

[![meetmyagent-mcp MCP server](https://glama.ai/mcp/servers/studiomeyer-io/meetmyagent-mcp/badges/card.svg)](https://glama.ai/mcp/servers/studiomeyer-io/meetmyagent-mcp)

Score Badge

Copy to your README.md:

[![meetmyagent-mcp MCP server](https://glama.ai/mcp/servers/studiomeyer-io/meetmyagent-mcp/badges/score.svg)](https://glama.ai/mcp/servers/studiomeyer-io/meetmyagent-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/studiomeyer-io/meetmyagent-mcp'

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