Skip to main content
Glama
kukapay

solana-launchpads-mcp

get_daily_active_addresses

Track daily active wallet counts for Solana memecoin launchpads to monitor platform engagement and user activity trends.

Instructions

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.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
limitNo

Implementation Reference

  • main.py:125-148 (handler)
    The primary handler function for the 'get_daily_active_addresses' tool. Decorated with @mcp.tool() for automatic registration in FastMCP. Fetches data from Dune query 5002622, pivots daily active wallets by platform using pandas, sorts descending by date, and returns markdown table or error.
    @mcp.tool()
    def get_daily_active_addresses(limit: int = 1000) -> str:
        """
        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.
        """
        try:
            data = get_latest_result(5002622, limit=limit)
            df = pd.DataFrame(data)
            df['date_time'] = pd.to_datetime(df['date_time']).dt.date
            pivot_df = df.pivot(index="date_time", columns="platform", values="daily_active_wallets")
            pivot_df = pivot_df.sort_index(ascending=False)
            return pivot_df.to_markdown()
        except Exception as e:
            return str(e)
  • main.py:21-43 (helper)
    Helper utility function called by the handler (and other tools) to retrieve the latest results from a Dune Analytics query using the configured API key and base URL.
    def get_latest_result(query_id: int, limit: int = 1000) -> list:
        """
        Fetch the latest results from a Dune Analytics query.
    
        Args:
            query_id (int): The ID of the Dune query to fetch results from.
            limit (int, optional): Maximum number of rows to return. Defaults to 1000.
    
        Returns:
            list: A list of dictionaries containing the query results, or an empty list if the request fails.
    
        Raises:
            httpx.HTTPStatusError: If the API request fails due to a client or server error.
        """
        url = f"{BASE_URL}/query/{query_id}/results"
        params = {"limit": limit}
        with httpx.Client() as client:
            response = client.get(url, params=params, headers=HEADERS, timeout=300)
            response.raise_for_status()
            data = response.json()
            
        result_data = data.get("result", {}).get("rows", [])
        return result_data
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (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.

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 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.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('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.

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 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.

Install Server

Other Tools

Latest Blog Posts

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/kukapay/solana-launchpads-mcp'

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