Skip to main content
Glama
random-web3-mcp
by suxiongye

RandomWeb3MCP - Servicio de generación de elementos aleatorios Web3

RandomWeb3MCP es un servicio de generación de elementos aleatorios basado en el hash de bloque EVM. Ofrece diversas herramientas de generación de elementos aleatorios que pueden utilizarse en juegos, finanzas, pruebas y otros campos.

Características

  • Verificabilidad : Todos los números aleatorios se generan en función del hash de la cadena de bloques, lo que garantiza la imparcialidad y la verificabilidad.

  • Diversidad : admite varios escenarios de generación de números aleatorios, desde números aleatorios básicos hasta distribuciones de probabilidad complejas.

  • Confiabilidad : utiliza blockchain como fuente de entropía para garantizar la calidad de la aleatoriedad.

  • Usabilidad : Proporciona interfaces API simples e intuitivas para una fácil integración.

Related MCP server: Random Value MCP Server

Instalación

git clone git@github.com:suxiongye/random-web3-mcp.git
pip install -e .

Inicio rápido

Configuración en tico o Cursor

Agregue la configuración del servicio random-web3-mcp en la configuración del cursor:

{
  "mcpServers": {
    "random-web3-mcp": {
      "command": "uv",
      "args": ["--directory", "local_repo_directory/zxl-mcp-server", "run", "main.py"]
    }
  }
}

Lista de herramientas

generar_aleatorio_básico

Nombre

Generador básico de números aleatorios

Función

Generar un entero aleatorio dentro del rango especificado

Parámetros

  • min_value (int, opcional): Valor mínimo (inclusive). El valor predeterminado es 0.

  • max_value (int, opcional): Valor máximo (inclusive). El valor predeterminado es 1000000.

  • sal (str, opcional): Valor de sal de número aleatorio para mayor aleatoriedad. El valor predeterminado es ''

Devoluciones

Cadena JSON que contiene el resultado del número aleatorio

Escenarios de aplicación

  1. Sistemas de lotería

  2. Juego de números aleatorios

  3. Generación de identificación aleatoria

  4. Generación de datos de prueba

generar_matriz_aleatoria

Nombre

Generador de matrices aleatorias

Función

Generar una matriz aleatoria de longitud especificada

Parámetros

  • array_length (int, opcional): Longitud del array. El valor predeterminado es 1.

  • min_value (int, opcional): Valor mínimo. El valor predeterminado es 0.

  • max_value (int, opcional): Valor máximo. El valor predeterminado es 1000000.

  • salt (str, opcional): Valor de sal de número aleatorio. El valor predeterminado es ''

Devoluciones

Cadena JSON que contiene la matriz aleatoria

Escenarios de aplicación

  1. Generación de números aleatorios por lotes

  2. Muestreo aleatorio

  3. Generación de conjuntos de datos de prueba

  4. Asignación de tareas aleatorias

generar_ponderado_aleatorio

Nombre

Selector aleatorio ponderado

Función

Seleccione aleatoriamente una opción en función de los pesos

Parámetros

  • opciones (Lista[str]): Lista de opciones

  • pesos (List[int]): Lista de pesos correspondiente (0-1000)

  • salt (str, opcional): Valor de sal de número aleatorio. El valor predeterminado es ''

Devoluciones

Cadena JSON que contiene el resultado de la selección

Escenarios de aplicación

  1. Sistemas de lotería (premios con diferentes probabilidades)

  2. Gotas aleatorias (gotas de artículos ponderados)

  3. Asignación de tareas (según prioridad)

  4. Pruebas A/B (grupos experimentales con diferentes proporciones)

generar_característica_aleatoria

Nombre

Asignador aleatorio de funciones

Función

Genera un conjunto de valores de características aleatorios para los objetos, cada uno dentro de su rango especificado. Los valores de las características se codifican en un mapa de bits, donde cada característica ocupa 8 bits.

Parámetros

  • feature_count (int): Número de características a generar

  • feature_max_values (List[int]): Lista de valores máximos para cada característica, la longitud debe ser igual a feature_count

  • sal (str, opcional): Valor de sal de número aleatorio para mayor aleatoriedad. El valor predeterminado es ''

Devoluciones

Cadena JSON que contiene valores de características y mapas de bits, formateados como:

{
    "requestId": "Generated request ID",
    "features": [List of feature values],
    "featureBitmap": Feature bitmap value
}

Escenarios de aplicación

  1. Generación de atributos de personajes del juego (fuerza, agilidad, inteligencia, etc.)

  2. Aleatorización de atributos de equipo (ataque, defensa, velocidad, etc.)

  3. Simulación de rasgos biológicos (genes, rasgos, etc.)

  4. Generación aleatoria de escenas (terreno, clima, entorno, etc.)

generar_distribución

Nombre

Generador aleatorio de distribución de probabilidad

Función

Genera números aleatorios según el tipo de distribución de probabilidad y los parámetros especificados. Admite diversas distribuciones de probabilidad comunes.

Parámetros

  • tipo_distribución (int): Tipo de distribución:

    • 1 = Distribución uniforme (parámetros: [valor mínimo, valor máximo])

    • 2 = Distribución normal (parámetros: [media, desviación estándar])

    • 3 = Distribución exponencial (parámetros: [scale_parameter])

    • 4 = Distribución binomial (parámetros: [ensayos, probabilidad de éxito])

  • distribución_parámetros (Lista[flotante]): Lista de parámetros de distribución

  • sal (str, opcional): Valor de sal de número aleatorio para mayor aleatoriedad. El valor predeterminado es ''

Devoluciones

Cadena JSON que contiene información de distribución y valor aleatorio, con el siguiente formato:

{
    "requestId": "Generated request ID",
    "randomValue": Generated random value,
    "distributionMetadata": {
        "distributionType": Distribution type,
        ...Distribution parameters
    }
}

Escenarios de aplicación

  1. Simulación del mercado financiero (distribución de rentabilidad, análisis de riesgos)

  2. Simulación de fenómenos naturales (distribución de partículas, generación de ruido)

  3. Pruebas de carga (distribución del comportamiento del usuario)

  4. Muestreo estadístico (generación de datos experimentales)

generar_evento_aleatorio

Nombre

Desencadenante de evento aleatorio

Función

Activa una serie de eventos según las probabilidades dadas. Cada evento tiene una probabilidad de activación independiente. Utiliza un mapa de bits para registrar el estado de activación y facilitar su procesamiento.

Parámetros

  • event_count (int): Número total de eventos

  • event_probabilities (List[int]): Probabilidad de activación para cada evento (0-1000, que representa el 0-100%)

  • sal (str, opcional): Valor de sal de número aleatorio para mayor aleatoriedad. El valor predeterminado es ''

Devoluciones

Cadena JSON que contiene los resultados de activación de eventos, con el siguiente formato:

{
    "requestId": "Generated request ID",
    "triggeredEvents": Event trigger bitmap,
    "eventResults": [
        {
            "eventId": Event ID,
            "probability": Trigger probability,
            "triggered": Whether triggered,
            "randomValue": Random value
        },
        ...
    ]
}

Escenarios de aplicación

  1. Eventos aleatorios del juego (trama desencadenante, elementos que caen)

  2. Determinación del efecto de probabilidad (activación de habilidad, determinación de combo)

  3. Simulación de eventos de riesgo (predicción de fallas, eventos de accidentes)

  4. Determinación de múltiples condiciones (eventos de probabilidad combinados)

generar semilla aleatoria

Nombre

Generador de semillas aleatorias

Función

Genera una semilla aleatoria de alta entropía para cifrado u otros escenarios que requieren números aleatorios de alta calidad. Utiliza el hash de la cadena de bloques como fuente de entropía para garantizar la aleatoriedad.

Parámetros

  • seed_length (int): Longitud de la semilla a generar (en bytes)

  • sal (str, opcional): Valor de sal de número aleatorio para mayor aleatoriedad. El valor predeterminado es ''

Devoluciones

Cadena JSON que contiene una semilla aleatoria, formateada como:

{
    "requestId": "Generated request ID",
    "randomSeed": "Random seed in hexadecimal format",
    "entropy": Estimated entropy value
}

Escenarios de aplicación

  1. Generación de claves (claves de cifrado, semillas de firma)

  2. Tokens de seguridad (identificadores de sesión, tokens de autenticación)

  3. Inicialización de números aleatorios (semillas PRNG, estados iniciales de simulación)

  4. Generación de identificadores únicos (semillas UUID, identificadores aleatorios)

matriz aleatoria

Nombre

Mezclador de matrices aleatorias

Función

Baraja aleatoriamente la matriz de entrada, garantizando que cada elemento tenga la misma probabilidad de aparecer en cualquier posición. Utiliza el algoritmo de barajado de Fisher-Yates para garantizar la imparcialidad.

Parámetros

  • input_array (Lista): Matriz que se va a barajar, los elementos pueden ser de cualquier tipo

  • sal (str, opcional): Valor de sal de número aleatorio para mayor aleatoriedad. El valor predeterminado es ''

Devoluciones

Cadena JSON que contiene la matriz mezclada, formateada como:

{
    "requestId": "Generated request ID",
    "shuffledArray": [Shuffled array]
}

Escenarios de aplicación

  1. Barajado de juegos (cartas de juego, fichas de mahjong)

  2. Orden aleatorio (orden de preguntas, lista de reproducción)

  3. Agrupación aleatoria (asignación de equipo, agrupación de experimentos)

  4. Mezcla de datos (conjunto de datos de entrenamiento, casos de prueba)

generar_coordenadas

Nombre

Generador de coordenadas aleatorias

Función

Genera puntos de coordenadas aleatorios en un espacio dimensional específico. Cada dimensión tiene su propio rango de valores. Admite la generación de coordenadas en cualquier número de dimensiones.

Parámetros

  • dimensiones (int): Número de dimensiones de coordenadas (1D, 2D, 3D, etc.)

  • min_values (List[float]): Lista de valores mínimos para cada dimensión

  • max_values (List[float]): Lista de valores máximos para cada dimensión

  • coordinate_count (int): Número de puntos de coordenadas a generar

  • sal (str, opcional): Valor de sal de número aleatorio para mayor aleatoriedad. El valor predeterminado es ''

Devoluciones

Cadena JSON que contiene coordenadas aleatorias, formateada como:

{
    "requestId": "Generated request ID",
    "coordinates": [
        [x1, y1, z1, ...],  # First point coordinates
        [x2, y2, z2, ...],  # Second point coordinates
        ...
    ]
}

Escenarios de aplicación

  1. Posicionamiento de objetos del juego (ubicación de NPC, distribución de elementos)

  2. Sistemas de partículas (generación de efectos, distribución de partículas)

  3. Generación de mapas (altura del terreno, distribución de recursos)

  4. Muestreo espacial (modelado 3D, análisis espacial)

generar_rareza

Nombre

Asignador aleatorio de rarezas

Función

Genera puntos de coordenadas aleatorios en un espacio dimensional específico. Cada dimensión tiene su propio rango de valores. Admite la generación de coordenadas en cualquier número de dimensiones.

Parámetros

  • item_count: Cantidad del proyecto

  • rarity_tiers: Matriz de niveles de rareza

  • rarity_percentages: Porcentaje de probabilidad para cada nivel de rareza

  • Guaranteed_minimums: Cantidad garantizada para cada nivel de rareza (opcional)

  • sal (str, opcional): Valor de sal de número aleatorio para mayor aleatoriedad. El valor predeterminado es ''

Devoluciones

Cadena JSON que contiene una matriz de rareza aleatoria, formateada como:

{
    "requestId": "Generated request ID",
    "rarityDistribution": [Rarity allocation result]
}

Escenarios de aplicación

  1. Obtención de objetos del juego (equipos y objetos de diferente rareza)

  2. Sistemas de lotería (premios con diferentes probabilidades)

  3. Asignación de recursos (recursos de diferente rareza, materiales)

  4. Desencadenante de eventos aleatorios (eventos de diferente probabilidad)

Escenarios de aplicación

Desarrollo de juegos

  • Objetos que caen al azar

  • Generación de atributos de caracteres

  • Generación aleatoria de mapas

  • Desencadenante de evento de probabilidad

Aplicación financiera

  • Simulación de riesgos

  • Análisis de cartera de inversiones

  • Simulación del comportamiento del mercado

Datos de prueba

  • Generación aleatoria de casos de prueba

  • Datos de prueba de carga

  • Muestra de prueba de rendimiento

Cálculo científico

  • Simulación de Monte Carlo

  • Simulación de sistemas de partículas

  • Muestreo aleatorio

Notas

  1. Toda generación de números aleatorios depende del hash de la cadena de bloques de Trust Chain; asegúrese de que la conexión a la red sea normal.

  2. El rango de valores de peso del selector aleatorio ponderado es de 0 a 1000, lo que representa una probabilidad del 0 al 100 %.

  3. Los parámetros de distribución de probabilidad deben proporcionar una lista de parámetros correcta según el tipo de distribución específico

  4. Se recomienda utilizar el parámetro de sal en el entorno de producción para aumentar la aleatoriedad.

Manejo de errores

El servicio puede devolver los siguientes tipos de error:

{
    "error": "Error message",
    "code": "Error code",
    "requestId": "Request ID"
}

Códigos de error comunes:

  • INVALID_PARAMS : Error de parámetro

  • NETWORK_ERROR : Error de conexión de red

  • CHAIN_ERROR : Error de acceso a la cadena de bloques

  • INTERNAL_ERROR : Error de servicio interno

Consideración del rendimiento

  • Cada solicitud de generación de números aleatorios necesita acceder a la cadena de bloques, lo que puede tener un cierto retraso.

  • Se recomienda almacenar en caché los números aleatorios utilizados con frecuencia

  • Preste atención a la frecuencia de las solicitudes cuando maneje una gran cantidad de solicitudes simultáneas

Guía de contribuciones

Te invitamos a enviar un problema y una solicitud de extracción para ayudar a mejorar este proyecto. Antes de enviar, asegúrate de lo siguiente:

  1. El código se ajusta a la especificación PEP 8

  2. Se agregan casos de prueba apropiados

  3. Se actualizan los documentos relacionados

Licencia

Este proyecto utiliza la licencia MIT. Consulte el archivo de licencia para más detalles.

Available Tools

10 tools
generate_basic_randomA

Basic Random Number Generator

Generate a random integer within the specified range

Args:
    salt (str, optional): Random number salt value for increased randomness. Defaults to "".
    min_value (int, optional): Minimum value (inclusive). Defaults to 0.
    max_value (int, optional): Maximum value (inclusive). Defaults to 1000000.

Returns:
    str: JSON string containing the random number result

Application Scenarios:
1. Lottery systems
2. Game random numbers
3. Random ID generation
4. Test data generation

Inputs: max_value, min_value, salt.

generate_coordinateA

Random Coordinate Generator

Generate random coordinate points in a specified dimensional space, each dimension has its own value range.
Supports coordinate generation in any number of dimensions.

Args:
    dimensions (int): Number of coordinate dimensions (1D, 2D, 3D, etc.)
    min_values (List[float]): List of minimum values for each dimension
    max_values (List[float]): List of maximum values for each dimension
    coordinate_count (int): Number of coordinate points to generate
    salt (str, optional): Random number salt value for increased randomness. Defaults to "".

Returns:
    str: JSON string containing random coordinates, formatted as:
    {
        "requestId": "Generated request ID",
        "coordinates": [
            [x1, y1, z1, ...],  # First point coordinates
            [x2, y2, z2, ...],  # Second point coordinates
            ...
        ]
    }

Application Scenarios:
1. Game object positioning (NPC locations, item distribution)
2. Particle systems (effect generation, particle distribution)
3. Map generation (terrain height, resource distribution)
4. Spatial sampling (3D modeling, spatial analysis)

Inputs: coordinate_count (required), dimensions (required), max_values (required), min_values (required), +1 more.

generate_distributionA

Probability Distribution Random Generator

Generate random numbers according to specified probability distribution type and parameters.
Supports various common probability distributions.

Args:
    distribution_type (int): Distribution type:
        1 = Uniform distribution (parameters: [min_value, max_value])
        2 = Normal distribution (parameters: [mean, standard_deviation])
        3 = Exponential distribution (parameters: [scale_parameter])
        4 = Binomial distribution (parameters: [trials, success_probability])
    distribution_parameters (List[float]): Distribution parameter list
    salt (str, optional): Random number salt value for increased randomness. Defaults to "".

Returns:
    str: JSON string containing random value and distribution information, formatted as:
    {
        "requestId": "Generated request ID",
        "randomValue": Generated random value,
        "distributionMetadata": {
            "distributionType": Distribution type,
            ...Distribution parameters
        }
    }

Application Scenarios:
1. Financial market simulation (return distribution, risk analysis)
2. Natural phenomena simulation (particle distribution, noise generation)
3. Load testing (user behavior distribution)
4. Statistical sampling (experimental data generation)

Inputs: distribution_parameters (required), distribution_type (required), salt.

generate_random_arrayA

Random Array Generator

Generate a random array of specified length

Args:
    salt (str, optional): Random number salt value. Defaults to "".
    array_length (int, optional): Array length. Defaults to 1.
    min_value (int, optional): Minimum value. Defaults to 0.
    max_value (int, optional): Maximum value. Defaults to 1000000.
    allow_duplicates (bool, optional): Allow duplicate values. Defaults to True.

Returns:
    str: JSON string containing the random array

Application Scenarios:
1. Batch random number generation
2. Random sampling
3. Test dataset generation
4. Random task assignment

Inputs: allow_duplicates, array_length, max_value, min_value, +1 more.

generate_random_eventA

Random Event Trigger

Trigger a series of events based on given probabilities, each event has an independent trigger probability.
Uses bitmap to record trigger status for easy processing.

Args:
    event_count (int): Total number of events
    event_probabilities (List[int]): Trigger probability for each event (0-1000, representing 0-100%)
    salt (str, optional): Random number salt value for increased randomness. Defaults to "".

Returns:
    str: JSON string containing event trigger results, formatted as:
    {
        "requestId": "Generated request ID",
        "triggeredEvents": Event trigger bitmap,
        "eventResults": [
            {
                "eventId": Event ID,
                "probability": Trigger probability,
                "triggered": Whether triggered,
                "randomValue": Random value
            },
            ...
        ]
    }

Application Scenarios:
1. Game random events (trigger plot, drop items)
2. Probability effect determination (skill trigger, combo determination)
3. Risk event simulation (fault prediction, accident events)
4. Multiple condition determination (combined probability events)

Inputs: event_count (required), event_probabilities (required), salt.

generate_random_featureA

Random Feature Allocator

Generate a set of random feature values for objects, each feature value within its specified range.
Feature values are encoded into a bitmap, with each feature occupying 8 bits.

Args:
    feature_count (int): Number of features to generate
    feature_max_values (List[int]): List of maximum values for each feature, length must equal feature_count
    salt (str, optional): Random number salt value for increased randomness. Defaults to "".

Returns:
    str: JSON string containing feature values and bitmap, formatted as:
    {
        "requestId": "Generated request ID",
        "features": [List of feature values],
        "featureBitmap": Feature bitmap value
    }

Application Scenarios:
1. Game character attribute generation (strength, agility, intelligence, etc.)
2. Equipment attribute randomization (attack, defense, speed, etc.)
3. Biological trait simulation (genes, traits, etc.)
4. Random scene generation (terrain, weather, environment, etc.)

Inputs: feature_count (required), feature_max_values (required), salt.

generate_random_seedA

Random Seed Generator

Generate high-entropy random seed for encryption or other scenarios requiring high-quality random numbers.
Uses blockchain hash as entropy source to ensure randomness.

Args:
    seed_length (int): Length of seed to generate (in bytes)
    salt (str, optional): Random number salt value for increased randomness. Defaults to "".

Returns:
    str: JSON string containing random seed, formatted as:
    {
        "requestId": "Generated request ID",
        "randomSeed": "Random seed in hexadecimal format",
        "entropy": Estimated entropy value
    }

Application Scenarios:
1. Key generation (encryption keys, signature seeds)
2. Security tokens (session identifiers, authentication tokens)
3. Random number initialization (PRNG seeds, simulation initial states)
4. Unique identifier generation (UUID seeds, random identifiers)

Inputs: seed_length (required), salt.

generate_random_weightedA

Weighted Random Selector

Randomly select an option based on weights

Args:
    options (List[str]): List of options
    weights (List[int]): Corresponding weight list (0-1000)
    salt (str, optional): Random number salt value. Defaults to "".

Returns:
    str: JSON string containing the selection result

Application Scenarios:
1. Lottery systems (prizes with different probabilities)
2. Random drops (weighted item drops)
3. Task assignment (based on priority)
4. A/B testing (experiment groups with different ratios)

Inputs: options (required), weights (required), salt.

generate_rarityC

Rarity Distributor Args: item_count: Number of items rarity_tiers: Array of rarity tiers rarity_percentages: Probability percentage for each rarity tier guaranteed_minimums: Minimum guaranteed count for each rarity tier (optional) salt: Additional entropy source

Inputs: item_count (required), rarity_percentages (required), rarity_tiers (required), guaranteed_minimums, +1 more.

shuffle_arrayA

Random Array Shuffler

Randomly shuffle the input array, ensuring each element has an equal probability of appearing in any position.
Uses Fisher-Yates shuffle algorithm to ensure fairness.

Args:
    input_array (List): Array to be shuffled, elements can be of any type
    salt (str, optional): Random number salt value for increased randomness. Defaults to "".

Returns:
    str: JSON string containing the shuffled array, formatted as:
    {
        "requestId": "Generated request ID",
        "shuffledArray": [Shuffled array]
    }

Application Scenarios:
1. Game shuffling (playing cards, mahjong tiles)
2. Random ordering (question order, playlist)
3. Random grouping (team assignment, experiment grouping)
4. Data shuffling (training dataset, test cases)

Inputs: input_array (required), salt.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.6/5.0

    Scored across 10 tools

    Disambiguation3/5

    The tools have overlapping purposes in random generation, with multiple tools generating random numbers or arrays (e.g., generate_basic_random, generate_random_array, generate_distribution). However, descriptions clarify distinctions like coordinate generation, distribution types, or weighted selection, helping agents differentiate between them. Some ambiguity remains, such as between generate_random_array and shuffle_array for array manipulation.

    Naming Consistency5/5

    All tool names follow a consistent snake_case pattern with a clear 'generate_' or 'shuffle_' prefix, making them predictable and readable. The naming convention is uniform across all tools, with no mixing of styles or deviations, which aids in easy identification and usage.

    Tool Count4/5

    With 10 tools, the count is reasonable for a random generation server, covering various aspects like basic numbers, coordinates, distributions, and shuffling. It's slightly heavy but well-scoped, as each tool addresses a specific niche in random generation without being excessive for the domain.

    Completeness4/5

    The toolset covers a broad range of random generation scenarios, including numbers, arrays, distributions, events, and seeds, with no obvious gaps for core functionalities. Minor gaps might include lack of tools for random string generation or more advanced statistical distributions, but the existing set supports most common use cases effectively.

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Production-ready MCP server that provides LLMs with essential random generation abilities, including random integers, floats, choices, shuffling, and cryptographically secure tokens.
      7
      156 PyPI
      50
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      Generates random integers within a specified range and random alphanumeric strings of specified length through MCP protocol integration.
      2
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      An encrypted and secure random number generation server that complies with the MCP protocol, suitable for AI applications, LLMS, and other systems that require high-quality random numbers.
      7
      2
      Apache 2.0
    • A
      license
      A
      quality
      D
      maintenance
      MCP server providing true randomness capabilities to Claude, enabling cryptographically secure random number generation for games, decision-making, sampling, simulations, and any operation requiring genuine randomness.
      13
      2
      MIT