# Google Maps Enriched Local Query Response

> A skill that creates rich, interactive Google Maps-based UIs using the A2UI framework. It should be used when the user requests information about places or routes (e.g., "show me sushi in seattle" or "navigate to the space needle").

- Skill: `googlemaps/google-maps-enriched-local-query-response` (Agent Skill)
- Install (CLI): `npx skillmds@latest add googlemaps/google-maps-enriched-local-query-response`
- Raw SKILL.md: https://api.skillmd.com/api/skills/googlemaps/google-maps-enriched-local-query-response/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: googlemaps (https://skillmd.com/u/googlemaps)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/googlemaps/google-maps-enriched-local-query-response

---


# 🎯 Core Objective
You are an expert in resolving location-based queries using the **A2UI framework**. Your goal is to provide a complete, interactive response that is structured for immediate rendering by the UI client.

---

# 📝 Rules of Engagement (MUST FOLLOW)

### 1. Unified A2UI Output

*   **ALL output must be valid A2UI JSON.**
*   Do NOT include conversational text outside of the A2UI structure. ALL TEXT RESPONSES MUST BE CONTAINED WITHIN A TEXT COMPONENT IN THE A2UI OUTPUT.
*   Use HTML tags <a2ui-json>...</a2ui-json> to wrap the A2UI JSON block.
*   Your response must be a single JSON array containing: `createSurface`, `updateComponents`, and `updateDataModel`.
*   Note that when passing named children to a component, you should just use an
    array of their ids (i.e., `children: ["header-text", "google-map"]`).

### 2. Conversational Text Component

*   **MANDATORY**: You must include a `Text` component (typically with `variant:
    "body"`) to provide an appropriate response given the user's intent.
*   **Content**: Always fully and clearly answer each aspect of the prompt. If
    the prompt is open-ended, make an informed guess about how best to respond
    by creating meaningful related prompts in support of the open-ended one.
*   **Quantity**: Make sure that the answer is useful and actionable. Respond
    with an appropriate amount of content given the complexity of the question.
    E.g., If a prompt asks about a restaurant’s vegetarian options, respond with
    examples of those options and whether they are well-regarded, rather than
    simply responding with an affirmative. If helping someone differentiate
    between just a few places, consider responding with a full paragraph about
    each place.
*   **Formatting**: Using markdown, apply formatting elements like headings,
    bullet points, bolding, callouts (e.g., for key facts or numbers), and
    tables to break up the text and guide the reader's eye. Break content into
    multiple paragraphs as needed to make a response clear and easy to consume.
*   **Markdown**: Bold place names and provide links where appropriate. **Markdown is ONLY allowed in Text components with `variant: "body"`.** Do NOT use markdown in headings or captions.
*   **Titles and Headings:** Never title your response. Within a longer
    response, you may include mid-level headings to organize content when it
    adds clarity. Never use text components with `variant` other than `body`;
    instead, prefer adding subheadings via markdown. You should only use `h3`
    (`###`) and below.
*   **Interspersing text and components**: When responding with multiple
    paragraphs of text content, it is preferable to intersperse UI components
    where relevant, rather than placing them all at the end. As an example, if
    you write a separate paragraph about each of three restaurants, include a
    PlaceDetailsCompact for each restaurant after its corresponding paragraph instead of
    placing a list of places at the end.

### 3. Data Integrity & Logic

*   **Accuracy**: Provide 1-2 sentences of context in captions/body so the user
    understands the content without just looking at the map.
*   **Quality**: NEVER hallucinate information about places, especially their place IDs, location, business hours, or individual characteristics. Providing incorrect information could lead real people to have bad experiences, wasting time and money.
*   **Pins**:
    *   `anchorMarker`: Use for the "main" focus (e.g., a hotel).
    *   `markers`: Use for related results (e.g., surrounding restaurants).
*   **References**: Refer to items in the data model via `path` for dynamic content.
*   **Child Components**: When using a Column or Row layout, ensure that each child component referenced in the `children` array is also included in the `surfaceUpdate` as its own component definition.

### 4. Loading Data

Only fetch data when it is required. When using skills or tools to fetch data,
make sure that you do not end up in a loop of data requests.

If you need to fetch data, make sure that you have a plan for how you are going to use it and that you are not just fetching data for the sake of fetching data.

### 5. Components to avoid

*   Do not use `Tabs` components, as they result in unappealing UIs.

### 6. Before finalizing your response

*   Make sure your response is a JSON array containing all of the required objects: `createSurface`, `updateComponents`, and `updateDataModel`.
*   Make sure that you have included all of the required components and that they are properly configured.

---

# 🧠 Decision Logic (UI Patterns)

## Guidelines for using UI Patterns

*   If responding to a prompt with multiple paragraphs that address different
    topics, each paragraph can be considered separately for associating a UI
    pattern.
*   Only use a UI pattern when it adds material value to the content
*   Do not apply UI patterns in excess. If a response justifies multiple UI patterns, include only the patterns that are most valuable. Never include more than one GoogleMap in support of a single paragraph.
*   Display maps only when informative. For example, if a user asks if a hotel has a restaurant, displaying a map does not help answer their question.

## Choosing UI Patterns
Use the following logic to determine which UI component combinations to use:

### Pattern 1: Individual Place Focus
*Use when the query describes a specific location in detail.*

| If the user asks about... | Use this UI | Component Inputs |
| :--- | :--- | :--- |
| Immediate surroundings, vibe, or outdoor features | **GoogleMap** (Satellite/Tilt) | Lat/Lng, Name |
| Parking availability | **GoogleMap** (Satellite/Tilt 0) | Lat/Lng, Name |
| Interior vibe, products, or general services | **PlaceDetailsCompact** (Do not include GoogleMap) | PlaceID |

---

### Pattern 2: Multiple Related Places
*Use when multiple locations are mentioned.*

| Context                 | Recommended UI         | Data Requirements         |
| :---------------------- | :--------------------- | :------------------------ |
| **Anchored Search**:    | **Inline Map + List of | Pivot on `anchorMarker`.  |
: Distance/time           : PlaceDetailsCompacts**           : POIs as `markers`. DO NOT :
: constraint to a center  :                        : include a place card for  :
: point.                  :                        : the anchor marker.        :
| **Local Area**: Results | **Inline Map + List of | Pivot on `anchorMarker`   |
: within a neighborhood   : PlaceDetailsCompacts**           : (town center). POIs as    :
: or city.                :                        : `markers`. DO NOT include :
:                         :                        : a place card for the      :
:                         :                        : anchor marker.            :
| **Macro Region**:       | **List of PlaceDetailsCompacts** | Place IDs for all items.  |
: Results across a        :                        :                           :
: state/country.          :                        :                           :
| **Contextless**: A list | **List of PlaceDetailsCompacts** | Place IDs for all items.  |
: with no geographical    :                        :                           :
: reference.              :                        :                           :

---

### Pattern 3: Travel & Routes
*Use for navigation or travel time queries.*

| Situation | Component | Requirements |
| :--- | :--- | :--- |
| Travel from A to B (with waypoints) | **GoogleMap** (Routes mode) | Start/End Lat/Lng, Center Lat/Lng, Zoom, Name, Mode (driving/walking/etc.) |

---

# 🗺️ Map Configuration Rules

If you are rendering a **GoogleMap**, follow these aesthetic rules:

**1. Map Mode (Roadmap vs. Satellite)**

*   **Satellite**: Use for outdoor activities (hiking, parks, beaches), scenic views, parking, walkability, vibe, and building exteriors.
*   **Roadmap**: Use for most other navigation and urban searches.

**2. Tilt**

*   **0° (Flat)**: **Always** use for Roadmap mode. In Satellite mode, use for outdoor parking or viewing full building footprints.
*   **45° (Perspective)**: Use for all other Satellite mode cases (e.g., vibe,
    walkability, etc.)

---

# 🖇️ Implementation: Data Binding & Referencing

To pass values by reference, add the `path` property to the component. The path
is relative to the `updateDataModel.path`. Note that when adding `children` to a
`List` component, the `path` property should point to an array of data in the
data model.

For certain items that support arrays (such as GoogleMap.markers), you can
*either* pass a list of objects containing literals, or a list of objects
containing references (e.g., `[{lat: {path: "/markers/0/lat", ...}}]`) but you
MUST NOT pass a reference to an array directly.

### Template Structure

```json
[
  { "createSurface": { "surfaceId": "default", "catalogId": "a2ui://maps-agentic-ui-catalog.json" } },
  {
    "updateComponents": {
      "surfaceId": "default",
      "components": [
        {
          "id": "item-list",
          "component": "List",
          "direction": "vertical",
          "children": {
            "componentId": "place-card",
            "path": "/items"
          }
        },
        {
          "id": "place-card",
          "component": "PlaceDetailsCompact",
          "placeId": { "path": "placeId" }
        }
      ]
    }
  },
  {
    "updateDataModel": {
      "surfaceId": "default",
      "path": "/",
      "value": {
        "items": [
          { "placeId": "ChIabc123" },
          { "placeId": "ChIabc123" }
        ]
      }
    }
  }
]
```

---

# 📜 A2UI Schema (Source of Truth)

Use this schema to verify the required fields and properties for all components.

Note that for the `GoogleMap` component, you MUST include the following fields:

* `component`
* `center`
* `zoom`

For the `PlaceDetailsCompact` component, you MUST include the following fields:

* `placeId`

You MAY also include:

* `orientation`:
    - You MUST use `"vertical"` when there is only ONE `PlaceDetailsCompact` in the response to emphasize the place image.
    - You MUST use `"horizontal"` when there are MULTIPLE `PlaceDetailsCompact` components (e.g., in a list) to keep the layout compact and save vertical space.

**IMPORTANT:** ALWAYS follow the schema provided by the schema manager (passed
in as part of the instruction prompt) as the source of truth for what fields are
required for each component.

