How to Deploy Remote MCP Servers in Python (Step-by-Step Guide for Custom Self-Hosted MCP Servers)

This article covers how to deploy a remote Model Context Protocol (MCP) server using Python and FastMCP on a Hostinger Virtual Private Server (VPS). By setting up this self-hosted backend, you can connect custom tools—such as search engine optimization (SEO) analyzers—directly to AI clients like Cursor, Claude, or Windsurf to perform advanced development tasks.

Understanding remote MCP servers

A remote Model Context Protocol (MCP) server acts as a lightweight backend layer that responds to structured prompts from AI development interfaces. By building with the FastMCP framework, you can create and deploy portable, Python-based tools that utilize AI-assisted inputs and return structured JSON outputs.

Benefits of using FastMCP on a Hostinger VPS

Using FastMCP on a Hostinger VPS environment provides several distinct advantages for developers:

It eliminates the need for building a custom frontend or user interface (UI).
It allows you to write advanced developer tools entirely in pure Python.
It leverages Docker containers for rapid deployment.
It integrates natively and instantly with major AI clients.
It utilizes Hostinger 1-click deployment templates for streamlined setup.

Hostinger provides an open-source SEO Checker MCP template on GitHub. You can use this repository as a foundational blueprint to launch various custom backends, such as secure sockets layer (SSL) certificate checkers, uptime monitors, or custom data extraction pipelines.

Before you start

Before beginning the deployment process, ensure that you have an active Hostinger VPS hosting plan with root access.

Installing the Ubuntu 24 MCP server template

To configure the pre-built application environment on your virtual server, follow these sequential steps:

Log in to your Hostinger account and navigate to your VPS dashboard.
Access the Operating System settings panel from the left sidebar.
Select and install the Ubuntu 24 with MCP Server template.

Once the installation process completes, the server automated workflow will pull the template repository, build the application container, open network port 8080, and assign a live production URL formatted like the following example:

http://your-seo-app.hstgr.cloud/mcp

Adding the remote server to Cursor

To link your deployed remote backend to your AI client interface, apply the configuration steps below:

Open the Cursor editor application.
Navigate to Settings ❯ Tools & Integrations ❯ MCP Tools.
Click the Add New Tool button.

Input your unique VPS hostname configuration details using the standard JSON structure:

{
  "mcpServers": {
    "seo-checker": {
      "url": "http://your-seo-app.hstgr.cloud:8080/mcp",
      "description": "Professional SEO analysis and optimization recommendations"
    }
  }
}

Restart the Cursor application to load the newly connected remote tool.

Testing the MCP server inside Cursor

Once the configuration is active, you can verify the connectivity and operation of your custom Python backend directly from the chat panel.

Open a new chat window within Cursor.
Enter a natural language request to trigger your tool, using prompts such as:
- Analyze the SEO of example.com.
- Do a quick SEO check on github.com.
- Check the meta tags for blog.mywebsite.com.
- Compare SEO of google.com, bing.com, and duckduckgo.com.

When the remote server finishes processing the data, a comprehensive SEO audit checklist appears directly in the chat interface. The structured textual response details key web optimization metrics, showing specific items like missing meta descriptions, absent H1 headers, and missing image alternative text tags.

Customizing the MCP tool

To expand the default script functionality or implement entirely new backend logic, modify the application core file:

Open your terminal and locate the remote-seo-checker.py file within the project directory.

Define your custom functions and register them using the @Tool decorator:

from fastmcp import Tool, run

@Tool
def custom_hello_world(name: str) -> str:
    return f"Hello, {name}. This is your custom MCP tool!"

run()

Save your file changes and restart the Docker container to reinitialize the process.

The FastMCP framework automatically analyzes your Python parameters and generates the required API schemas without requiring manual route configurations.

Creating new tools using AI

You can leverage large language models to write and expand your server features even faster:

Copy the contents of the baseline remote-seo-checker.py script.
Upload the file to an AI assistant like ChatGPT or Claude.
Provide a clear engineering instruction to generate a brand new plugin using the identical format: “Create a new MCP tool using this format — for example, an SSL certificate checker.”
Insert the newly generated script blocks back into your environment and deploy the file.

Using this prompt-driven development workflow, you can quickly build out multiple administrative utilities:

SSL certificate expiration checkers.
Website uptime monitors.
Live analytics dashboards.
PDF document metadata extractors.
XML sitemap architecture auditors.

Running the server locally for development

If you prefer to debug and test your Python modifications locally before pushing them live to your production Hostinger VPS, use the following sequence:

Clone your project repository to your local computer environment.
Initialize and activate a localized Python virtual environment:
```
python -m venv venv
source venv/bin/activate
```
Install the project dependencies using the package manager file:
```
pip install -r requirements.txt
```
Execute the runtime command to boot up the application process:
```
python remote-seo-checker.py
```

Your local development instance is now fully operational and listening at http://localhost:8080/mcp.

You can now successfully build, expand, and manage scalable, production-grade AI backend features on your Hostinger VPS using pure Python and FastMCP.