Skip to main content
By the end of this guide you will have a Python MCP server running on Horizon at a stable, protected URL like https://weather-mcp.fastmcp.app/mcp, ready for any MCP client to call. Horizon builds the server from your GitHub repository, publishes it behind the gateway, and keeps the endpoint live across future pushes. The path is short: point Horizon at a repository and an entrypoint, and each push to your default branch becomes a new build and deployment. You write the MCP server; Horizon owns everything from source to a protected URL.

​
A server to deploy

A Horizon hosted server is a Python FastMCP server in a Git repository. Horizon reads one file, the entrypoint, to start the server and to discover the tools, resources, and prompts it exposes. Anything your entrypoint imports at startup is available to the running server. This is a complete server you can deploy. It exposes a single get_weather tool:
main.py
from fastmcp import FastMCP

mcp = FastMCP("Weather MCP")


@mcp.tool
def get_weather(city: str) -> str:
    """Get current weather for a city."""
    return f"It is always sunny in {city}."


if __name__ == "__main__":
    mcp.run()
Commit this as main.py at the root of a repository. main.py is the entrypoint Horizon looks for by default, so a repository shaped this way needs no extra configuration. To use a different file, or to point at a named server object, configure the entrypoint as server.py or server.py:mcp when you create the server. For how Horizon resolves the entrypoint, Python version, and dependencies, see Build system. The server above has no third-party dependencies beyond FastMCP, which Horizon installs for you. When your server imports other packages, commit a requirements.txt or pyproject.toml and Horizon installs them during the build. For configuring secrets and settings your code needs at runtime, see Environment variables.

​
Deploy on Horizon

1

Sign in and create an organization

Sign in at horizon.prefect.io. On first sign-in you create an organization, which owns your servers, members, and access settings. Every server you deploy belongs to one organization.
2

Connect GitHub and choose a repository

Horizon builds from source in GitHub, so the first step is linking a GitHub installation. Authorize the Horizon GitHub App and grant it access to the repositories you want to deploy. The repository picker then lists those repositories with their default branch. Select the one holding your server. For how the GitHub connection works and what each event triggers, see GitHub.
3

Configure the server

Name the server, then confirm the entrypoint. The name determines the deployment URL, previewed as {name}.fastmcp.app while you type. Leave the entrypoint as main.py for the server above, or point it at your file. Optionally set a dependency file and environment variables. New servers have Horizon authentication enabled by default, so the endpoint starts behind an access check.
4

Watch the first build

When you create the server, Horizon resolves your default branch to an exact commit, installs dependencies, packages the server, and inspects it with FastMCP to discover its tools, resources, and prompts. Build logs show each step. A build is tied to the commit it resolved, so moving the branch afterward does not change that build.
5

The server goes live

A successful build produces an artifact, and Horizon deploys it to your server’s stable URL. The Deployments page shows the live URL and status. From here, every push to the default branch creates a new build and, when it succeeds, updates the live deployment.

​
Confirm it is live

Open the server’s Deployments page. The stable production URL sits at the top, ending in /mcp, and the status reads Live once the first deployment is serving. This URL stays constant as you push new versions; Horizon changes the artifact behind it through promotion and rollback without asking clients to reconfigure. Because Horizon authentication is enabled, callers authenticate before a request reaches your code. The gateway verifies the caller, checks access, and only then forwards the request to your Python handler. To make a server public or to let your own code own authentication, disable Horizon authentication, described in Authentication. With the server live, you are ready to point an MCP client at it. Connect a client walks through configuring Claude, Cursor, ChatGPT, and the CLI clients against your new endpoint.