pumpfun-claims-bot

Server Quality Checklist

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

Latest release: v1.0.4
Disambiguation5/5
Each tool targets a distinct data resource: token info, holders, trades, liquidity, bundle status, creator profile, GitHub user, claim history, and SOL price. There is no meaningful overlap or ambiguity between tool purposes.
Naming Consistency5/5
All tools follow a consistent get_<noun> pattern with snake_case, making the read-only nature and target resource immediately clear. No mixed conventions or vague verb variations exist.
Tool Count5/5
Nine tools is a well-scoped size for a claims-verification bot. Each tool covers a distinct piece of the investigation workflow without unnecessary redundancy or bloat.
Completeness4/5
The toolkit covers token intelligence, holder analysis, liquidity, scam signals, creator background, GitHub identity, claim history, and SOL pricing—strong coverage for pre-claim due diligence. However, there is no active claim or eligibility-check action, which leaves a minor gap if the bot is expected to execute claims directly.
Average 3.7/5 across 9 of 9 tools scored. Lowest: 3.1/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 8 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 failing
This repository is licensed under Inno Setup 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.
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, so the description carries the full burden of behavioral disclosure. The description only states the tool's purpose but does not disclose what the tool returns (e.g., a boolean, a score, details), whether it makes external calls, or any side effects. For a detection tool, the output format and interpretation are critical, and this is not addressed.
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, concise sentence that front-loads the purpose. It is efficient and contains no fluff. However, it could be slightly more structured by including a note about the output or usage, but for its length, it is well-written.
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 detection tool with a single parameter and no output schema), the description is incomplete. It does not explain what the tool returns, how to interpret the result, or any limitations. The agent would need to guess the output format, which is a significant gap for a tool that provides a scam indicator.
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 100% for the single parameter 'mint', which is described as 'Token mint address'. The description adds no additional meaning beyond the schema, but since the schema fully covers the parameter, a baseline of 3 is appropriate. The description does not clarify the format or any constraints beyond what the schema provides.
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: detecting if a token launch was bundled, which is a scam indicator. It uses a specific verb ('Detect') and resource ('token launch'), and it distinguishes itself from sibling tools like get_token_info or get_token_holders by focusing on the bundling scam aspect.
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 scam detection but does not explicitly state when to use this tool versus alternatives. It doesn't mention when not to use it or provide context on how it fits with other token analysis tools. The purpose is clear enough that an agent could infer usage, but explicit guidance is missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations provided, and the description does not disclose any behavioral traits such as read-only nature, side effects, rate limits, or required permissions. The tool appears to be a simple fetch, but without explicit disclosure, the agent cannot assess side effects or constraints. This fails to carry the behavioral transparency burden.
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 that packs in the essential information: what it does, the input method, and the output scope. No unnecessary words or redundancy. It is well-structured 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?
The description provides a partial view of the output (repos, followers, bio, account age) but does not mention error handling, return format, or any limitations. Since there is no output schema, the description should compensate more fully. However, given the simplicity of the tool, a score of 3 is appropriate.
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 input schema already provides clear descriptions for each parameter ('GitHub numeric user ID' and 'GitHub username (login)'). The tool description adds meaningful clarification that either parameter can be used, reinforcing the intended usage. This goes beyond the schema's individual field descriptions, earning a high score.
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 function: 'Fetch GitHub user profile' and specifies the input method ('by username or numeric ID') and the key data returned ('repos, followers, bio, account age'). This is a specific verb+resource statement that distinguishes it from other tools in the sibling list.
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?
No explicit guidance is given on when to use this tool versus alternatives. While the sibling tools are clearly different (e.g., token info, pool liquidity), the description does not state conditions, exclusions, or preferences. It only describes the basic function, leaving the agent to infer usage from context.
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 full burden. It mentions 'recent' trade activity, but does not define the time window (e.g., last 24h, last hour, etc.) or any behavior like pagination, rate limits, or whether this is a read-only operation. It does not disclose how the counts are aggregated (e.g., on-chain vs. API-source) or whether it includes wash trading.
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?
Single sentence, front-loaded with the main purpose, and every word adds value. No unnecessary details. Perfectly concise.
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?
The tool is simple (one parameter, no nested objects, no output schema), so the bare description may be sufficient for an agent to know what it returns (volume, buy/sell counts). However, without annotations, more context on the 'recent' window or return format would increase completeness. Still, given its simplicity, it doesn't require extensive documentation.
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% – the only parameter 'mint' is described as 'Token mint address', which is sufficient. The description adds context that the param is for a PumpFun token, but since the schema already covers the parameter adequately, the 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 states a specific verb ('Fetch') and a specific resource ('recent trade activity for a PumpFun token') and mentions the key outputs (volume, buy/sell counts). It clearly distinguishes from siblings like get_token_info or get_token_holders by focusing strictly on trade activity (volume, buy/sell counts).
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 tool is for trade monitoring, but it doesn't explicitly state when to use it vs alternatives (e.g., when tracking volume changes vs. holding distribution). No exclusions or alternatives are named, but in the context of sibling tools like get_token_holders or get_pool_liquidity, the purpose is clear enough to guide selection.
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?
No annotations are provided, so the description carries the burden. It clearly indicates this is a read-only operation ('Check claim history') and explains what information is returned (claim status, count, and token mints). However, it doesn't disclose any other behavioral traits like whether it requires authentication, rate limits, or any side effects, but for a simple read tool, this is sufficient.
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, clear sentence that is front-loaded with the purpose, then details what is checked. It is concise without unnecessary words, but it could be slightly more structured (e.g., separating purpose from details), yet it is efficient and to the point.
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 has only one parameter and no output schema, the description is fairly complete for a simple query tool. It tells the agent what to expect (claim status, count, and token mints). However, it lacks information on edge cases, such as what happens if the user hasn't claimed anything or if the user ID is invalid, which would be helpful but not critical given the simplicity.
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 coverage is 100% (only one parameter, githubUserId, which is described as 'GitHub numeric user ID'). The description adds context by explaining what the tool does with that user ID (checks their claim history), which is helpful. However, since the schema already fully documents the parameter, the baseline is 3, and the description doesn't add much beyond that.
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 uses a clear verb ('Check') and specific resource ('claim history'), and distinguishes the tool from siblings by stating it checks 'whether they have claimed, claim count, and which token mints they claimed from'. This is specific and unambiguous, differentiating it from other get_* tools that focus on tokens or pools.
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 when to use this tool (when you need to check a GitHub user's claim history), but it does not provide explicit guidance on when not to use it or alternatives. Unlike the high-scoring example, it doesn't name alternative tools or exclude scenarios, so it's adequate but not explicit.
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?
No annotations are provided, so the description carries the behavioral disclosure burden. It clearly indicates a fetch/read operation and lists the returned data categories, but does not disclose potential behaviors such as whether the token must exist, how invalid addresses are handled, or whether data is cached. This is adequate but not rich.
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 that lists the resource and returned data categories. There is no filler, repetition, or unnecessary detail, making it easy for an agent to parse quickly.
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 simple one-parameter metadata-fetch tool with no output schema, the description sufficiently covers what the tool returns. It could mention that the input must be a PumpFun token and could clarify what 'flags' means, but the overall context is adequate for an agent to invoke the tool correctly.
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% because the only parameter 'mint' is described as 'Token mint address'. The description adds no additional parameter semantics beyond the schema, so the baseline score of 3 applies.
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 uses a specific verb ('Fetch') and identifies the exact resource (PumpFun token metadata) plus the specific data categories returned (market cap, bonding curve progress, flags). This clearly differentiates from sibling tools like get_token_holders, get_token_trades, and get_pool_liquidity.
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 when to use the tool: when you need token metadata, market cap, bonding curve progress, or flags. However, it does not explicitly state when not to use it or point to alternative sibling tools for different data needs, so the guidance is implied rather than explicit.
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?
No annotations are provided, so the description carries the burden. The use of 'Fetch' implies a read-only operation, but it does not explicitly state that the tool does not modify data or mention any potential side effects, rate limits, or authentication requirements. It does, however, add context by listing the returned fields, which is helpful.
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, front-loaded sentence that starts with the verb and resource, then lists the return fields. No unnecessary words or redundancy, making it highly concise and well-structured.
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 tool is simple with one parameter and no output schema. The description adequately explains what the tool returns (username, launch count, scam estimate, recent coins), which is sufficient for an agent to understand the expected result. Complexity is low, and the description covers the key aspects.
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 coverage is 100% since the wallet parameter has a clear description ('Creator wallet address'). The tool description does not add any additional meaning beyond the schema; it only lists the fields returned, not further elaboration on the parameter. 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 fetches a PumpFun creator profile and lists specific return fields (username, launch count, scam estimate, recent coins). This is a specific verb+resource that distinguishes it from sibling tools like get_token_info or get_github_user.
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 retrieving creator profiles but does not explicitly state when to use it versus alternatives or any exclusions. It lacks guidance such as 'use when you need creator details' or when not to use it. The intent is clear from the resource type but not explicitly articulated.
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 must carry the burden of behavioral disclosure. It states it fetches data, implying a read operation, but does not elaborate on whether the pool exists, what happens if the token is not graduated, or any specific data returned. It adds 'for a graduated token' which is useful, but not comprehensive.
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 that is front-loaded with the main purpose. No wasted words. It is appropriately sized and conveys the essential information.
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 has a simple purpose and full schema coverage, the description is adequate but could mention what data is returned (e.g., liquidity amounts, reserve values) even without an output schema. It lacks details on error cases or prerequisites, but is sufficient for basic usage.
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 coverage is 100% and both parameters have descriptions. The description does not add additional meaning beyond the schema, but the schema already provides adequate guidance. Baseline of 3 is appropriate since no extra context is provided.
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 action ('Fetch') and the specific resource ('PumpSwap AMM pool liquidity') qualified by 'for a graduated token'. It distinguishes the tool from siblings that fetch token info, holders, trades, etc., by focusing on liquidity of an AMM pool.
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 in the context of graduated tokens, which helps the agent understand when to use it (post-graduation). However, it does not explicitly mention when not to use it or alternatives, though siblings are available and the context is clear enough.
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?
No annotations are provided, so the description carries full burden. The verb 'Fetch' implies a read-only operation, and it adds that concentration metrics are included, but it does not disclose any other behaviors such as rate limits, data volume, or potential errors.
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 sentence, front-loaded with the action, and contains no unnecessary words. It is perfectly concise for the tool's simplicity.
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 one parameter and no output schema. The description provides a sufficient overview of the output (top holders with concentration metrics), though it could specify more details like the number of holders or format of metrics, but this is adequate for the tool's complexity.
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 input schema already describes the 'mint' parameter with a sufficient description ('Token mint address'), and the tool description does not add any extra meaning beyond what the schema provides. With 100% schema coverage, the baseline of 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 fetches top holders for a PumpFun token and includes concentration metrics, which distinguishes it from sibling tools like get_token_info or get_token_trades.
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 context that this is for top holder concentration analysis, but it does not explicitly mention alternatives or when not to use it. However, the purpose is clear enough that an agent would know when to choose this tool.
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?
No annotations are provided, so the description carries the full burden. It implies a read-only operation ('Fetch') but does not mention any behavioral details such as return format, potential delays, rate limits, or whether it requires authentication. For a simple read tool this is acceptable but not comprehensive.
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 sentence, highly concise with zero filler. It is front-loaded with the key verb and resource. 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 simplicity of the tool (no parameters, no nested objects, no output schema), the description is largely sufficient. However, it does not specify the exact return value (e.g., numeric price, string representation, or whether it includes historical data), which could leave slight ambiguity. Still, for a straightforward price getter, it is adequate.
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 schema coverage is trivially 100%. Per rubric, 0 parameters yields a baseline score of 4. The description adds no parameter details, but none are needed.
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 'Fetch current SOL/USD price' with a specific verb ('Fetch') and resource ('SOL/USD price'), distinguishing it from sibling tools like get_token_info or get_pool_liquidity. The purpose is unambiguous and directly maps to the tool's name.
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 context for when to use this tool is obvious: whenever the user needs the current SOL/USD price. Since the tool has no parameters and a unique niche among siblings, no exclusions or alternatives are necessary. It is implicitly clear, though not explicitly expressed.
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:

[![pumpfun-claims-bot MCP server](https://glama.ai/mcp/servers/nirholas/pumpfun-claims-bot/badges/card.svg)](https://glama.ai/mcp/servers/nirholas/pumpfun-claims-bot)

Score Badge

Copy to your README.md:

[![pumpfun-claims-bot MCP server](https://glama.ai/mcp/servers/nirholas/pumpfun-claims-bot/badges/score.svg)](https://glama.ai/mcp/servers/nirholas/pumpfun-claims-bot)

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/nirholas/pumpfun-claims-bot'

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