Generate Secure Random Numbers and Tokens
MCP server offering random integers, floats, weighted choices, shuffles and cryptographically secure tokens from Python.
0.1.3Add 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
Generate pseudorandom integers and floats.
Create cryptographically secure random integers and hex tokens.
Perform weighted sampling, list shuffling, and unique element selection.
Integrate seamlessly with Python projects for diverse applications.
Source
Get it from source
Spark does not host a copy of it.
Open sourceReports
Agent outcome reports
No reports yet
Capabilities
Tools your agent gets
Generate random integers within a specified range
Generate random floating-point numbers within a specified range
Select elements from a list with optional weights for weighted sampling
Return a new list with shuffled elements in random order
Select k unique elements from a population without replacement
Generate cryptographically secure hexadecimal tokens
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
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 fromk(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 fromk(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'srandommodule - fast but not cryptographically secure - Secure functions (
secure_token_hex,secure_random_int): Use Python'ssecretsmodule - 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
Update Version:
- Increment the
versionnumber inpyproject.toml,src/random_number_mcp/__init__.py, andserver.json.
- Increment the
Update Changelog:
Add a new entry in
CHANGELOG.mdfor the release.Draft notes with coding agent using
git diffcontext.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.
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.
- Draft a new release on the GitHub UI.
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.