交互式地图服务

                                    Azure
 +-----------------------------------------------------------------+
 |                                                                 |
 |   Azure Container Apps              Azure Static Web App        |
 |  +---------------------------+    +-------------------------+   |
 |  | TomTom MCP Server         |    | Interactive Map App     |   |
 |  | (Orbis Maps backend)      |    | (TomTom Maps SDK +      |   |
 |  |                           |    |  MapLibre GL JS)        |   |
 |  | Image: ghcr.io/tomtom-    |    |                         |   |
 |  |   international/          |    | Renders markers, routes,|   |
 |  |   tomtom-mcp:latest       |    | polygons, traffic via   |   |
 |  |                           |    | URL query parameters    |   |
 |  | MAPS=tomtom-orbis-maps    |    +-------------------------+   |
 |  | 16 tools | Port 3000      |                ^                 |
 |  | 1.5 CPU, 3Gi RAM          |                |                 |
 |  | Replicas: 1-3             |        "Open Interactive Map"    |
 |  |                           |                |                 |
 |  | Endpoints:                |    +-------------------------+   |
 |  |   GET  /health            |    | Azure Function App      |   |
 |  |   POST /mcp              +--->| Map Proxy API            |   |
 |  +---------------------------+    |                         |   |
 |                                   | POST /api/generate-     |   |
 |                                   |       map-card          |   |
 |                                   | GET  /api/get-map-image |   |
 |                                   |                         |   |
 |                                   | Returns Adaptive Cards  |   |
 |                                   | + image URLs            |   |
 |                                   +------------+------------+   |
 |                                                |                |
 +-----------------------------------------------------------------+
                                                  |
                          HTTPS + API Key header   |
                   +------------------------------+|
                   |              |                ||
           Copilot Studio   Power Automate   Graph Connector
           (Native MCP +    (Custom          (.NET 9 console)
            Adaptive Cards)  Connector)
                   |              |                |
                   +--------------+----------------+
                                  |
                            M365 Copilot
                      (answers location queries)

.\deploy\Deploy-TomTomMCP.ps1 -TomTomApiKey "<YOUR_KEY>" `
    -SubscriptionId "<YOUR_SUB>" -TenantId "<YOUR_TENANT>"

.\deploy\Deploy-OrbisUpgrade.ps1
.\deploy\Deploy-OrbisUpgrade.ps1 -TomTomApiKey "<YOUR_NEW_KEY>"

.\deploy\Deploy-InteractiveMap.ps1 -ResourceGroupName "rg-tomtom-mcp" -Location "uksouth"

# Option: Manual deploy via SWA CLI
npm install -g @azure/static-web-apps-cli
cd interactive-map-app
swa deploy . --deployment-token <TOKEN>

.\deploy\Deploy-MapProxy.ps1 `
    -TomTomApiKey "<YOUR_KEY>" `
    -McpServerUrl "https://ca-tomtom-mcp.azurecontainerapps.io" `
    -InteractiveMapUrl "https://swa-tomtom-map.azurestaticapps.net"

cd map-proxy-api
npm install && npm run build
func azure functionapp publish func-tomtom-map-proxy

# Create the Entra ID app registration
.\graph-connector\Setup-AppRegistration.ps1 -TenantId "<YOUR_TENANT_ID>"

# Copy the template and fill in your credentials
cp graph-connector/appsettings.template.json graph-connector/appsettings.json
# Edit appsettings.json with your tenantId, clientId, clientSecret, tomTomApiKey, mcpBaseUrl

# Run the connector to index location data
dotnet run --project graph-connector

.\tests\Invoke-SmokeTests.ps1 -BaseUrl "https://<your-app>.azurecontainerapps.io" -ApiKey "<YOUR_KEY>"

.\tests\Invoke-OrbisTests.ps1 -BaseUrl "https://<your-app>.azurecontainerapps.io"

# Run a subset of tests
.\tests\Invoke-OrbisTests.ps1 -BaseUrl "https://<your-app>.azurecontainerapps.io" -TestFilter "*ev*"

# Static only (validates manifest/skills, builds the .zip)
.\tests\Invoke-CoworkPluginTests.ps1

# With live gateway checks
.\tests\Invoke-CoworkPluginTests.ps1 -GatewayUrl "https://<map-proxy>/api/mcp"

# Deploy the gateway to the map-proxy Container App
.\deploy\Deploy-CoworkGateway.ps1 -TomTomApiKey "<YOUR_KEY>"

# Validate + package the plugin into an uploadable .zip
.\cowork-plugin\Build-CoworkPlugin.ps1

TomTom/
+-- README.md                                  # This file
+-- .gitignore
+-- docs/
|   +-- COWORK-PLUGIN-PLAN.md                  # Cowork plugin design plan + alignment checklist
|   +-- COWORK-IMPLEMENTATION-LOG.md           # Running change log + test evidence
+-- cowork-plugin/
|   +-- manifest.json                          # M365 app manifest v1.28 (skills + connector)
|   +-- color.png / outline.png                # Plugin icons (192x192 / 32x32)
|   +-- New-Icons.ps1                          # Icon generator
|   +-- Build-CoworkPlugin.ps1                 # Validate + package the .zip
|   +-- README.md                              # Plugin overview
|   +-- COWORK-DEPLOYMENT-GUIDE.md             # Register -> package -> upload -> enable -> test
|   +-- skills/                                # 6 Agent Skills (live-map, search, route, traffic, ev, analytics)
+-- deploy/
|   +-- Deploy-TomTomMCP.ps1                   # Full Azure deployment (Orbis by default)
|   +-- Deploy-OrbisUpgrade.ps1                # Upgrade existing deployment to Orbis
|   +-- Deploy-InteractiveMap.ps1              # Deploy Static Web App for interactive map
|   +-- Deploy-MapProxy.ps1                    # Deploy Azure Function App (map proxy)
|   +-- Update-Container.ps1                   # Update container to latest image
|   +-- Deploy-CoworkGateway.ps1               # Redeploy map-proxy w/ Cowork MCP gateway
|   +-- Remove-TomTomMCP.ps1                   # Tear down all resources
+-- interactive-map-app/
|   +-- index.html                             # Single-page interactive map (TomTom SDK + MapLibre)
|   +-- package.json                           # App metadata and dev scripts
|   +-- staticwebapp.config.json               # Azure Static Web App routing and headers
+-- map-proxy-api/
|   +-- package.json                           # Node.js 18 Azure Function project
|   +-- tsconfig.json                          # TypeScript configuration
|   +-- host.json                              # Azure Functions host settings
|   +-- local.settings.json                    # Local development environment variables
|   +-- src/
|       +-- functions/
|       |   +-- generateMapCard.ts             # POST endpoint: MCP tool -> Adaptive Card
|       |   +-- getMapImage.ts                 # GET endpoint: MCP tool -> PNG image
|       |   +-- mcpGateway.ts                  # POST /api/mcp -- Cowork MCP gateway route
|       +-- lib/
|           +-- mcpClient.ts                   # MCP JSON-RPC client with SSE parsing
|           +-- mcpGateway.ts                  # Gateway logic + render_live_map tool
|           +-- adaptiveCards.ts               # Adaptive Card builders (search, route, traffic, map)
+-- tests/
|   +-- Invoke-SmokeTests.ps1                  # 13 smoke tests (original 11 tools)
|   +-- Invoke-OrbisTests.ps1                  # 18 Orbis tests (all 16 tools + security + perf)
|   +-- Invoke-CoworkPluginTests.ps1           # Cowork package validation + live gateway smoke
+-- power-platform/
|   +-- TomTomMCP-connector.swagger.json       # OpenAPI definition for Power Automate
|   +-- SETUP-GUIDE.md                         # Custom connector setup guide
|   +-- COPILOT-AGENT-GUIDE.md                 # Agent instructions & examples
+-- graph-connector/
    +-- TomTomGraphConnector.csproj             # .NET 9 project
    +-- Program.cs                             # Main entry point
    +-- ConnectorConfig.cs                     # Configuration model
    +-- GraphConnectorService.cs               # Microsoft Graph external connection
    +-- TomTomClient.cs                        # TomTom MCP API client
    +-- LocationItem.cs                        # Data model for indexed items
    +-- appsettings.template.json              # Configuration template (copy to appsettings.json)
    +-- Setup-AppRegistration.ps1              # Entra ID app registration script
    +-- DEPLOYMENT-GUIDE.md                    # Full deployment & troubleshooting guide

  User asks a location question in Teams
                    |
                    v
  Copilot Studio agent receives the message
                    |
                    v
  Agent calls MCP tool via the MCP server
  (e.g., tomtom-dynamic-map, tomtom-routing, tomtom-poi-search)
                    |
                    v
  MCP server returns tool result
  (JSON data, and/or base64 PNG image)
                    |
                    v
  Agent calls Map Proxy  POST /api/generate-map-card
  with the tool name + arguments
                    |
                    v
  Map Proxy calls MCP server, parses the result,
  and builds a typed Adaptive Card:
    - Search results card  (geocode, POI, fuzzy, nearby, area, EV search)
    - Route card           (routing, EV routing, waypoint optimization)
    - Traffic card         (traffic incidents)
    - Dynamic map card     (map images with overlays)
    - Generic fallback     (any other tool)
                    |
                    v
  Adaptive Card is returned to Teams with:
    - A static map image (embedded or via /api/get-map-image URL)
    - Result summary text (distances, addresses, counts)
    - "Open Interactive Map" button linking to the Static Web App
                    |
                    v
  User sees the card in Teams and can:
    [View the static map inline]
    [Click "Open Interactive Map" to zoom/pan/explore in the browser]

curl -X POST "https://<your-app>.azurecontainerapps.io/mcp" \
  -H "Accept: application/json,text/event-stream" \
  -H "tomtom-api-key: <YOUR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "method": "tools/call",
    "params": {
      "name": "tomtom-geocode",
      "arguments": { "query": "Cardiff Castle, Wales" }
    },
    "jsonrpc": "2.0",
    "id": 1
  }'