APAC MCP and AI Gateway Guide 2026: FastMCP, MCP Inspector, and Portkey

Why APAC AI Teams Need MCP Infrastructure and LLM Gateways

APAC AI teams building production AI systems face two integration problems simultaneously: exposing internal APAC data and tools to AI assistants (solved by MCP), and managing reliable, cost-efficient LLM API routing across multiple providers (solved by AI gateways). These two layers are complementary — MCP standardizes how AI assistants connect to tools; AI gateways standardize how AI applications connect to LLM providers.

Three tools cover this APAC infrastructure stack:

FastMCP — Python framework for building Model Context Protocol servers with decorator-based tool and resource definitions.

MCP Inspector — Official Anthropic interactive web UI for debugging and validating MCP servers during development.

Portkey — AI gateway providing multi-model LLM routing, automatic fallbacks, semantic caching, and cost observability for APAC production applications.

Model Context Protocol: APAC Infrastructure Layer

Without MCP (fragmented APAC integration):
  Claude Desktop → proprietary plugin format
  Cursor         → proprietary tool format
  AutoGen        → custom function calling
  → Each APAC AI client = separate integration effort

With MCP (standardized APAC integration):
  FastMCP server exposes APAC tools once
  → Claude Desktop connects  (stdio)
  → Claude Code connects     (stdio)
  → Cursor connects          (stdio)
  → Any MCP client connects  (stdio / SSE / HTTP)
  → APAC team builds once, connects everywhere

FastMCP: APAC MCP Server Development

FastMCP APAC basic server

# APAC: FastMCP — decorator-based MCP server

from fastmcp import FastMCP

apac_mcp = FastMCP("APAC Business Tools")

@apac_mcp.tool()
def search_apac_customers(
    query: str,
    market: str = "sg",
    limit: int = 10
) -> list[dict]:
    """Search APAC CRM for customers matching query in specified market."""
    # APAC: Real implementation queries internal CRM API
    apac_results = internal_crm.search(
        query=query,
        market=market,
        limit=limit
    )
    return [
        {
            "customer_id": r.id,
            "company_name": r.name,
            "market": r.market,
            "contract_value_usd": r.contract_value,
        }
        for r in apac_results
    ]

@apac_mcp.resource("apac://reports/{report_type}")
def get_apac_report(report_type: str) -> str:
    """Expose APAC business reports as MCP resources."""
    apac_report = report_store.get(report_type)
    return apac_report.content

@apac_mcp.prompt()
def apac_market_analysis_prompt(market: str, quarter: str) -> str:
    """Reusable APAC market analysis prompt template."""
    return f"""Analyze the {market.upper()} market performance for {quarter}.
    Use the search_apac_customers tool to find top accounts,
    then retrieve the apac://reports/quarterly-summary resource.
    Focus on: revenue trends, churn risk, expansion opportunities."""

if __name__ == "__main__":
    apac_mcp.run()
    # Claude Desktop: add to claude_desktop_config.json
    # Claude Code: use as MCP server via --mcp-server flag

FastMCP APAC multi-transport configuration

# APAC: FastMCP — stdio vs SSE transport configuration

from fastmcp import FastMCP
from fastmcp.server import Settings

# APAC: Local Claude Desktop (stdio transport)
apac_local_mcp = FastMCP(
    "APAC Local Tools",
    settings=Settings(transport="stdio")
)

# APAC: Remote team access (SSE transport)
apac_remote_mcp = FastMCP(
    "APAC Team Server",
    settings=Settings(
        transport="sse",
        host="0.0.0.0",
        port=8080,
        # APAC: Authentication for enterprise deployment
        auth_token=os.environ["APAC_MCP_AUTH_TOKEN"],
    )
)

# APAC: Claude Desktop config for local stdio MCP
# ~/.config/Claude/claude_desktop_config.json
apac_claude_config = {
    "mcpServers": {
        "apac-business-tools": {
            "command": "python",
            "args": ["/apac/mcp-server/server.py"],
            "env": {
                "APAC_CRM_API_KEY": "...",
                "APAC_MARKET": "sg"
            }
        }
    }
}

FastMCP APAC server composition

# APAC: FastMCP server composition — multiple servers into one

from fastmcp import FastMCP

# APAC: Separate MCP servers per domain
apac_crm_mcp = FastMCP("APAC CRM")
apac_finance_mcp = FastMCP("APAC Finance")
apac_hr_mcp = FastMCP("APAC HR")

# APAC: Add tools to each domain server
@apac_crm_mcp.tool()
def get_apac_customer(customer_id: str) -> dict: ...

@apac_finance_mcp.tool()
def get_apac_invoice(invoice_id: str) -> dict: ...

@apac_hr_mcp.tool()
def get_apac_employee(employee_id: str) -> dict: ...

# APAC: Compose into unified MCP server for Claude
apac_unified_mcp = FastMCP("APAC Enterprise Suite")
apac_unified_mcp.mount(apac_crm_mcp, prefix="crm")
apac_unified_mcp.mount(apac_finance_mcp, prefix="finance")
apac_unified_mcp.mount(apac_hr_mcp, prefix="hr")

# APAC: Claude sees: crm_get_apac_customer, finance_get_apac_invoice, hr_get_apac_employee
# One MCP server connection → all APAC enterprise tools
apac_unified_mcp.run()

MCP Inspector: APAC Development Debugging

Connecting MCP Inspector to an APAC server

# APAC: MCP Inspector — connect to local FastMCP server

# Install
npx @modelcontextprotocol/inspector

# APAC: Connect via stdio (same as Claude Desktop)
npx @modelcontextprotocol/inspector python /apac/mcp-server/server.py

# APAC: Connect via SSE (remote APAC server)
npx @modelcontextprotocol/inspector --sse http://apac-server:8080/sse

# APAC: Inspector opens browser UI at http://localhost:5173
# → Tools panel: all APAC tools with JSON schemas
# → Resources panel: all APAC resource URIs
# → Prompts panel: all APAC prompt templates

MCP Inspector APAC debugging workflow

APAC MCP Debugging Pattern:

1. SCHEMA VALIDATION
   Inspector → Tools panel → search_apac_customers
   Check: parameter names, types, descriptions, required fields
   Common APAC issue: missing "market" parameter description
   → Claude won't know to pass "sg"/"hk"/"jp" without it

2. MANUAL EXECUTION
   Inspector → Execute tab → search_apac_customers
   Input: {"query": "technology", "market": "sg", "limit": 5}
   Check: returns valid JSON, no Python exceptions, under 30s

3. ERROR REPRODUCTION
   APAC Claude reports: "tool returned error: connection timeout"
   Inspector → Execute → same parameters → reveals: APAC CRM API
   requires VPN — Claude has no VPN → architectural issue caught early

4. RESPONSE VALIDATION
   Inspector shows raw APAC server response + timing
   Confirms: Claude receives same data Inspector shows
   No need to add Claude to debug loop for each APAC test

APAC Rule: Debug with Inspector until clean → then connect Claude

Portkey: APAC LLM Gateway for Production

Portkey APAC basic configuration

# APAC: Portkey — one-line LLM gateway integration

from openai import OpenAI

# APAC: Original — direct OpenAI call
apac_client_original = OpenAI(api_key="APAC_OPENAI_KEY")

# APAC: Portkey — same SDK, route through gateway
apac_client_portkey = OpenAI(
    api_key="APAC_OPENAI_KEY",
    base_url="https://api.portkey.ai/v1",
    default_headers={
        "x-portkey-api-key": os.environ["PORTKEY_API_KEY"],
        "x-portkey-provider": "openai",
        # APAC: Tag for cost attribution
        "x-portkey-metadata": '{"user_segment": "apac_enterprise", "market": "sg"}',
    }
)

# APAC: All existing code works unchanged — Portkey intercepts transparently
apac_response = apac_client_portkey.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Summarize APAC market conditions"}]
)

Portkey APAC multi-provider fallback

# APAC: Portkey — automatic fallback across LLM providers

import portkey_ai as portkey

# APAC: Configure fallback routing
apac_config = portkey.Config(
    strategy={"mode": "fallback"},
    targets=[
        # APAC: Primary: OpenAI
        {
            "provider": "openai",
            "api_key": os.environ["OPENAI_API_KEY"],
            "override_params": {"model": "gpt-4o"}
        },
        # APAC: Fallback 1: Anthropic (if OpenAI 429/503)
        {
            "provider": "anthropic",
            "api_key": os.environ["ANTHROPIC_API_KEY"],
            "override_params": {"model": "claude-sonnet-4-6"}
        },
        # APAC: Fallback 2: Azure OpenAI (regional APAC endpoint)
        {
            "provider": "azure-openai",
            "api_key": os.environ["AZURE_OPENAI_KEY"],
            "resource_name": "apac-openai-sg",
            "deployment_id": "gpt-4o-apac",
            "api_version": "2024-02-01",
        }
    ]
)

apac_portkey = portkey.Portkey(
    api_key=os.environ["PORTKEY_API_KEY"],
    config=apac_config
)

# APAC: Request automatically routes: OpenAI → Anthropic → Azure
# If OpenAI returns 429 or 503, Portkey retries Anthropic silently
apac_response = apac_portkey.chat.completions.create(
    messages=[{"role": "user", "content": "APAC regulatory summary"}]
)

Portkey APAC prompt management

# APAC: Portkey prompt versioning — deploy without code changes

from portkey_ai import Portkey

apac_portkey = Portkey(api_key=os.environ["PORTKEY_API_KEY"])

# APAC: Call versioned prompt by ID (managed in Portkey dashboard)
# Version history: v1 (baseline) → v2 (added APAC market context) → v3 (current)
apac_response = apac_portkey.prompts.completions.create(
    prompt_id="apac-customer-summary-v3",
    variables={
        "customer_name": "APAC Corp Pte Ltd",
        "market": "Singapore",
        "contract_value": "USD 85,000",
    }
)

# APAC: A/B test prompt variants (50/50 split)
apac_ab_config = {
    "strategy": {"mode": "loadbalance"},
    "targets": [
        {"prompt_id": "apac-prompt-variant-a", "weight": 0.5},
        {"prompt_id": "apac-prompt-variant-b", "weight": 0.5},
    ]
}
# Portkey tracks which variant each APAC response came from
# Dashboard: compare output quality, cost, latency by variant

APAC MCP + Gateway Integration

APAC Production AI Architecture:

User / AI Assistant
        ↓
  Portkey Gateway          ← LLM provider routing, caching, cost
        ↓
  LLM (OpenAI/Anthropic)
        ↓
  FastMCP Server           ← APAC tool and resource definitions
        ↓
  Internal APAC Systems    ← CRM, ERP, databases, APIs

Development Debug Flow:
  MCP Inspector → FastMCP  (validate schemas before connecting Claude)
  Portkey Dashboard        (track costs after connecting Claude)

APAC Use Case                   → Tool Stack
---
APAC Claude Desktop + CRM       → FastMCP (expose CRM tools) + Claude
APAC MCP server schema issues   → MCP Inspector (debug before prod)
APAC high-volume LLM app        → Portkey (routing + cost control)
APAC provider outage resilience → Portkey fallback chains
APAC Claude + internal tools    → FastMCP → Portkey → OpenAI/Claude

Related APAC AI Infrastructure Resources

For the AI agent frameworks (AutoGen, PydanticAI, smolagents) that call FastMCP tools as part of multi-agent APAC workflows, see the APAC AI agent frameworks guide.

For the LLM serving frameworks (vLLM, Ollama, LiteLLM) that Portkey routes requests to for self-hosted APAC LLM deployments, see the APAC LLM inference guide.

For the browser automation tools (Stagehand, browser-use) that use LLM APIs routed through Portkey for APAC web agent workflows, see the APAC browser automation guide.