ChatGPT Orchestrator MCP Server

A minimal remote MCP server in Python for the following scheme:

ChatGPT -> MCP server -> main orchestrator -> helper agents

At the first stage, the server contains one tool:

• run_orchestrator

• input: goal: string

• output: simple JSON

There is currently a stub inside. Later, it can be replaced with a call to your actual main agent.

Why FastMCP

FastMCP was chosen because it allows you to describe an MCP tool with a regular Python function and immediately launch a remote MCP endpoint via HTTP. To connect to ChatGPT, you need a public HTTPS endpoint like /mcp.

Related MCP server: impart-mcp

Project Structure

.
├── .gitignore
├── server.py
├── requirements.txt
├── Procfile
├── render.yaml
└── README.md

Local Launch

Requirements:

• Python 3.11+

• pip

1. Create a virtual environment

PowerShell:

python -m venv .venv
.\.venv\Scripts\Activate.ps1

If the python command on Windows opens the Microsoft Store or does not show the version, use:

py -3.11 -m venv .venv
.\.venv\Scripts\Activate.ps1

macOS/Linux:

python3 -m venv .venv
source .venv/bin/activate

2. Install dependencies

pip install -r requirements.txt

3. Start the server

python server.py

Local MCP endpoint:

http://localhost:8000/mcp

A standard check that the server is alive:

http://localhost:8000/health

If the client requests an endpoint with a trailing slash, use:

http://localhost:8000/mcp/

Local Verification

Leave python server.py running. In a second terminal, execute:

Invoke-RestMethod http://localhost:8000/health

Expected response:

{
  "status": "ok"
}

Important: if you open http://localhost:8000/mcp in a browser or hit it with a regular curl without MCP headers, you might see an error:

{
  "error": {
    "message": "Not Acceptable: Client must accept text/event-stream"
  }
}

This is normal for an MCP endpoint. Check /health with a regular browser, and check /mcp with an MCP client.

@'
import asyncio
from fastmcp import Client

async def main():
    async with Client("http://localhost:8000/mcp") as client:
        tools = await client.list_tools()
        print("TOOLS:")
        for tool in tools:
            print("-", tool.name)

        result = await client.call_tool(
            "run_orchestrator",
            {"goal": "Create an MVP launch plan"}
        )
        print("RESULT:")
        print(result)

asyncio.run(main())
'@ | python

Expected meaning of the response: the server will show the run_orchestrator tool and return a JSON with text stating that the stub has accepted the task.

You can also check via the MCP Inspector:

npx @modelcontextprotocol/inspector

In the UI, select transport Streamable HTTP and URL:

http://localhost:8000/mcp

Deploy to Render

Option via GitHub

1. Create a new GitHub repository.

2. Upload these files there.

3. Open Render.

4. Click New -> Web Service.

5. Connect the GitHub repository.

6. Render will usually read render.yaml automatically.

7. If configuring manually:

   • Runtime: Python

   • Build Command: pip install -r requirements.txt

   • Start Command: python server.py

8. Click Deploy.

After deployment, Render will provide a URL similar to this:

https://chatgpt-orchestrator-mcp.onrender.com

Production MCP endpoint will be:

https://chatgpt-orchestrator-mcp.onrender.com/mcp

Production health endpoint for browser verification:

https://chatgpt-orchestrator-mcp.onrender.com/health

This is the exact URL you need to insert into ChatGPT.

How to connect to ChatGPT

1. Open ChatGPT in your browser.

2. Go to Settings.

3. Open Apps & Connectors or Connectors.

4. Enable Developer Mode if it is not already enabled:

   • Advanced settings

   • Developer mode

5. Click Create or Create connector.

6. Fill in:

   • Name: Orchestrator

   • Description: Runs my main orchestrator agent through MCP.

   • Connector URL: https://YOUR-RENDER-SERVICE.onrender.com/mcp

7. Save.

8. In a new chat, select this connector/tool and ask ChatGPT to call the orchestrator.

Example test request in ChatGPT

Используй Orchestrator и вызови run_orchestrator с goal:
"Составь пошаговый план запуска MVP моего продукта"

Expected response from the tool now will be approximately:

{
  "status": "ok",
  "message": "Stub orchestrator accepted the goal.",
  "goal": "Составь пошаговый план запуска MVP моего продукта",
  "next_step": "Replace call_real_orchestrator() in server.py with your real agent call."
}

Where to replace the stub with a real agent

Open server.py and find the function:

def call_real_orchestrator(goal: str) -> dict[str, Any]:

Currently, it returns a test JSON. Later, replace its body with the actual call to your main agent.

Example of a future replacement:

def call_real_orchestrator(goal: str) -> dict[str, Any]:
    result = my_main_agent.run(goal)
    return {
        "status": "ok",
        "goal": goal,
        "result": result,
    }

Important: do not create a separate MCP server for each helper agent at the first stage. Let ChatGPT see only one run_orchestrator tool, and let your main agent inside decide which helpers to call.

Final URLs

Locally:

http://localhost:8000/mcp

Production URL template:

https://YOUR-RENDER-SERVICE.onrender.com/mcp

URL for ChatGPT:

https://YOUR-RENDER-SERVICE.onrender.com/mcp

Useful official documents

• OpenAI: https://developers.openai.com/apps-sdk/deploy/connect-chatgpt

• OpenAI: https://developers.openai.com/api/docs/mcp