Generative AI Google Brain

gemini-use-cases-retail-retail-ai-location-strategy-gemini-3

3 min read

Retail AI Location Strategy: Autonomous Site Selection & Market Analysis

Source notebook

Repo path: gemini/use-cases/retail/retail_ai_location_strategy_gemini_3.ipynb · Open on GitHub · advanced

Builds a Gemini 3 retail site-selection pipeline using search, Maps, code execution, reasoning, and JSON output.

Summary

This notebook teaches how to use Gemini 3 on Vertex AI for retail location strategy. It demonstrates an end-to-end workflow that researches a target market with Google Search grounding, maps competitors through a Google Maps Places API tool, runs quantitative gap analysis with code execution, and synthesizes a structured Pydantic-backed JSON recommendation using extended reasoning.

Key code patterns

Initialize Vertex AI Gemini client

client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)
MODEL_ID = "gemini-3.1-pro-preview"

Configures the Google GenAI SDK to call Gemini through Vertex AI in the global location.

Search grounding

search_tool = types.Tool(google_search=types.GoogleSearch())
response = client.models.generate_content(
    model=MODEL_ID,
    contents=market_research_prompt,
    config=types.GenerateContentConfig(
        system_instruction=system_instruction,
        tools=[search_tool],
    ),
)

Grounds market research in current web sources before downstream analysis.

Maps function calling

def search_places(query: str):
    import googlemaps
    gmaps = googlemaps.Client(key=MAPS_API_KEY)
    return gmaps.places(query)
 
response = client.models.generate_content(
    model=MODEL_ID,
    contents=competitor_prompt,
    config=types.GenerateContentConfig(tools=[search_places]),
)

Lets Gemini call a custom Google Maps Places API wrapper for real competitor data.

Code execution analysis

code_execution_tool = types.Tool(code_execution=types.ToolCodeExecution())
response = client.models.generate_content(
    model=MODEL_ID,
    contents=gap_analysis_prompt,
    config=types.GenerateContentConfig(tools=[code_execution_tool]),
)

Uses executable Python instead of guessed arithmetic for saturation and viability metrics.

Structured reasoning output

response = client.models.generate_content(
    model=MODEL_ID,
    contents=final_recommendation_prompt,
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_level=types.ThinkingLevel.HIGH,
            include_thoughts=True,
        ),
        response_mime_type="application/json",
        response_schema=LocationIntelligenceReport,
    ),
)

Combines high-level reasoning with a strict Pydantic schema for downstream JSON use.

Models & APIs used

  • Models: gemini-3.1-pro-preview
  • APIs / services: Vertex AI, Google Search, Google Maps Places API
  • SDKs / libraries: google-genai, googlemaps, pydantic

When to use this

Use this pattern when a retail site-selection decision needs fresh web research, grounded competitor locations, quantitative gap analysis, and structured executive recommendations.

Gotchas & caveats

  • Requires Python 3.9 or higher.
  • Requires a Google Cloud project with the Vertex AI API enabled.
  • Requires a Google Maps API key with the Maps Places API enabled.
  • PROJECT_ID must be set directly or via GOOGLE_CLOUD_PROJECT.
  • MAPS_API_KEY must be stored in Colab Secrets or provided as an environment variable.
  • LOCATION is set to global because Gemini 3 is available globally.
  • The notebook states Gemini 3 has a Jan 2025 knowledge cutoff, so current market data uses Search Grounding.
  • The notebook warns that built-in Google Maps grounding suits simple conversational use cases, while custom tools give more control for agentic workflows.

Best practices

  • Use Search Grounding for fresh demographics, growth, rental, and market viability data.
  • Wrap Google Maps Places API as a tool for real competitor names, locations, and ratings.
  • Base gap analysis on prior market research and competitor findings rather than isolated prompts.
  • Use code execution for density, saturation, and scoring calculations.
  • Use Pydantic schemas and response_schema to make final recommendations machine-readable.
  • Save each stage output for later synthesis across the workflow.
  • Reference actual business names, locations, ratings, and sourced data in analysis.

Graph View

Backlinks