MCP Connector

Generate Secure Random Numbers and Tokens

Generate random integers, floats, weighted choices, shuffles, and cryptographically secure tokens - built on Python's stdlib.

Works with github

88
Spark score
out of 100
Updated 2 months ago
Source checked Sep 19, 2026
Version 0.1.3
Models
universal

Add to Favorites

Why it matters

Leverage Python's standard library for robust random number generation, including pseudorandom and cryptographically secure options for integers, floats, sampling, and token creation.

Outcomes

What it gets done

01

Generate pseudorandom integers and floats.

02

Create cryptographically secure random integers and hex tokens.

03

Perform weighted sampling, list shuffling, and unique element selection.

04

Integrate seamlessly with Python projects for diverse applications.

Source

Get it from source

Spark does not host a copy of it.

Open source

Reports

Agent outcome reports

No reports yet

Capabilities

Tools your agent gets

random_int

Generate random integers within a specified range

random_float

Generate random floating-point numbers within a specified range

random_choices

Select elements from a list with optional weights for weighted sampling

random_shuffle

Return a new list with shuffled elements in random order

random_sample

Select k unique elements from a population without replacement

secure_token_hex

Generate cryptographically secure hexadecimal tokens

secure_random_int

Generate cryptographically secure random integers

Overview

Random Number MCP Server

Random Number MCP Server provides Python stdlib-based random generation - pseudorandom integers, floats, weighted choices, and shuffles via the random module, plus cryptographically secure tokens and integers via the secrets module. Use pseudorandom tools for simulations and games; use secure_token_hex/secure_random_int instead whenever the output needs to resist prediction, such as tokens or codes.

What it does

Random Number MCP Server provides random number generation utilities from Python's standard library, covering both fast pseudorandom operations (integers, floats, weighted sampling, list shuffling) and cryptographically secure operations (secure tokens, secure random integers).

When to use - and when NOT to

Use pseudorandom tools (random_int, random_float, random_choices, random_shuffle, random_sample) for simulations, games, or any non-security-sensitive randomness need - they're fast but not cryptographically safe. Use the secure tools (secure_token_hex, secure_random_int) instead whenever the output needs to resist prediction - session tokens, password reset codes, or other security-critical values - since they're built on Python's secrets module rather than random. Do not use the pseudorandom tools for anything security-sensitive; they explicitly are not cryptographically secure.

Capabilities

  • random_int: generate a random integer within a range.
  • random_float: generate a random floating-point number within a range.
  • random_choices: pick items from a list, with optional weights.
  • random_shuffle: return a new list with elements shuffled.
  • random_sample: pick k unique elements from a population without replacement.
  • secure_token_hex: generate a cryptographically secure hex token.
  • secure_random_int: generate a cryptographically secure random integer.

How to install

uvx random-number-mcp

Configure Claude Desktop:

{
  "mcpServers": {
    "random-number": {
      "command": "uvx",
      "args": ["random-number-mcp"]
    }
  }
}

For local development: git clone https://github.com/example/random-number-mcp && cd random-number-mcp && uv sync --dev, then debug with npx @modelcontextprotocol/inspector uv run random-number-mcp. Requires Python 3.10+ and the uv package manager.

Who it's for

Developers who need an AI assistant to generate random values for simulations, games, sampling, or security-sensitive tokens, choosing the right tool (pseudorandom vs. cryptographically secure) for the use case.

Source README

Random Number MCP

Essential random number generation utilities from the Python standard library, including pseudorandom and cryptographically secure operations for integers, floats, weighted selections, list shuffling, and secure token generation.

Looking for the agent skill version? random-number-skills implements the same random number generation strategy as an agent skill instead of an MCP server.

Demo Video

https://github.com/user-attachments/assets/303a441a-2b10-47e3-b2a5-c8b51840e362

Random Number MCP server

Tools

Tool Purpose Python function
random_int Generate random integers random.randint()
random_float Generate random floats random.uniform()
random_choices Choose items from a list (optional weights) random.choices()
random_shuffle Return a new list with items shuffled random.sample()
random_sample Choose k unique items from population random.sample()
secure_token_hex Generate cryptographically secure hex tokens secrets.token_hex()
secure_random_int Generate cryptographically secure integers secrets.randbelow()

Setup

Claude Desktop

Add this to your Claude Desktop configuration file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "random-number": {
      "command": "uvx",
      "args": ["random-number-mcp"]
    }
  }
}

Tool Reference

random_int

Generate a random integer between low and high (inclusive).

Parameters:

  • low (int): Lower bound (inclusive)
  • high (int): Upper bound (inclusive)

Example:

{
  "name": "random_int",
  "arguments": {
    "low": 1,
    "high": 100
  }
}

random_float

Generate a random float between low and high.

Parameters:

  • low (float, optional): Lower bound (default: 0.0)
  • high (float, optional): Upper bound (default: 1.0)

Example:

{
  "name": "random_float",
  "arguments": {
    "low": 0.5,
    "high": 2.5
  }
}

random_choices

Choose k items from a population with replacement, optionally weighted.

Parameters:

  • population (list): List of items to choose from
  • k (int, optional): Number of items to choose (default: 1)
  • weights (list, optional): Weights for each item (default: equal weights)

Example:

{
  "name": "random_choices",
  "arguments": {
    "population": ["red", "blue", "green", "yellow"],
    "k": 2,
    "weights": [0.4, 0.3, 0.2, 0.1]
  }
}

random_shuffle

Return a new list with items in random order.

Parameters:

  • items (list): List of items to shuffle

Example:

{
  "name": "random_shuffle",
  "arguments": {
    "items": [1, 2, 3, 4, 5]
  }
}

random_sample

Choose k unique items from population without replacement.

Parameters:

  • population (list): List of items to choose from
  • k (int): Number of items to choose

Example:

{
  "name": "random_sample",
  "arguments": {
    "population": ["a", "b", "c", "d", "e"],
    "k": 2
  }
}

secure_token_hex

Generate a cryptographically secure random hex token.

Parameters:

  • nbytes (int, optional): Number of random bytes (default: 32)

Example:

{
  "name": "secure_token_hex",
  "arguments": {
    "nbytes": 16
  }
}

secure_random_int

Generate a cryptographically secure random integer below upper_bound.

Parameters:

  • upper_bound (int): Upper bound (exclusive)

Example:

{
  "name": "secure_random_int",
  "arguments": {
    "upper_bound": 1000
  }
}

Security Considerations

This package provides both standard pseudorandom functions (suitable for simulations, games, etc.) and cryptographically secure functions (suitable for tokens, keys, etc.):

  • Standard functions (random_int, random_float, random_choices, random_shuffle): Use Python's random module - fast but not cryptographically secure
  • Secure functions (secure_token_hex, secure_random_int): Use Python's secrets module - slower but cryptographically secure

Development

Prerequisites

  • Python 3.10+
  • uv package manager

Setup

# Clone the repository
git clone https://github.com/example/random-number-mcp
cd random-number-mcp

# Install dependencies
uv sync --dev

# Run tests
uv run pytest

# Run linting
uv run ruff check --fix
uv run ruff format

# Type checking
uv run mypy src/

MCP Client Config

{
  "mcpServers": {
    "random-number-dev": {
      "command": "uv",
      "args": [
        "--directory",
        "<path_to_your_repo>/random-number-mcp",
        "run",
        "random-number-mcp"
      ]
    }
  }
}

Note: Replace <path_to_your_repo>/random-number-mcp with the absolute path to your cloned repository.

Building

# Build package
uv build

# Test installation
uv run --with dist/*.whl random-number-mcp

Release Checklist

  1. Update Version:

    • Increment the version number in pyproject.toml, src/random_number_mcp/__init__.py, and server.json.
  2. Update Changelog:

    • Add a new entry in CHANGELOG.md for the release.

      • Draft notes with coding agent using git diff context.
      Update the @CHANGELOG.md for the latest release.
      List all significant changes, bug fixes, and new features.
      Here's the git diff:
      [GIT_DIFF]
      
    • Commit along with any other pending changes.

  3. Create GitHub Release:

    • Draft a new release on the GitHub UI.
      • Tag release using UI.
    • The GitHub workflow will automatically build and publish the package to PyPI.

Testing with MCP Inspector

For exploring and/or developing this server, use the MCP Inspector npm utility:

# Install MCP Inspector
npm install -g @modelcontextprotocol/inspector

# Run local development server with the inspector
npx @modelcontextprotocol/inspector uv run random-number-mcp

# Run PyPI production server with the inspector
npx @modelcontextprotocol/inspector uvx random-number-mcp

MCP Registry

mcp-name: io.github.zazencodes/random-number-mcp

FAQ

Common questions

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.