ChatGPT Setup

Pick your flavour

Three integration paths, depending on whether you're a developer, an end user, or building production agents.

See it in action

If you've never set up MCP or a Custom GPT before, these official walkthroughs from OpenAI show what the experience looks like. PMI works the same way.

Option A: OpenAI Responses API

OpenAI's Responses API supports MCP servers natively. Direct connection, same URL, same Bearer token, same 28 tools. This is the recommended path for developers.

from openai import OpenAI

client = OpenAI()  # OPENAI_API_KEY from env

response = client.responses.create(
    model="gpt-4.1",
    tools=[{
        "type": "mcp",
        "server_label": "pmi",
        "server_url": "https://pmi-api-beta-7tvvt.ondigitalocean.app/mcp",
        "headers": {
            "Authorization": "Bearer pmi_live_YOUR_KEY_HERE"
        },
        # Don't require approval for each call, let the model run end-to-end
        "require_approval": "never"
    }],
    input="What's the rental yield in LS6, and is the area growing in demand?",
)

print(response.output_text)

Restricting which tools the model sees

By default the model sees all 28 tools. To narrow it down (e.g. only valuation tools for a valuation-only chatbot):

"allowed_tools": ["pmi_valuation_sale", "pmi_valuation_rental", "pmi_valuation_hmo"]

Add this inside the MCP tool config block. Reduces token cost and stops the model wandering into unrelated tools.

Approval flows for expensive tools

For interactive UIs where the user should confirm expensive calls (the STR estimate is 50 credits a pop):

"require_approval": "always"

The model returns control after every tool call so you can show a “Confirm spending 50 credits on STR estimate?” prompt. For server-side agents, leave it "never".

Option B: Custom GPT in ChatGPT

ChatGPT (the consumer product, including ChatGPT Plus, Team, and Enterprise) supports custom integrations through Actions. Actions use OpenAPI specs, not MCP, so we point your Custom GPT at the REST API directly.

This works well for end users who want to chat with their property data. They don't need to know what MCP is.

https://pmi-api-beta-7tvvt.ondigitalocean.app/v1/openapi.json

You are a property market intelligence assistant for the UK. You have direct
access to the Property Market Intel API for live data.

When the user asks anything about a UK property or area:
1. If they give an address, first call POST /addresses/match to resolve to a UPRN.
2. Use UPRN-based endpoints (/valuations/{uprn}/sale, /risks/{uprn}, etc.) for
   property-specific questions.
3. Use location-based endpoints (/prices/market, /rents/yields, /str/market)
   for area questions. Accept postcode, outcode, lat+lng+radius_m, or polygon.
4. Always quote the median (not mean) when discussing prices and rents, it's
   more robust to outliers.
5. Currency is always GBP. Cite confidence levels when the API provides them.
6. If the API returns a 402 (credits exhausted), tell the user politely.
7. Never guess data, if you don't have a tool that answers something, say so.

For SA revenue projections, use POST /valuations/str-estimate with the
property's UPRN or postcode + bedrooms.

Option C: OpenAI Agents SDK

If you're building with the Agents SDK (Python or TypeScript), MCP is first-class. Same URL, same headers.

Python

from agents import Agent
from agents.mcp import MCPServerStreamableHttp

pmi = MCPServerStreamableHttp(
    url="https://pmi-api-beta-7tvvt.ondigitalocean.app/mcp",
    headers={"Authorization": "Bearer pmi_live_YOUR_KEY_HERE"},
)

agent = Agent(
    name="PropertyAnalyst",
    instructions="You are a UK property market analyst. Use PMI tools.",
    mcp_servers=[pmi],
)

result = await agent.run("Compare STR vs long-let yields for SW1.")
print(result.final_output)

TypeScript

import { Agent } from "@openai/agents";
import { MCPServerStreamableHttp } from "@openai/agents-mcp";

const pmi = new MCPServerStreamableHttp({
  url: "https://pmi-api-beta-7tvvt.ondigitalocean.app/mcp",
  headers: { Authorization: "Bearer pmi_live_YOUR_KEY_HERE" },
});

const agent = new Agent({
  name: "PropertyAnalyst",
  instructions: "You are a UK property market analyst. Use PMI tools.",
  mcpServers: [pmi],
});

const result = await agent.run("Compare STR vs long-let yields for SW1.");
console.log(result.finalOutput);

Which one should I pick?

Best practices

• Use sub-keys, not your master key. One per integration. Cap each one’s monthly credits.
• Filter tool exposure, when the agent's purpose is narrow. A pure rental-yield bot doesn't need access to pmi_planning_applications.
• For public-facing Custom GPTs, gate via require_approval on the expensive tools (pmi_str_revenue_estimate is 50 credits, can drain a key fast).
• Server-side proxy for browser apps. Never put pmi_live_… in client-side JavaScript. Build a thin endpoint on your backend that talks to OpenAI with PMI keys living in env vars.
• Cache responses by UPRN, for 24h+ in your own layer. Most user-flow patterns re-request the same property within a session.

Troubleshooting