Random Number MCP
The Random Number MCP server provides both standard pseudorandom and cryptographically secure random generation capabilities, built on Python's standard library:
Generate random integers: Get a random number within a specified inclusive range using
random_intGenerate random floats: Get a random decimal number within a range (defaults to 0.0-1.0) using
random_floatChoose random items: Select items from a list with optional weights using
random_choicesShuffle items: Return a list with items in random order using
random_shuffleCreate secure hex tokens: Generate cryptographically secure random hex tokens using
secure_token_hexGenerate secure random integers: Get cryptographically secure random integers below a specified upper bound using
secure_random_int
The server distinguishes between fast pseudorandom functions for general use cases and more secure functions for security-sensitive applications.
Leverages Python's standard library (random and secrets modules) to provide both standard pseudorandom functions and cryptographically secure random generation capabilities.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Random Number MCP generate a random integer between 1 and 100"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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
Related MCP server: Random-Generator
Tools
Tool | Purpose | Python function |
| Generate random integers |
|
| Generate random floats |
|
| Choose items from a list (optional weights) |
|
| Return a new list with items shuffled |
|
| Choose k unique items from population |
|
| Generate cryptographically secure hex tokens |
|
| Generate cryptographically secure integers |
|
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 secureSecure 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-mcpRelease Checklist
Update Version:
Increment the
versionnumber inpyproject.toml,src/random_number_mcp/__init__.py, andserver.json.
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.
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-mcpMCP Registry
mcp-name: io.github.zazencodes/random-number-mcp
License
MIT License - see LICENSE file for details.
Available Tools
7 toolsrandom_choicesA
Choose k items from population with replacement, optionally weighted.
Args: population: List of items to choose from k: Number of items to choose (default 1) weights: Optional weights for each item (default None for equal weights)
Returns: List of k chosen items
Inputs: population (required), k, weights. Returns: Generic wrapper for non-object return types.
random_floatA
Generate a random float between low and high.
Args: low: Lower bound (default 0.0) high: Upper bound (default 1.0)
Returns: Random float between low and high
Inputs: low, high. Returns: Generic wrapper for non-object return types.
random_intB
Generate a random integer between low and high (inclusive).
Args: low: Lower bound (inclusive) high: Upper bound (inclusive)
Returns: Random integer between low and high
Inputs: low (required), high (required). Returns: Generic wrapper for non-object return types.
random_sampleA
Choose k unique items from population without replacement.
Args: population: List of items to choose from k: Number of items to choose
Returns: List of k unique chosen items
Inputs: population (required), k (required). Returns: Generic wrapper for non-object return types.
random_shuffleA
Return a new list with items in random order.
Args: items: List of items to shuffle
Returns: New list with items in random order
Inputs: items (required). Returns: Generic wrapper for non-object return types.
secure_random_intA
Generate a secure random integer below upper_bound.
Args: upper_bound: Upper bound (exclusive)
Returns: Random integer in range [0, upper_bound)
Inputs: upper_bound (required). Returns: Generic wrapper for non-object return types.
secure_token_hexA
Generate a secure random hex token.
Args: nbytes: Number of random bytes to generate (default 32)
Returns: Hex string containing 2*nbytes characters
Inputs: nbytes. Returns: Generic wrapper for non-object return types.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 7 tools
Most tools have clearly distinct purposes: integer, float, secure integer, token, sample, shuffle, and choices. There is mild overlap between random_int and secure_random_int, but the inclusive/exclusive bounds and cryptographic distinction in descriptions help disambiguate them.
Naming follows a mostly consistent snake_case pattern with random_* for general operations and secure_* for cryptographic variants. The only minor inconsistency is secure_random_int breaking the random_* prefix pattern, but the naming remains predictable and readable.
Seven tools is well-scoped for a random number utility server. Each tool addresses a distinct common random-generation need without unnecessary redundancy or bloat.
The server covers the core random number domain well: integers, floats, secure randomness, sampling, shuffling, and weighted choices. Minor gaps such as random boolean generation or non-uniform distributions exist but are not essential for the stated purpose.
Maintenance
Related MCP Connectors
Hosted MCP server for LLM cost estimation, model comparison, and budget-aware routing.
MCP server providing access to the Scorecard API to evaluate and optimize LLM systems.
MCP server for building and testing AI agents with multi-model experimentation and insights.
MCP server for OpenAI API (chat completions, image generation, embeddings) via AceDataCloud
Related MCP Servers
- MIT
- AlicenseAqualityDmaintenanceAn 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.72Apache 2.0
- AlicenseAqualityDmaintenanceMCP 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.132MIT
- FlicenseNot gradedqualityDmaintenanceA Model Context Protocol (MCP) server that provides random dice rolling capabilities for AI assistants.-