Some of the Eye-Catching Outputs

The webmap automation system operates through an intelligent agent framework powered by GitHub Copilot integrated within the VSCode development environment. The architecture implements a structured instruction set defined in .github/copilot-instructions.md, enabling precise control over agent behavior, output formatting, edge case handling, and result validation protocols.

Core Components:

The system architecture consists of three primary layers:

1. Agent Instruction Layer: Markdown-based system directives that define agent reasoning processes, expected outputs, and workflow requirements
2. MCP Server Integration: Custom Model Context Protocol server configured via .vscode/mcp.json that provides specialized geospatial tooling accessible to the AI agent
3. Conversational Interface: Natural language processing layer that interprets user requests, orchestrates tool execution, and generates properly formatted webmap configurations

Operational Workflow:

When a user submits a geospatial query, the AI agent executes the following automated sequence:

• Analyzes user intent and identifies required data sources
• Queries ArcGIS Living Atlas through MCP server tools to locate relevant datasets
• Retrieves layer metadata and field schemas from REST endpoints
• Generates appropriate definition expressions for data filtering
• Constructs standards-compliant webmap JSON configurations
• Validates output format and writes results to configuration files

The agent operates autonomously through the entire workflow, handling context management, tool invocation, result interpretation, and output generation without manual intervention. This autonomous operation is enabled by the comprehensive instruction set that defines reasoning patterns and decision-making criteria.

Example Use Case:

An analyst needs to compare fossil fuel versus renewable energy infrastructure using ArcGIS Living Atlas data. They request "show me the coal power plants" and the AI agent automatically searches Esri's Living Atlas, identifies the appropriate ArcGIS Online energy infrastructure dataset, and filters it to display only coal-fired power generation facilities across the operational area in an ArcGIS WebMap.

Output:

Following up with "Now show me the wind power plants," the system intelligently adds a second filtered ArcGIS layer from Living Atlas with a spatial constraint, applying both facility type and geographic boundary filters to the ArcGIS Online WebMap. This demonstrates the system's ability to understand sequential Esri mapping requests, maintain context across ArcGIS interactions, and automatically generate complex ArcGIS definition expressions combining attribute and spatial filters—a task that traditionally requires writing SQL-like queries and understanding ArcGIS Living Atlas dataset schemas.

Output:

Core ArcGIS Automation Tools:

The search-living-atlas tool utilizes ArcGIS Living Atlas dataset discovery by implementing intelligent search algorithms that query Esri's Living Atlas repository using natural language terms:

@mcp.tool(name='search-living-atlas', description='Search for the relevant layers from the ARCGIS Living Atlas REST endpoint.')
def search_living_atlas(title=None):
    try:
        url = 'https://www.arcgis.com/sharing/rest/content/groups/47dd57c9a59d458c86d3d6b978560088/search'
        params = {
            'f': 'json',
            'start': 1,
            'num': 5,
            'q': f'(title:{title}) (type: "Feature Collection" OR type: "Feature Service" OR type: "Map Service" OR type: "Vector Tile Service" OR type: "Image Service" OR type: "WMS" OR type: "Group Layer")',
            'categories': '/Categories'
        }
        response = requests.get(url, params=params, timeout=10)
        response.raise_for_status()
        res = response.json()
        output = [{k:v for k,v in item.items() if k in ['name','url','id','tags']} for item in res.get('results',[])]
        return output
    except Exception as e:
        print(f"Error occurred while searching Living Atlas: {str(e)}")
        return None

The get-layers-info tool provides comprehensive ArcGIS layer metadata extraction, enabling intelligent field analysis and automated definition expression generation:

@mcp.tool(name='get-layers-info', description='Get layer available within feature server from the REST endpoint.')
def get_layers_info(feature_server_url):
    try:
        params = {'f': 'pjson'}
        response = requests.get(feature_server_url, params=params, timeout=10)
        response.raise_for_status()
        res = response.json()
        output = res['layers'] or []

        return output
    except Exception as e:
        print(f"Error occurred while fetching sublayer info: {str(e)}")
        return None

The get-sublayer-info tool provides specialized capabilities for analyzing complex ArcGIS Feature Services with multiple sublayers, enabling intelligent navigation of hierarchical dataset structures:

def get_sublayer_info(layer_url):
    try:
        response = requests.get(f'{layer_url}?f=pjson', timeout=10)
        response.raise_for_status()
        res = response.json()
        fields = res.get('fields', [])
        result = []
        for field in fields:
            description = json.loads(field.get('description')) if field.get(
                'description') else {}
            result.append({
                'name': field.get('name'),
                'itemId': field.get('serviceItemId'),
                'actualType': field.get('actualType'),
                'alias': field.get('alias'),
                'description': description.pop('description', description),
            })
        return result
    except Exception as e:
        print(f"Error occurred while fetching layer info: {str(e)}")
        return None

This tool enables the AI agent to intelligently navigate complex ArcGIS Living Atlas datasets that contain multiple thematic sublayers, automatically identifying and extracting relevant sublayer configurations for targeted WebMap visualization. The sublayer analysis capability is essential for handling enterprise-scale ArcGIS Feature Services where different data themes are organized as sublayers within a single service endpoint.

The save-webmap tool implements secure ArcGIS WebMap JSON serialization with enterprise-grade UTF-8 encoding support:

@mcp.tool(name="save-webmap", description="Save a webmap JSON to a file.")
def save_webmap(webmap_dict):
    try:
        output_filepath = 'data/custom_webmap.json'
        with open(output_filepath, "w", encoding="utf-8") as f:
            json.dump(webmap_dict, f, indent=4, ensure_ascii=False)
        return output_filepath
    except Exception as e:
        print(f"Error occurred while saving webmap: {str(e)}")
        return None

This advanced capability transforms the system from a development and prototyping framework into a production-grade ArcGIS Online content management solution that seamlessly integrates with enterprise Esri workflows. Organizations can leverage conversational AI not only for creating sophisticated ArcGIS WebMap configurations but also for managing the complete lifecycle of published ArcGIS Online items within established enterprise governance frameworks. Teams can maintain comprehensive version control of enterprise WebMaps, programmatically update published ArcGIS Online content based on evolving business requirements, and integrate AI-driven ArcGIS automation directly into enterprise ArcGIS Online governance workflows while maintaining full compliance with organizational security protocols.

Implementation requires secure credential management through environment variables and appropriate ArcGIS Online organizational permissions. This architecture ensures that AI-assisted WebMap creation can seamlessly integrate with existing enterprise GIS infrastructure while maintaining security and governance standards.

Enterprise Integration Capabilities:

The MCP server architecture is designed for seamless integration with existing enterprise Esri ArcGIS Online infrastructures. The modular tool design allows for rapid customization to support:

• Custom ArcGIS Enterprise environments through modified REST endpoint configurations
• Enhanced security protocols including OAuth2 and SAML integration for enterprise ArcGIS Online authentication
• Advanced Esri data processing with support for complex spatial queries and geoprocessing workflows
• Scalable deployment patterns supporting high-availability ArcGIS automation scenarios

This sophisticated MCP server foundation enables the AI agent to perform complex ArcGIS operations that traditionally require deep technical expertise in Esri REST APIs, ArcGIS Online authentication, and WebMap JSON specification standards.

REFERENCES

• https://livingatlas.arcgis.com/en/browse
• https://modelcontextprotocol.io/docs/getting-started/intro
• https://developers.arcgis.com/javascript/latest/api-reference/esri-WebMap.html