solana-launchpads-mcp
Connects with GitHub for repository access and installation, allowing users to clone the server repository for deployment.
Formats all output data as markdown tables for enhanced readability when presenting metrics and statistics.
Built on Python 3.10+, leveraging the Python ecosystem for data processing and API integration.
Tracks metrics across multiple Solana launchpads, providing data on token deployments, successful project graduations, graduation rates, and active wallet addresses on the Solana blockchain.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@solana-launchpads-mcpshow me token deployments across launchpads for the past week"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Solana Launchpads MCP
An MCP server that tracks daily activity and graduate metrics across multiple Solana launchpads.
Features
MCP Tools: Four tools to retrieve daily metrics:
Token deployments.
Successful graduates (completed projects).
Graduation rates.
Active wallet addresses.
Markdown Output: Data is formatted as markdown tables for easy readability.
Related MCP server: pumpfun-wallets-mcp
Prerequisites
Python 3.10 or higher
uv (recommended package manager)
Installation
Clone the repository:
git clone https://github.com/kukapay/solana-launchpads-mcp.git cd solana-launchpads-mcpInstall dependencies:
uv syncInstalling to Claude Desktop:
Install the server as a Claude Desktop application:
uv run mcp install main.py --name "Solana Launchpads"Configuration file as a reference:
{ "mcpServers": { "Solana Launchpads": { "command": "uv", "args": [ "--directory", "/path/to/solana-launchpads-mcp", "run", "main.py" ], "env": { "DUNE_API_KEY": "dune_api_key"} } } }Replace
/path/to/solana-launchpads-mcpwith your actual installation path, anddune_api_keywith your API key from Dune Analytics.
Tools
Tool Name | Description | Parameters |
| Retrieves daily token deployments by platform, optionally as percentages. |
|
| Fetches daily successful graduates by platform. |
|
| Retrieves daily graduation rates by platform. |
|
| Fetches daily active wallet addresses by platform. |
|
Example Usage
To use the MCP server, start it and interact with its tools and prompt via an LLM client (e.g., Claude Desktop or or MCP Inspector). Below are examples for each tool and the prompt, using natural language inputs.
Get Daily Token Deployments
Prompt:
Show me the number of tokens launched on Solana memecoin launchpads each day for the past week.Output:
| date | LaunchLabs | LetsBonk | Pump.fun | Boop | Bags | Believeapp | Moonshot | Sunpump.meme |
|------------|------------|----------|----------|------|------|------------|----------|--------------|
| 2025-06-15 | 50 | 20 | 120 | 10 | 15 | 5 | 30 | 25 |
| 2025-06-14 | 45 | 18 | 110 | 8 | 12 | 4 | 25 | 20 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... |Get Daily Graduates
Prompt:
How many projects successfully graduated from Solana memecoin launchpads daily over the last 10 days?Output:
| block_date | LaunchLabs | LetsBonk | Pump.fun | Boop | Bags | Believeapp | Moonshot | Sunpump.meme |
|------------|------------|----------|----------|------|------|------------|----------|--------------|
| 2025-06-15 | 10 | 5 | 15 | 2 | 3 | 1 | 5 | 4 |
| 2025-06-14 | 8 | 4 | 12 | 1 | 2 | 0 | 4 | 3 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... |Get Daily Graduation Rate
Prompt:
What’s the success rate of projects on Solana memecoin launchpads for the past 5 days?Output:
| block_date | LaunchLabs | LetsBonk | Pump.fun | Boop | Bags | Believeapp | Moonshot | Sunpump.meme |
|------------|------------|----------|----------|------|------|------------|----------|--------------|
| 2025-06-15 | 0.20 | 0.25 | 0.30 | 0.15 | 0.18 | 0.10 | 0.22 | 0.19 |
| 2025-06-14 | 0.18 | 0.22 | 0.28 | 0.12 | 0.15 | 0.08 | 0.20 | 0.17 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... |Get Daily Active Addresses
Prompt:
Tell me how many wallets were active on Solana memecoin launchpads each day for the last week.Output:
| date_time | LaunchLabs | LetsBonk | Pump.fun | Boop | Bags | Believeapp | Moonshot | Sunpump.meme |
|------------|------------|----------|----------|------|------|------------|----------|--------------|
| 2025-06-15 | 2000 | 800 | 5000 | 300 | 400 | 100 | 1200 | 900 |
| 2025-06-14 | 1800 | 700 | 4800 | 250 | 350 | 80 | 1100 | 800 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... |License
This project is licensed under the MIT License. See the LICENSE file for details.
Available Tools
4 toolsget_daily_active_addressesA
Fetch the daily count of active wallet addresses interacting with Solana memecoin launchpads.
This tool retrieves data from a Dune Analytics query and pivots it to show the number of unique
active wallets per day by each platform.
Args:
limit (int, optional): Maximum number of rows to fetch from the Dune query. Defaults to 1000.
Returns:
str: A markdown-formatted table of daily active wallets by platform, or an error message if
the query fails.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses key behavioral traits: data source (Dune Analytics query), transformation (pivoted to show unique active wallets per day by platform), output format (markdown table or error message), and a default parameter value. However, it lacks details on rate limits, authentication needs, or query failure specifics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by concise sections for arguments and returns. Every sentence adds value without redundancy, making it efficient and well-structured for quick comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (data fetching and transformation), no annotations, and no output schema, the description is largely complete. It covers purpose, data source, parameter semantics, and output format. However, it could improve by mentioning potential limitations or error conditions more explicitly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaning by explaining that 'limit' controls the maximum rows fetched from the Dune query, with a default of 1000, which clarifies its purpose beyond the schema's basic type and title. Since there is only one parameter, this is sufficient for good understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('fetch the daily count'), resource ('active wallet addresses'), and scope ('interacting with Solana memecoin launchpads'). It distinguishes from siblings by focusing on active addresses rather than graduates, graduation rates, or tokens deployed, 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.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving daily active wallet data from Dune Analytics, but it does not explicitly state when to use this tool versus the sibling tools (e.g., for analyzing user engagement vs. token metrics). No exclusions or alternatives are provided, leaving some ambiguity in context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_daily_graduatesA
Fetch the daily number of graduates from Solana memecoin launchpads.
This tool retrieves data from a Dune Analytics query and pivots it to show the number of
successful graduates (e.g., completed token sales or projects) per day by each platform.
Args:
limit (int, optional): Maximum number of rows to fetch from the Dune query. Defaults to 1000.
Returns:
str: A markdown-formatted table of daily graduates by platform, or an error message if the
query fails.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and does well by disclosing key behaviors: it retrieves data from Dune Analytics, pivots it, and returns a markdown table or error message. It mentions the query might fail, adding context. However, it lacks details on rate limits, authentication needs, or data freshness, which could be important 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by additional context in a second sentence, and then structured sections for Args and Returns. 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.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (fetching and processing data from an external source), no annotations, and no output schema, the description is fairly complete. It explains what the tool does, the parameter, and the return format. However, it could improve by detailing error conditions or data sources more explicitly, but it covers the essentials well.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate. It adds meaning by explaining the 'limit' parameter as 'Maximum number of rows to fetch from the Dune query' with a default of 1000, which clarifies its purpose beyond the schema's basic type and title. Since there is only one parameter, this is sufficient for good understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'fetch' and the resource 'daily number of graduates from Solana memecoin launchpads', specifying it retrieves data from Dune Analytics and pivots it to show graduates per day by platform. It distinguishes from siblings like 'get_daily_active_addresses' or 'get_daily_tokens_deployed' by focusing on graduates rather than addresses or tokens.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for fetching graduate data from launchpads, but does not explicitly state when to use this tool versus alternatives like 'get_daily_graduation_rate' (which might provide rates rather than counts). No exclusions or specific contexts are provided, leaving some ambiguity in tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_daily_graduation_rateA
Fetch the daily graduation rate of Solana memecoin launchpads.
This tool retrieves data from a Dune Analytics query and pivots it to show the graduation rate
(e.g., percentage of projects that successfully complete their goals) per day by each platform.
Args:
limit (int, optional): Maximum number of rows to fetch from the Dune query. Defaults to 1000.
Returns:
str: A markdown-formatted table of daily graduation rates by platform, or an error message
if the query fails.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
TDQS
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 describes the data source (Dune Analytics query), transformation (pivoting to show graduation rate per day by platform), and output format (markdown table or error message), which covers key behavioral aspects. However, it doesn't mention rate limits, authentication needs, or error handling specifics beyond a generic mention of query failure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and concise, with a clear purpose statement followed by specific details about data source, transformation, parameters, and return values. Every sentence adds value without redundancy, and it's appropriately front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (one optional parameter, no output schema, no annotations), the description provides good completeness. It explains what the tool does, the parameter's purpose, and the return format. However, it could be more complete by addressing potential limitations or edge cases, such as what happens if the Dune query times out or how historical data availability is handled.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for the single parameter 'limit', explaining it controls 'maximum number of rows to fetch from the Dune query' with a default of 1000. Since schema description coverage is 0% (the schema only lists 'limit' as an integer with default 1000 without semantic explanation), the description compensates well by providing clear parameter semantics beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('fetch', 'retrieves') and resources ('daily graduation rate of Solana memecoin launchpads'), distinguishing it from sibling tools like get_daily_active_addresses or get_daily_tokens_deployed by focusing on graduation rates rather than addresses or token deployments.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving graduation rate data from Dune Analytics, but does not explicitly state when to use this tool versus alternatives or provide context on prerequisites. It mentions the data source and transformation, which gives some implied guidance, but lacks explicit when/when-not instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_daily_tokens_deployedA
Retrieve the daily count of tokens deployed by Solana memecoin launchpads.
This tool fetches data from a Dune Analytics query and pivots it to show the number of tokens
deployed per day by each platform. Optionally, it can return the data as percentages of the
total daily deployments.
Args:
return_percent (bool, optional): If True, returns the data as percentages of total daily
deployments for each platform. Defaults to False.
limit (int, optional): Maximum number of rows to fetch from the Dune query. Defaults to 1000.
Returns:
str: A markdown-formatted table of daily token deployments by platform, or an error message
if the query fails.
| Name | Required | Description | Default |
|---|---|---|---|
| return_percent | No | ||
| limit | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and does well by disclosing: data source (Dune Analytics query), transformation (pivoting to show per-platform counts), optional percentage calculation, error handling (returns error message on query failure), and output format (markdown table). It doesn't mention rate limits, authentication needs, or data freshness.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Perfectly structured with purpose statement, implementation details, parameter explanations, and return format - all in 4 focused sentences. Every sentence earns its place with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 2-parameter tool with no annotations and no output schema, the description provides excellent coverage of purpose, parameters, and return format. It could improve by mentioning data freshness, query execution time, or rate limits, but covers the essentials well given the context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by explaining both parameters: 'return_percent' controls percentage vs. absolute value formatting with clear default, and 'limit' specifies maximum rows from the query with default value. The description adds crucial meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('retrieve the daily count'), resource ('tokens deployed by Solana memecoin launchpads'), and data source ('fetches data from a Dune Analytics query'). It distinguishes from siblings by focusing on token deployments rather than addresses, graduates, or graduation rates.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for analyzing token deployment trends and offers an optional percentage format, but doesn't explicitly state when to use this tool versus alternatives or provide context about prerequisites. No sibling tool comparisons or exclusion criteria are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
- First observed
get_daily_active_addresses - First observed
get_daily_graduates - First observed
get_daily_graduation_rate - First observed
get_daily_tokens_deployed
TDQS
Scored across 4 tools
Each tool has a clearly distinct purpose with no overlap: get_daily_active_addresses tracks wallet activity, get_daily_graduates counts successful projects, get_daily_graduation_rate measures success percentages, and get_daily_tokens_deployed monitors token deployments. The descriptions explicitly differentiate these metrics, eliminating any ambiguity.
All tool names follow a consistent verb_noun pattern with 'get_daily_' as a prefix, followed by a specific metric (e.g., active_addresses, graduates). This uniform naming convention makes the tools predictable and easy to understand at a glance.
With 4 tools, the server is well-scoped for its purpose of monitoring Solana memecoin launchpad metrics, though it feels slightly thin. Each tool earns its place by covering distinct aspects of launchpad activity, but additional tools for broader analytics or historical trends could enhance completeness.
The tools cover key daily metrics (activity, graduates, rates, deployments) but lack broader operations like historical trends, platform comparisons, or CRUD functionality for managing data. This creates notable gaps that agents might need to work around, limiting the server's utility for comprehensive analysis.
Maintenance
Related MCP Connectors
MCP server for Renzo protocol data, including chains, vaults, operators, and ezETH metrics.
Solana MCP: Jupiter swaps, SPL transfers, Metaplex NFTs, Bonfida SNS, slot/TPS, staking.
Crypto market intelligence, token rug-checks, and wallet verification in one MCP server.
Unlock the power of real-time cryptocurrency data with our Crypto Price Insights MCP server.
Related MCP Servers
- AlicenseAqualityDmaintenanceAn MCP server that tracks stablecoin peg integrity across multiple blockchains.44MIT
- AlicenseAqualityDmaintenanceAn MCP server that analyzes wallets’ trading activity and profitability on Pump.fun and PumpSwap.41MIT
- AlicenseAqualityDmaintenanceAn MCP server that tracks trading volume metrics segmented by DEX, blockchain, aggregator, frontend, and Telegram bot.101MIT
- AlicenseAqualityDmaintenanceAn MCP server that analyzes cross-chain activity on the Wormhole protocol, providing insights into transaction volumes, top assets, source-destination chain pairs, and key performance indicators (KPIs).7MIT