MCP Connector

Generate Secure Random Numbers and Tokens

MCP server offering random integers, floats, weighted choices, shuffles and cryptographically secure tokens from Python.

Works with github

88
Spark score
out of 100
Updated 3 months ago
Source checked Oct 10, 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

Exposes seven random number tools from the Python standard library. Standard tools use the random module, while secure tools use the secrets module for tokens and keys. Use for simulations, games, sampling and shuffling, or secure tokens. Choose the secure tools for anything security related.

What it does

Random Number MCP exposes random number generation utilities from the Python standard library to an MCP client. It covers pseudorandom and cryptographically secure operations for integers, floats, weighted selections, list shuffling and secure token generation. The project also mentions an agent skill version, random-number-skills, which implements the same random number generation strategy as a skill instead of an MCP server.

When to use - and when NOT to

Use it when a model needs real random values instead of numbers it makes up itself: picking a die roll or a number in a range, drawing weighted or unweighted items from a list, shuffling a list, sampling unique items, or generating a hex token or secure integer.

The package draws a clear line between two families of tools. The standard functions (random_int, random_float, random_choices, random_shuffle) use Python's random module, which is fast but not cryptographically secure, and are suited to simulations and games. The secure functions (secure_token_hex, secure_random_int) use Python's secrets module, which is slower but cryptographically secure, and are suited to tokens and keys. Do not use the standard tools for keys or tokens. If you prefer an agent skill over an MCP server, it points to the separate random-number-skills project.

Capabilities

The server provides seven tools, each mapped to a Python function:

  • random_int generates a random integer between low and high, both inclusive, using random.randint().
  • random_float generates a random float between low and high, with optional bounds that default to 0.0 and 1.0, using random.uniform().
  • random_choices chooses k items from a population with replacement, optionally weighted. The parameters are population, an optional k that defaults to 1, and optional weights that default to equal weights. It uses random.choices().
  • random_shuffle returns a new list with the given items in random order, and is implemented with random.sample().
  • random_sample chooses k unique items from a population without replacement, using random.sample().
  • secure_token_hex generates a cryptographically secure hex token from nbytes random bytes, with a default of 32, using secrets.token_hex().
  • secure_random_int generates a cryptographically secure integer below an exclusive upper_bound, using secrets.randbelow().

Every tool is called with named arguments, for example random_int with low 1 and high 100, or random_choices with a population of four colors, k of 2 and weights of 0.4, 0.3, 0.2 and 0.1.

How to install

Add the server to your Claude Desktop configuration file. On macOS that file is at ~/Library/Application Support/Claude/claude_desktop_config.json, and on Windows it is at %APPDATA%/Claude/claude_desktop_config.json.

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

For development, the project requires Python 3.10 or newer and the uv package manager. It uses uv for dependency sync, pytest for tests, ruff for linting and formatting, and mypy for type checking. A development client configuration runs the server with uv from a local checkout, where you replace the placeholder path with the absolute path to your cloned repository. To explore the tools interactively, the MCP Inspector npm utility can run against either the local development server or the published PyPI package. Releases are published to PyPI by a GitHub workflow when a GitHub release is created, and the server is registered in the MCP Registry under io.github.zazencodes/random-number-mcp.

Who it's for

Developers and agent builders who want a small, dependable source of randomness inside an MCP-enabled assistant, from game and simulation logic to generating secure tokens. The project is MIT licensed.

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.