> ## Documentation Index
> Fetch the complete documentation index at: https://docs.horizon.prefect.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Overview

> What Horizon is, how it hosts FastMCP servers, and the core concepts - projects, deployments, and server types.

Horizon is the production platform for MCP servers from the team behind FastMCP,
the framework that has become the default way developers build MCP servers. It
gives teams a place to deploy the servers they build, secure every request
through a gateway, connect the servers they already operate, and understand what
agents and clients are doing in production.

FastMCP helped make MCP server development feel like ordinary Python
development. Horizon applies the same practical approach to production
operations: packaging servers, giving them stable endpoints, enforcing access,
preserving MCP session routing, recording logs and metrics, and making approved
servers discoverable to the rest of your organization.

<CardGroup cols={2}>
  <Card title="Deploy from code" icon="rocket" href="/quickstart">
    Link a repository, build a Python MCP or FastMCP server, and publish a live
    endpoint for MCP clients.
  </Card>

  <Card title="Secure every request" icon="shield-check" href="/gateway">
    Authenticate callers, enforce access, preserve sessions, and record request
    metadata before traffic reaches server code.
  </Card>

  <Card title="Observe behavior" icon="chart-line" href="/observability">
    Inspect requests, server logs, clients, users, builds, and usage patterns
    from one place.
  </Card>

  <Card title="Connect existing servers" icon="plug" href="/servers/external">
    Register remote MCP servers alongside hosted servers so teams can manage
    access from the same Horizon surface.
  </Card>

  <Card title="Publish a registry" icon="globe" href="/mcp-registry">
    Give GitHub Copilot and other registry clients one organization catalog for
    discovering production MCP servers.
  </Card>
</CardGroup>

## Why Horizon exists

FastMCP made MCP servers easy to build. That changed the bottleneck. When teams
can create useful servers quickly, the next question is how to share them safely:
a remote endpoint clients can reach, a catalog where people can find approved
servers, and access controls that match how work actually happens.

Some tools should be available to everyone. Some should only be available to
engineering, finance, or an on-call team. Some servers should be visible across
the organization, while individual tools remain restricted to the people who
need them. Horizon exists for that second phase of MCP adoption: turning
individually useful servers into shared, governed infrastructure.

Local servers are good for development. Shared servers need a lifecycle: builds,
deployment URLs, previews, rollbacks, environment variables, authentication,
authorization, logs, metrics, and a clear owner. Horizon brings that lifecycle to
MCP without asking every team to rebuild the same platform around each server.

## What is an MCP gateway?

An MCP gateway sits between MCP clients and MCP servers. Instead of every client
connecting directly to every server, the gateway receives requests first and
handles shared platform concerns such as routing, authentication, authorization,
session handling, and logging.

In Horizon, every MCP request to a deployed server passes through the gateway
before it reaches your code. That is where Horizon identifies the deployment,
applies the server's authentication mode, checks authorization, preserves MCP
session routing, and records request metadata for logs and analytics.

This matters because MCP access is not only a deployment problem. It is a policy
surface. Teams need to decide who can discover a server, who can call it, who can
manage it, and which tools a caller should be allowed to use. Horizon puts those
decisions in the request path, so every server does not need to reimplement its
own authentication, RBAC, logging, and session behavior.

<CardGroup cols={2}>
  <Card title="Authentication" icon="key" href="/platform/authentication">
    Choose how callers prove identity when they connect to deployed MCP servers.
    Horizon authentication is enabled by default so new hosted endpoints start
    behind an access check.
  </Card>

  <Card title="Authorization" icon="shield" href="/platform/authorization">
    Use organization roles, server access, custom server roles, and tool-level
    access to control what authenticated callers can do.
  </Card>

  <Card title="Request logs" icon="list" href="/observability#request-logs">
    See which client called which deployment, how the request was routed, and
    whether the gateway accepted or rejected it.
  </Card>

  <Card title="Gateway" icon="route" href="/gateway">
    Learn the full request path from deployment lookup through access checks,
    session routing, and server forwarding.
  </Card>
</CardGroup>

## What you can build

Horizon supports three server patterns.

<CardGroup cols={2}>
  <Card title="Hosted servers" icon="server" href="/servers/hosted">
    Build and run Python MCP or FastMCP servers from source code managed in a
    Git repository.
  </Card>

  <Card title="External servers" icon="link" href="/servers/external">
    Register MCP servers that run outside Horizon and manage their access through
    Horizon.
  </Card>

  <Card title="Remix servers" icon="sliders" href="/servers/remix">
    Combine selected capabilities from multiple servers into one scoped MCP
    endpoint.
  </Card>
</CardGroup>

| Server type | Best for                                                                                     | Who runs the code                 |
| ----------- | -------------------------------------------------------------------------------------------- | --------------------------------- |
| Hosted      | The fastest path when you want Horizon to package, deploy, serve, and observe your MCP code. | Horizon.                          |
| External    | Systems that already have their own runtime.                                                 | You, outside Horizon.             |
| Remix       | Shaping the exact set of capabilities a team or agent should see.                            | The upstream servers you combine. |

## How a hosted server works

<Steps>
  <Step title="Write or choose a server">
    Start with a Python MCP or FastMCP server. The server exposes tools,
    resources, or prompts that MCP clients can call.
  </Step>

  <Step title="Link the repository">
    Connect the Git repository that contains the server. Horizon uses the
    repository to create builds and deployment artifacts.
  </Step>

  <Step title="Deploy an artifact">
    A successful build becomes a deployable artifact. Deployments provide stable
    URLs, preview environments, promotion, and rollback.
  </Step>

  <Step title="Connect a client">
    MCP clients call the Horizon deployment URL. Horizon handles routing,
    authentication, authorization, sessions, and request observability before
    traffic reaches your server.
  </Step>
</Steps>

## Core concepts

<CardGroup cols={2}>
  <Card title="Builds" icon="hammer" href="/platform/build-system">
    Builds turn repository source into deployable server artifacts. Build logs
    explain dependency installation, entrypoint detection, inspection, and
    packaging failures.
  </Card>

  <Card title="Deployments" icon="cloud-arrow-up" href="/deployments">
    Deployments decide which artifact serves traffic. Use them to promote,
    preview, and roll back server versions.
  </Card>

  <Card title="Gateway" icon="route" href="/gateway">
    The gateway receives MCP traffic, identifies the deployment, enforces access,
    preserves session routing, and forwards supported requests.
  </Card>

  <Card title="Compute model" icon="memory" href="/platform/compute-model">
    The compute model explains startup, request handling, timeouts, memory,
    environment variables, local state, and logs.
  </Card>

  <Card title="Authentication" icon="key" href="/platform/authentication">
    Authentication determines how callers prove identity when they connect to
    Horizon, the REST API, or deployed MCP servers.
  </Card>

  <Card title="Authorization" icon="shield" href="/platform/authorization">
    Authorization determines what authenticated callers can do at the
    organization, server, and tool level.
  </Card>
</CardGroup>

## Start here

If you want the shortest path to a working server, start with
[Quickstart](/quickstart), then [connect a client](/connect-a-client). If you are
planning a production rollout, read [Gateway](/gateway),
[Build system](/platform/build-system), and
[Compute model](/platform/compute-model) before you depend on a server in a
critical workflow.