hetzner-mcp

🚀 Hetzner MCP Server

License

Hetzner Logo

Disclaimer: This project is not affiliated with or endorsed by Hetzner. The Hetzner logo is used solely to visually associate this repository with Hetzner Cloud services.

A next-generation Model Context Protocol (MCP) server for Hetzner Cloud, providing seamless, programmatic access to the entire Hetzner API via the official hcloud-python SDK.

✨ Key Features

Total Hetzner API Coverage: Instantly access any Hetzner Cloud resource or action—servers, images, firewalls, networks, volumes, SSH keys, and more—using the official SDK. No manual endpoint mapping required.
Dynamic, Discoverable Tooling:
- call_hetzner: Run any SDK call as a string, with robust error handling and structured results.
- hetzner_help: Instantly discover all available SDK resources, methods, signatures, and documentation—perfect for LLMs, agents, and power users.
- echo: Simple echo for connectivity and round-trip testing.
- mcp_health: Health check endpoint for automation and monitoring.
Agent/LLM Ready: Designed for AI agents, automation, and scripting. All tools are introspectable and return structured, machine-friendly responses.
Secure, Constrained Execution: All calls are sandboxed to the SDK context. No secrets are baked into the image; credentials are injected at runtime.

🔒 Security & Considerations

Arbitrary Code Execution: This MCP allows arbitrary Python code execution via the call_hetzner tool, due to limitations of the Hetzner SDK and the need for full SDK flexibility. Any code using the client object can be executed, including list comprehensions, attribute access, and more.
Run Only in Isolated Environments: You should only run this MCP server inside a Docker container or a similarly isolated environment. Do not expose it to untrusted networks or users.
Risk Awareness: Running this server gives any connected agent or LLM the ability to execute arbitrary code in the container. This is a significant risk, but is similar to the risk you already accept when using agentic AI assistants with code execution capabilities (such as built-in tools that can run code in your console).
No Secrets in Image: The Docker image does not contain any credentials or secrets. The Hetzner API token is injected at runtime via .env or environment variable.
Full API Access: Any SDK call (including destructive actions) is permitted. Users and agents have full control over your Hetzner account via the API token. Always protect your .env file and API token.

Environment Variables & VS Code Integration

Prerequisites

Docker must be installed: Get Docker

1. Configure Your `.env` File

Copy the provided example:
```
 cp .env.example .env
```
Open .env and paste your Hetzner API token:
```
 HETZNER_API_TOKEN=your_hetzner_api_token_here
```
Never commit your real .env file to version control!

Need a token? See the Hetzner docs:
👉 How to generate your Hetzner API Token

2. Integrate with VS Code

To enable agent/LLM workflows in VS Code:

Create a .vscode folder in your workspace if it doesn’t exist.
Create or edit the file .vscode/mcp.json and add the following configuration:

{
	"servers": {
		"hetzner-mcp": {
			"command": "docker",
			"args": [
				"run",
				"-i",
				"--rm",
				"-v",
				"${workspaceFolder}/.env:/app/.env:ro",
				"betancourtosmar/hetzner-mcp"
			]
		}
	}
}

This will allow you to launch the MCP server with your credentials for agent-driven workflows.

🐍 Local Development (No Docker Needed)

Install dependencies:
```
  pip install -r requirements.txt
```
Ensure your .env file is present and contains your Hetzner API token.
Run the server:
```
  python src/main.py
```

🛠️ Available Tools

Tool	Description
`call_hetzner`	Execute any Hetzner SDK call as a string, e.g. `client.servers.get_all()`
`hetzner_help`	List all SDK resources, methods, signatures, and docstrings for full discoverability
`echo`	Echo back any text (for testing)
`mcp_health`	Health check endpoint

💡 Example Usage

List all servers:

call_hetzner("client.servers.get_all()")

Create a server:

call_hetzner("client.servers.create(name='my-server', server_type='cx11', image='ubuntu-20.04')")

Delete a server:

call_hetzner("client.servers.delete(server)")

List all images:

call_hetzner("client.images.get_all()")

Discover all possible actions:

hetzner_help()

🌐 What Can You Do?

Instantly list, create, update, and delete any Hetzner Cloud resource.
Perform advanced actions: reboot, power on/off, attach/detach resources, assign floating IPs, manage firewalls, and more.
Programmatically discover all SDK capabilities and method signatures.
Integrate with LLMs, agents, or automation tools for full cloud control.

❓ FAQ

Q: Can I run this MCP outside Docker?

A: You can, but it is strongly discouraged. Running outside Docker gives the agent/LLM a wildcard to execute any Python code on your real machine—just like agentic Copilot or Cursor. The main difference is that the MCP provides explicit instructions and helpers for the Hetzner SDK, making it easier for the LLM to automate cloud operations. For safety, always use Docker or another isolated environment.

Q: What is the value of the MCP tools?

A: The MCP tools (like call_hetzner and hetzner_help) provide structured, discoverable interfaces and documentation for the Hetzner SDK. This abstracts the SDK logic from the user and makes it much easier for LLMs and agents to use the full power of Hetzner Cloud without manual setup or research.

📝 License

This project is licensed under the MIT License. See LICENSE for details.

📬 Support / Contact

For questions, feedback, or support, contact: oaba.dev@gmail.com

Made with ❤️ for Hetzner Cloud automation.
Ready for the future of cloud operations.

The best part: This MCP always uses the latest version of the Hetzner Python SDK.
Every new feature released by Hetzner is instantly available here—no manual updates required!

This site is open source. Improve this page.