# Mapulus MCP > Mapulus gives you deep location intelligence for Australia. Connect it to your AI agent to instantly pull census data, check statistical boundaries (like suburbs or postcodes), and run advanced spatial analytics—all without writing complex API calls. You get catchment areas, population counts, and specific geographic context just by asking a question. ## Overview - **Category:** data-analytics - **Price:** Free - **Tags:** spatial-analytics, demographic-data, isochrones, geographic-boundaries, census-data, location-intelligence ## Description Yo, listen up. Mapulus gives your AI agent deep location intel for Australia. Forget digging through databases; just ask the question and get straight answers. **Searching Boundaries:** You need to pinpoint an official boundary? Whether you're looking for a specific suburb, a Local Government Area (LGA), or a postcode, you can search across all Australian statistical boundaries using `search_boundaries`. Need something more targeted? Use `search_suburbs` if you know the name of the suburb. If you just need to check the full details of any defined boundary—like what exactly makes up that LGA or postcode—you run `get_boundary_details`. **Demographics and Stats:** Want to know who lives where? You can pull hard census data from ABS using `get_demographics`, getting population counts, median income figures, and housing metrics for any defined area. For a quick check on a specific postal code, `get_postcode_data` pulls all the relevant statistical and demographic info you need. If you aren't sure what kind of stats are available—like if we got 'income' or 'population' data—you can run `list_data_topics` to see exactly what categories of data we've got. **Spatial Analysis:** Need to know the physical area people can reach? You generate isochrones with `get_isochrone`. This calculates boundaries based on a specific travel time from your starting point. For standardized grid mapping, you calculate an H3 hexagonal index using `get_h3_index`, which pins down a location's spot for consistent spatial analysis across different tools. **Location Enrichment:** Got just a latitude and longitude? Don't sweat it. You pass those coordinates into `enrich_location` and we spit out detailed geographic, statistical, and contextual data for that exact spot. This function gives you everything—the geography, the stats, the context—all in one shot. Basically, Mapulus handles all the heavy lifting. You're not writing complex API calls; your agent just talks to us. You pull census-derived population counts and income metrics for any defined area, search official boundaries like postcodes or LGAs by name, generate catchment areas based on travel time constraints, get a standardized H3 index for grid use, and even take raw coordinates and instantly grab comprehensive statistical context for that precise spot. ## Tools ### enrich_location Takes a latitude and longitude and returns detailed geographic, statistical, and contextual data for that specific spot. ### get_boundary_details Retrieves full details for any specific defined geographical boundary type you pass to it. ### get_demographics Pulls ABS Census data, giving population counts and income metrics for a specified geographic area. ### get_h3_index Calculates the H3 hexagonal index for any given location, standardizing its position on a grid. ### get_isochrone Generates boundaries representing areas reachable within a specific travel time from a starting point. ### get_postcode_data Retrieves all relevant statistical and demographic information for a given Australian postcode. ### list_data_topics Lists the specific categories of data available, like 'population' or 'income', that you can query. ### search_boundaries Searches across all Australian statistical boundaries (LGA, suburb, postcode) based on a general search term. ### search_suburbs Performs a targeted search specifically for Australian suburbs by name or location. ## Prompt Examples **Prompt:** ``` Search for boundaries matching 'Sydney'. ``` **Response:** ``` Fetching boundaries... I found several results including 'Sydney (LGA)', 'Sydney (Suburb)', and 'Sydney (Postcode)'. ``` **Prompt:** ``` Get demographics for postcode 2000. ``` **Response:** ``` Retrieving data... Postcode 2000 has a population of approximately 27,000 with a median age of 32. ``` **Prompt:** ``` Show available data topics. ``` **Response:** ``` Here are the available topics: 'population', 'income', 'housing', 'education', 'employment'. ``` ## Capabilities ### Search Australian Boundaries Find specific official boundaries by name or type, such as suburbs, postcodes, or local government areas. ### Retrieve Population and Income Stats Get census data on population size, median income, and housing metrics for a defined boundary area. ### Calculate Travel-Time Areas (Isochrones) Determine the physical catchment area around a point based on specified travel time constraints. ### Enrich Coordinates Take any latitude/longitude pair and get back its detailed geographic, statistical, and contextual information. ### Index Location by Hexagon Grid Assign an H3 hexagonal index to a location for standardized spatial analysis across different tools. ## Use Cases ### Identifying Service Area Gaps A logistics manager needs to prove their new depot location covers a whole region. They use `get_isochrone` based on the required drive time, then run `search_boundaries` against that resulting area to confirm they cover enough high-value postcodes. ### Market Sizing for New Housing Projects A developer wants to know if a suburb is viable. They start by running `get_postcode_data` for the target code, then use `search_suburbs` to verify the local LGA boundaries, and finally check `get_demographics` for current median income. ### Standardizing Data Inputs A data scientist is compiling a multi-source dataset. They use `get_h3_index` on every single coordinate point to normalize the data into a consistent, gridded format before analysis. This makes joining disparate datasets reliable. ### Verifying Geographic Scope A government researcher needs to confirm all relevant administrative areas for a policy report. They use `list_data_topics` first to scope the data, then run `search_boundaries` multiple times (e.g., once for 'LGA' and once for 'suburb') to capture every necessary layer. ## Benefits - Stop manually cross-referencing spreadsheets. By invoking `get_demographics`, you pull hard ABS Census numbers (population, income) directly into your conversation, making reporting instant. - You don't need to know the exact boundary type—just ask. The `search_boundaries` tool finds results across LGAs, suburbs, and postcodes so you never miss a data set. - Need service areas? Running `get_isochrone` calculates real travel-time catchment zones around a point, which is far more accurate than simple straight-line distance calculations. - Forget guessing what metrics are available. Use `list_data_topics` first to see exactly what data points (like 'employment' or 'housing') the server can pull for any given boundary. - Pinpoint exact locations with `enrich_location`. Instead of just getting a street name, you get the full statistical context—the population density and LFA codes for that specific lat/lon. ## How It Works The bottom line is, it turns complex geospatial database queries into simple chat prompts. 1. Subscribe to the Mapulus server and input your unique API key. 2. Your AI client sends a natural language request (e.g., 'What's the population near 2000?'). 3. The MCP framework translates that into specific tool calls, retrieves the Australian data, and hands you the final answer. ## Frequently Asked Questions **How do I get census data using Mapulus?** You use `get_demographics`. You just need to tell the server which boundary you're interested in—like a postcode or an LGA—and it pulls population and income stats for that exact area. **What is the difference between search_boundaries and search_suburbs?** `search_boundaries` handles all types of official areas (LGA, suburb, postcode). `search_suburbs` limits your search only to Australian suburbs. Use the general tool unless you know you only need a suburb. **Can I calculate service zones with Mapulus?** Yes, use the `get_isochrone` tool. This runs an analysis that creates boundaries based on real travel time from a starting point, which is better than any simple radius calculation. **Does enrich_location give me enough data?** It gives you detailed geographic context for specific coordinates (lat/lon). For deeper stats like population counts, pair it with `get_demographics` and pass the resulting boundary ID to that tool. **How do I check what data topics are available before using the `list_data_topics` tool?** You start by calling `list_data_topics`. This function immediately shows all the domains you can query, such as 'population' or 'housing'. It’s a quick way to understand the entire dataset scope without needing specific geographic coordinates first. **What happens if I run `enrich_location` with invalid latitude/longitude inputs?** The tool returns an explicit error status code and details showing where your input failed. You must validate that the latitude and longitude are within expected ranges before attempting to enrich a location. **Does running `get_isochrone` multiple times in quick succession count against rate limits?** Yes, all API calls are subject to Vinkius' defined usage rates. If you need many isochrones, consider batching your requests or checking the provided dashboard for current quotas to avoid throttling. **Can `get_postcode_data` pull generalized demographic insights, or is it code-specific?** It pulls specific, detailed records tied directly to the Australian postcode you provide. You can't use this tool for general searches; you must input an exact postcode number. **How do I find my Mapulus API Key?** Log in to Mapulus, go to Profile > API Keys, and you can generate your key there. **What regions are covered by Mapulus?** Mapulus specializes in Australian geographic and statistical data (ABS Census boundaries). **Is my API Key secure?** Absolutely. Your token is encrypted at rest and injected securely at runtime.