Check that QGIS is running with the MCP plugin enabled.

Returns the QGIS version and the plugin's protocol version. Use this first if any other tool fails, to tell "QGIS is not reachable" apart from a real error in the command itself.

Describe the QGIS project currently open in the desktop app.

Returns its file path, title, CRS, extent, layer count, and whether it has unsaved changes.

List every layer in the open project.

For each layer: id, name, type, provider, CRS, geometry type, feature count (vector layers only), visibility, and position in the layer tree. Feature counts come from the provider's index, not by scanning features. Use the returned id to call get_layer_schema or get_layer_sample.

Open a .qgs/.qgz project file, replacing the currently open project.

This discards the in-memory project state. If the current project has unsaved changes, the call fails with a ProjectDirty error unless force is set - confirm with the user before forcing a discard. Returns the same shape as project_info.

Save the open project.

Pass path to "save as" a new file; otherwise saves to the project's current file. Fails if the project has never been saved and no path is given.

Replace the open project with a new, empty one.

Discards all layers and settings from the current project. If it has unsaved changes, the call fails with a ProjectDirty error unless force is set - confirm with the user before forcing a discard.

Set the project's coordinate reference system, e.g. "EPSG:2180".

Set project metadata. Only the fields you pass are changed; the rest are left as-is.

Capture the full project state - info plus every layer - in one call.

Equivalent to project_info + project_list_layers merged into one payload. Useful as a reference point before a risky qgis_run_python or qgis_run_algorithm call, so you know what to compare against or restore.

Describe a vector layer's fields.

Always returns each field's name, type, length, and precision. For any field name passed in fields, also returns a capped sample of distinct values (with a total count) and, for numeric fields, the min/max. Requesting distinct values on every field on a large layer is expensive, so pass only the fields you actually need to reason about.

Fetch a handful of representative features from a vector layer.

limit defaults to 5 and is capped at 20 - this is a preview, not a data export. Geometry is omitted unless include_bbox is set, in which case each feature gets its bounding box only, never full WKT.

Rename a layer in the project.

Use the id from project_list_layers. Returns the layer's id and new name.

Show or hide a layer in the layer tree (its checkbox state).

Does not affect scale-based visibility rules set via layer_set_scale_visibility.

Set a layer's opacity, from 0 (fully transparent) to 100 (fully opaque).

Restrict a layer's visibility to a range of map scales.

min_scale/max_scale are scale denominators (e.g. 1000 for 1:1000) - min_scale is the most zoomed-out scale and max_scale the most zoomed-in scale at which the layer is shown. Pass enabled=False to turn the restriction off without losing the stored range. Omit either bound to leave it unchanged.

Assign a layer's CRS metadata, e.g. "EPSG:2180".

This only relabels the layer's coordinate reference system - it does not reproject coordinates. Use it to fix a layer that was loaded with a missing or wrong CRS. For an actual reprojection, a layer_reproject tool is planned but not yet implemented.

Describe a single layer in detail.

Returns id, name, type, provider, CRS, extent, source, position, and visibility, plus for vector layers: geometry type, feature count, encoding, and field count.

Remove a layer from the project.

This deletes the layer from the project, not from disk. Confirm with the user before removing a layer that hasn't been backed up elsewhere.

Duplicate a layer within the project.

The clone shares the same data source as the original - it's a second view onto the same data, not a copy of the underlying file. Pass name to set the clone's name; otherwise QGIS assigns a default.

Move a layer to a new position among its siblings in the layer tree.

position is a 0-based index (0 = top of the tree, drawn above the others). Does not move a layer into or out of a group - group support is planned but not yet implemented.

Select features on a vector layer using a QGIS expression.

mode controls how the match combines with the existing selection: "set" (default, replaces it), "add", "intersect", or "remove". Returns the resulting selected feature count.

Select features whose geometry intersects a bounding box.

bbox is [xmin, ymin, xmax, ymax]. crs defaults to the layer's own CRS if omitted. mode is the same set/add/intersect/remove combination as features_select_by_expression.

Select features on layer_id by their spatial relationship to another layer.

predicate is one of: intersects, contains, within, touches, overlaps, crosses, disjoint, equals. mode is the same set/add/intersect/remove combination as features_select_by_expression.

Clear the current feature selection on a vector layer.

Fetch the currently selected features on a vector layer.

Capped at 20 features (same limit as get_layer_sample) even if more are selected - total_selected in the response gives the real count. Geometry is omitted unless include_bbox is set, in which case each feature gets its bounding box only, never full WKT.

Fetch features from a vector layer, optionally filtered by a QGIS expression.

limit defaults to 5 and is capped at 20 - this is a preview, not a data export, same as get_layer_sample. Geometry is omitted unless include_bbox is set.

Count features on a vector layer, optionally matching a QGIS expression.

Without a filter this reads the provider's feature count directly (fast, no scan, same as project_list_layers); with a filter it scans and counts matches.

List a vector layer's fields: name, type, length, and precision.

Lighter-weight than get_layer_schema when you don't need distinct values or numeric ranges for any field.

Add a new field to a vector layer.

type is one of: integer, double, string, date, datetime, boolean. length/precision only matter for string/double fields. Requires an editable data source - fails with an EditFailed error on read-only layers.

Delete a field from a vector layer.

This removes the field's data on every feature. Confirm with the user before deleting a field that hasn't been backed up elsewhere.

Rename a field on a vector layer.

Set a field's value from a QGIS expression, evaluated per feature (the field calculator).

Pass filter_expression to only update a subset of features; omit it to update every feature. This overwrites existing values on every matched feature - confirm with the user before running it on a layer that hasn't been backed up.

Set specific attribute values on a single feature.

attributes maps field name to new value. Fails with FieldNotFound if any key isn't a real field on the layer.

Compute aggregate statistics for a numeric field.

stats is a subset of: min, max, mean, sum, median, stddev, count - defaults to min/max/mean/sum/count if omitted.

List a field's distinct values, capped at 20 with a total distinct count.

Same cap as the fields option on get_layer_schema - use this instead when you only need one field's distinct values without the rest of the schema.

Apply a SQL WHERE-style subset filter to a vector layer.

Hides non-matching features everywhere in the project - canvas, attribute table, and every other tool that reads this layer. Pass an empty string to clear the filter. Confirm with the user before applying a filter that hides most of the data.

Join another vector layer's attributes onto this layer by a shared key field.

join_field is the field on join_layer_id; target_field is the field on layer_id to match it against. prefix is prepended to the joined field names to avoid collisions - defaults to the join layer's name if omitted. This adds fields to every feature on layer_id for the rest of the session; confirm with the user first.

Filter a layer to a single Polish administrative unit by its TERYT code.

Convenience wrapper over layer_set_subset_filter for the common case of filtering Polish administrative boundary layers (gmina/powiat/województwo) by their GUS TERYT code in field_name. code must be digits only.

Style a vector layer with one uniform symbol.

color and outline_color accept any Qt color string (e.g. "#FF0000", "red"). size is point diameter or line width depending on geometry type (ignored for polygons - use outline_width for their border).

Style a vector layer with one color per distinct value of field.

Pass categories as an explicit list of {"value", "color", "label"} to control colors/labels yourself. Omit it to auto-generate one category per distinct value in the field, colored from color_ramp (a QGIS style color ramp name, e.g. "Spectral" - the default if omitted).

Style a vector layer with a graduated color ramp over a numeric field.

mode is one of: quantile (default), equal_interval, natural_breaks, std_dev, pretty. color_ramp is a QGIS style color ramp name (defaults to "Spectral").

Style a vector layer with rule-based symbology.

rules is a list of {"expression", "color", "label"} - each feature is styled by the first rule whose QGIS expression matches. Use an empty string expression for a catch-all/ELSE rule.

Style a point layer as a heatmap.

radius_unit is one of: map_units (default), pixels, millimeters. color_ramp is a QGIS style color ramp name (defaults to "Reds"). Fails with UnsupportedGeometryType on non-point layers.

Style a point layer with distance-based point clustering.

distance is the clustering tolerance in millimeters at render time. The layer's current symbol (or a default one) is kept for individual points/clusters. Fails with UnsupportedGeometryType on non-point layers.

Load a layer's style (renderer, labels, opacity, etc.) from a .qml or .sld file.

Replaces the layer's current style. Confirm with the user before loading over a style they haven't saved a copy of.

Save a layer's current style (renderer, labels, opacity, etc.) to a .qml file.

Copy one layer's style onto one or more other layers.

Returns a per-target result so a failure on one target (e.g. an incompatible layer type) doesn't block the others. Overwrites each target's current style - confirm with the user first.

Set a raster layer's renderer.

renderer_type is one of:

• "singleband_pseudocolor": parameters may include band (default 1), color_ramp (QGIS style ramp name, default "Spectral"), min, max (default to the band's actual min/max).

• "hillshade": parameters may include band (default 1), azimuth (default 315), altitude (default 45).

• "multiband_color": parameters may include red_band, green_band, blue_band (default 1/2/3).

Set a layer's blend mode against layers below it.

mode is one of: normal, multiply, screen, overlay, darken, lighten, difference, addition.

Turn on labeling for a vector layer, sourced from a field or a QGIS expression.

Pass exactly one of field or expression. Applies simple (non-rule-based) labeling with default text formatting - use labels_configure afterwards to adjust font, buffer, placement, or priority.

Adjust label appearance and placement for a layer that already has labeling enabled.

Requires labels_enable to have been called first - fails with InvalidOperation otherwise. placement is one of: over_point, around_point, line, curved, horizontal. priority is 0-10 (higher wins label collisions). Only the fields you pass are changed.

Turn off labeling for a vector layer without discarding its label settings.

List Processing algorithms available in this QGIS install.

Matches text_filter (case-insensitive) against the algorithm id, display name, and group. QGIS ships 1000+ algorithms, so results are capped at 50 by default (200 hard max) - narrow the filter rather than raising the limit when you're after something specific. Use the returned id with qgis_algorithm_help and qgis_run_algorithm.

Describe a Processing algorithm's parameters and outputs.

Returns its display name, group, short help text, and for every parameter/output: name, type, description, default value, and whether it's optional. Call qgis_list_algorithms first to find the algorithm_id.

Run a Processing algorithm against the open project.

parameters is passed straight through to processing.run, so check qgis_algorithm_help first to see what it expects. Like qgis_run_python, this can create, overwrite, or delete data - treat it as an operation that needs the user's go-ahead before running anything that writes files or modifies existing layers.

Zoom the map canvas to a bounding box.

bbox is [xmin, ymin, xmax, ymax]. crs defaults to the canvas CRS if omitted - pass it (e.g. "EPSG:4326") when the bbox coordinates are in a different CRS. Returns the resulting canvas extent.

Zoom the map canvas to a layer's full extent.

Use the id from project_list_layers. Returns the resulting canvas extent.

Zoom the map canvas to the selected features of a vector layer.

Fails with EmptySelection if the layer currently has no selected features.

Zoom the map canvas to the full extent of every layer in the project.

Set the map canvas scale, e.g. 10000 for a scale of 1:10000.

Center the map canvas on a coordinate without changing the zoom level.

crs defaults to the canvas CRS if omitted.

Rotate the map canvas to the given angle in degrees (normalized to 0-360).

Get the map canvas's current extent.

Returned in the canvas CRS by default; pass crs to get it expressed in a different CRS instead.

Get the map canvas's current scale.

Set the map canvas background color, e.g. "#FFFFFF" or "white".

Redraw the map canvas, re-reading every layer's data from its source.

Identify features at a point, across every visible layer.

For vector layers, returns features within a small screen-pixel tolerance of the point - a bounding-box match, not exact hit-testing against thin lines. For raster layers, returns the pixel value(s) at the point. crs defaults to the canvas CRS if omitted. Feature counts per layer and attribute string lengths are capped, same as get_layer_sample.

List the coordinate reference systems commonly used for Polish data.

Covers the national systems (PUWG 1992 / EPSG:2180, the four PUWG 2000 zones / EPSG:2176-2179, and legacy PUWG 1965 zone I / EPSG:3120) plus WGS 84 (EPSG:4326) and Web Mercator (EPSG:3857) for reference. Use the returned epsg codes with crs_transform_point, project_set_crs, or any tool that takes a crs argument.

Reproject a single 2D point between coordinate reference systems.

source_crs/target_crs accept anything QGIS recognizes, e.g. "EPSG:2180", "EPSG:2177", "EPSG:4326", "EPSG:3857" - see crs_list_polish for the common Polish ones. x/y follow the axis order QGIS uses for source_crs (for PUWG systems like EPSG:2180/2176-79 that's northing/easting in metres; for EPSG:4326 it's longitude/latitude in degrees).

Pick the right PUWG 2000 (CS2000) zone for a longitude or area.

Pass either lon (a single longitude in degrees) or bbox as [xmin, ymin, xmax, ymax] in degrees (EPSG:4326). Returns the zone whose 3-degree-wide strip covers the given longitude (or the bbox's centre), plus zones_touched and a warning if a bbox straddles more than one zone boundary - data spanning zones should usually be reprojected into one zone (or into EPSG:2180) rather than left mixed.

Convert a normal height between Poland's Kronsztadt'86 and EVRF2007-NH systems.

lon/lat (WGS84/ETRS89 degrees) locate the point - the conversion runs through GUGiK's geoid grids (PL-geoid2011 for Kronsztadt'86, PL-geoid2021 for EVRF2007-NH), which vary across Poland, so a height alone isn't enough. source/target are "KRON86" and "EVRF2007-NH" (either order). Accuracy - and whether this succeeds at all - depends on the QGIS instance's PROJ install having both geoid grids available; the call fails with a clear error if a grid can't be found or fetched.

Guess the probable CRS of unlabelled coordinates from their value range.

Pass either points (a sample of [x, y] pairs) or bbox as [xmin, ymin, xmax, ymax]. This is a heuristic over typical Polish coordinate ranges (geographic degrees, Web Mercator metres, PUWG 2000/1992 northing-easting) - it returns ranked candidates with a confidence and reason each, not a single definitive answer. Useful when a data source (e.g. an old shapefile with no .prj) gives no CRS at all; confirm with the user before assuming the top candidate is correct.

Geocode an address or place name using OpenStreetMap Nominatim, restricted to Poland.

Returns up to limit (default 5, max 10) candidates, each with display_name, lat/lon (WGS84, EPSG:4326), type, and importance. For fuzzy/autocomplete-style matching use geocode_photon instead; for Polish government address-point data use geocode_gugik_prg.

Geocode with autocomplete-style fuzzy matching via the public Photon (komoot) service.

Useful for partial/incomplete input where Nominatim's stricter matching returns nothing. Not restricted to Poland - be specific enough to avoid international noise. Returns up to limit (default 5, max 10) candidates with name, city, street, housenumber, postcode, country, lat/lon (WGS84, EPSG:4326).

Reverse-geocode WGS84 coordinates (EPSG:4326) to a street address via Nominatim.

Geocode a Polish address using GUGiK's UUG service (government PRG address points).

Generally more accurate than Nominatim for Polish addresses. Accepts forms like "Miasto, Ulica Numer" or just "Miasto". Returns up to limit (default 5, max 10) candidates with city, street, number, postal_code, teryt, x/y (EPSG:2180), and accuracy (0-1).

Bulk-geocode a CSV file of addresses and add the results as a point layer.

geocoder is "gugik" (default - GUGiK UUG, free with no documented rate limit, capped at 500 rows) or "nominatim" (capped at 50 rows, with a forced ~1.1s delay between requests - Nominatim's usage policy explicitly discourages bulk geocoding, so prefer "gugik" for anything but small batches). address_column names the CSV column holding the full address string. Every original CSV column is kept as a feature attribute on the resulting layer, plus match_status ("ok"/"not_found"). Only a count summary and a small sample are returned here, never the full geocoded table - inspect the layer with get_layer_sample.

Search for TERYT administrative-unit codes by name.

level narrows the search to one of "wojewodztwo", "powiat", "gmina"; omit it to search all three. Backed by GUGiK's PRG boundary registry, so results are guaranteed to match teryt_to_geometry. Locality-level (miejscowosc) lookup isn't covered here - GUGiK has no unified public REST search at that granularity; use emuia_search for street/address level instead.

Fetch a Polish administrative unit's boundary by TERYT code and add it to the project as a layer.

level is one of "wojewodztwo", "powiat", "gmina". teryt_code must match that level's code format (e.g. gmina codes are 7 digits, zero-padded, like "1465011" for Warszawa) - use teryt_lookup to find the right code by name. The boundary is added as a new memory layer (EPSG:2180) unless target_layer_id is given, in which case it's appended to that existing layer instead. Only a summary is returned; inspect the result with get_layer_sample/features_get.

Fetch a cadastral parcel's geometry from ULDK by its identifier and add it to the project.

parcel_id is the full ULDK identifier, e.g. "141201_1.0001.1867/2". Added as a new memory layer (EPSG:2180) with wojewodztwo/powiat/gmina/ obreb/numer attributes, unless target_layer_id is given to append to an existing layer instead. Only a summary is returned.

Identify the cadastral parcel under a point via ULDK - like map_identify_at_point for parcels.

crs defaults to EPSG:2180 (ULDK's native CRS); pass another EPSG code if x/y are in a different CRS. Returns the parcel id, wojewodztwo/ powiat/gmina/obreb/numer, and its bbox by default, without touching the project. Pass add_to_project=True to also materialize the full geometry as a layer, same as uldk_by_parcel_id.

Fetch an obreb/gmina/powiat boundary and add it to the project as a layer.

level is one of "obreb", "gmina", "powiat" - the granularities ULDK itself is built from. Companion to teryt_to_geometry: both are backed by the same GUGiK PRG boundary registry, so codes found via teryt_lookup work here too. Only a summary is returned.

Search the National Register of Geographic Names (PRNG) - mountains, rivers, settlements, etc.

Best-effort: backed by GUGiK's unified search API, which currently returns HTTP 403 to unauthenticated requests (confirmed live while building this tool) - the exact auth requirement isn't publicly documented. Calling this will likely raise a clear error until that's resolved; it's kept wired in so it starts working the moment GUGiK's auth requirement is confirmed, without another round of tool changes.

Search EMUiA (localities, streets, address points) by name.

Same caveat as prng_search: backed by GUGiK's unified search API, which currently returns HTTP 403 to unauthenticated requests (confirmed live while building this tool). Kept wired in for when GUGiK's auth requirement is confirmed.

Look up Polish postal codes by code prefix or place-name substring.

Backed by a static dataset bundled with the QGIS plugin (offline, no network call) - currently a starter set covering major cities only, not the full national registry (see plugin/qgis_mcp/data/kody_pocztowe.csv). Returns up to limit (default 20, max 50) matches.

Compute a route between waypoints via OSRM.

waypoints is a list of [lat, lon] pairs (>= 2). profile is one of "car" (default, the public router.project-osrm.org demo), "bike", "foot" (community-run routing.openstreetmap.de demo - best-effort, no SLA, see routing_client.py). Pass base_url for a self-hosted OSRM instance instead. Returns distance (m) and duration (s); pass add_to_project=True to also add the route geometry as a line layer (EPSG:4326) rather than returning raw coordinates.

Compute a route between waypoints via Valhalla, with richer costing models than OSRM.

waypoints is a list of [lat, lon] pairs (>= 2). costing is a Valhalla costing model, e.g. "auto", "bicycle", "pedestrian", "truck". Uses a community-run public Valhalla demo by default (best-effort, no SLA - see routing_client.py); pass base_url for your own instance. Returns distance (km) and duration (s); pass add_to_project=True to also add the route geometry as a line layer (EPSG:4326).

Compute a many-to-many travel time/distance matrix via OSRM's table service.

origins/destinations are lists of [lat, lon] pairs; destinations defaults to origins (a full origins x origins matrix). Capped at 25 points per side - split larger matrices into multiple calls. Returns durations_s and distances_m as origins x destinations matrices (entries are null where no route exists).

Compute isochrones (reachable-area contours) from a point using Valhalla.

minutes is a list of travel-time contours in minutes (default [15]), capped at 4 contours per call. costing is a Valhalla costing model, e.g. "auto", "bicycle", "pedestrian". Uses a community-run public Valhalla demo by default (best-effort, no SLA - see routing_client.py); pass base_url for your own instance. Always adds the contour polygons as a new layer (EPSG:4326) - only a summary is returned here.

Optimize the visiting order of waypoints (traveling-salesman-style) via OSRM's trip service.

waypoints is a list of [lat, lon] pairs (>= 3 - below that there's only one order). roundtrip (default True) returns to the start; set False for an open trip ending at the last waypoint. Returns total distance/duration and visit_order (indices into the input waypoints, in visiting order). Pass add_to_project=True to also add the optimized route geometry as a line layer (EPSG:4326).

Find the shortest/fastest path between two points on your own line network layer.

Runs QGIS's native network-analysis algorithm (Dijkstra) on network_layer_id - the layer must already be in the project (roads, trails, etc.). start_point/end_point are [x, y] in that layer's CRS. strategy is "shortest" (default, geometric length) or "fastest" (needs speed_field, km/h, falling back to default_speed where empty). direction_field supports one-way networks if the layer has one. The resulting path is added to the project as a new line layer; only a length/id summary is returned here.

Compute the reachable network area from a point within a travel-cost budget.

Same network-layer requirements as network_shortest_path_layer. cost is the budget in the strategy's unit: layer CRS distance units for "shortest", minutes for "fastest" (derived from speed_field/ default_speed). The reachable network segments are added to the project as a new line layer; only a summary is returned here.

Run a raw Overpass QL query and add the resulting nodes/ways as layer(s).

The query must end with an out geom; statement (or equivalent) so results carry coordinates - a query returning only tags/ids produces no geometry and nothing gets added. Points and ways are split into separate _points/_lines layers since a layer has one geometry type; closed ways (e.g. building outlines) still come back as lines, not polygons. Relations aren't parsed. Capped at 2000 elements per call - narrow the query (smaller bbox, fewer tags) rather than raising the cap.

Download OSM points/ways matching a key=value tag within a bounding box.

bbox is [xmin, ymin, xmax, ymax] in WGS84 (EPSG:4326) - e.g. for POIs like amenity=parking or shop=supermarket. Points and ways are split into separate _points/_lines layers. Capped at 2000 elements per call - narrow the bbox for dense areas.

Download the OSM road network for a named Polish place (city, gmina, powiat, ...).

area_name is geocoded via Nominatim (restricted to Poland) to get a bounding box, then used to query Overpass for roads within it - not an exact boundary clip, and accuracy depends on Nominatim's match (pick a distinctive enough name; check geocode_nominatim first if the result looks wrong). road_types filters to specific highway values (e.g. ["primary", "secondary"]); omit for all road types. Capped at 2000 elements per call - a whole city's road network can exceed that; narrow road_types or the search term if you hit the cap.

Read GetCapabilities from a WMS/WMTS/WFS/WCS endpoint.

url is the service's base endpoint - SERVICE/REQUEST/VERSION query params are added or overwritten automatically, so a full GetCapabilities URL works too. service is one of "WMS", "WMTS", "WFS", "WCS". Returns the advertised layers/feature types/coverages (name, title, CRS, formats/styles/tile matrix sets where applicable) so you know what to pass to wms_add_layer/wmts_add_layer/wfs_add_layer/wcs_add_layer. Capped at 200 entries per call; parsing is best-effort across the various GetCapabilities XML dialects, not a full capabilities model.

Add a WMS raster layer to the project.

url is the WMS service endpoint, layer the server-side layer name (use ows_list_capabilities with service="WMS" to list options and valid crs values). style is a server-side style name (server default if omitted). layer_name names the layer in QGIS (defaults to layer).

Add a WMTS raster (tiled) layer to the project.

url is the WMTS capabilities endpoint, layer the server-side layer identifier (use ows_list_capabilities with service="WMTS" to list options, including available tile_matrix_set names). Pass tile_matrix_set to pick a specific one (e.g. a non-default projection); omit to let QGIS pick the server's default.

Add a WFS vector layer to the project.

url is the WFS service endpoint, typename the server-side feature type (use ows_list_capabilities with service="WFS" to list options). filter is a QGIS expression applied as the layer's subset filter after loading (same syntax as layer_set_subset_filter), not an OGC XML filter. max_features caps how many features the server returns per request (unset uses the server's own default/no limit).

Add a WCS coverage (e.g. a DEM/elevation raster) as a raster layer.

url is the WCS service endpoint, identifier the server-side coverage id (use ows_list_capabilities with service="WCS" to list options).