A new road dataset arrives, and the same GIS task starts again: select the relevant road classes, find nearby buildings, and prepare a map for review. Doing it manually works once. A reusable workflow makes the next update easier to process and check.

With QGIS and Claude available through Vagon’s preinstalled application selection, you can bring your data and AI-assisted workflow into one Vagon Cloud Computer. Claude Code helps prepare the processing script and investigate errors, while QGIS runs the spatial analysis and gives you the tools to inspect the results.

This guide builds a practical example: finding building footprints that intersect a 50-metre buffer around selected roads. You will organize the data, develop the workflow with Claude Code, run it in the QGIS environment, and verify the saved layers.

The result is more than a generated script: an editable GIS project, documented analysis settings, and a repeatable process you can continue using from your cloud desktop.

Source: QGIS Training Manual

Define the Analysis Before Writing the Script

For this walkthrough, the task is to find building footprints that intersect a 50-metre buffer around selected road classes. Claude Code will help turn that requirement into a reusable QGIS workflow inside your Vagon computer.

Start with the roads and buildings provided through the official QGIS vector analysis lesson. Using training data lets you develop the process before applying it to a production dataset.

The analysis needs three inputs:

The selection rule matters. In this example, a building qualifies when any part of its footprint intersects the buffer, including a boundary touch. That is different from requiring its centroid to fall inside the buffer or its entire footprint to be contained.

Give Claude Code that distinction explicitly:

Preserving complete footprints is important. Clipping the buildings to the buffer would cut their geometry at the buffer boundary, producing a different deliverable.

The 50-metre distance is an example setting, not a regulatory threshold. This workflow measures geometric proximity to road lines. It does not establish walking distance, entrance access, or whether barriers separate a building from a road.

Your deliverables will be a reusable processing script, saved analysis layers, a record of the parameters used, and a QGIS project for review. Keeping those together on Vagon gives you a working analysis you can revise and rerun, rather than a one-off map with undocumented steps.

Set Up Your QGIS Workspace on Vagon

Choose QGIS and Claude during Vagon’s Application Selection, then connect to your cloud desktop. Your GIS application and AI assistant are now in the same working environment, alongside the storage and terminal tools needed for the analysis.

Open QGIS and Claude, complete any required sign-in, and prepare a dedicated project folder. For this workflow, use a simple structure:

This separates the source datasets from generated code and results. Keep an untouched copy of the training data in input, and direct all analysis outputs to output.

Bring Your Data into the Cloud Desktop

Use Vagon Files to transfer the downloaded QGIS training dataset into your cloud computer. Extract the archive before loading its layers, preserving the accompanying files and dataset attribution.

In QGIS, browse to the training GeoPackage and add the road and building layers. Save your project as road_screening.qgz in the main project folder. Keeping the project and datasets under a common directory makes their paths easier to manage.

Check that both layers display in the expected location. Open their attribute tables to confirm that records are available. If a layer fails to load, resolve the source path or file problem before introducing automation.

Start Claude Code in the Project Directory

Open a terminal in qgis-road-screening and launch:

If the CLI is not available, complete the Claude Code setup inside the cloud desktop. The preinstalled Claude application and Claude Code’s terminal workflow are distinct entry points.

Ask Claude Code to work only within this project, preserve the inputs, and request approval before running processing commands. Review those permissions when prompted.

You can now move between Claude Code, QGIS, and the saved outputs without transferring the project between computers. The next step is to give Claude an accurate inventory of the data it will process.

Let the Dataset Shape Claude’s Processing Plan

With the source layers open in QGIS, establish their structure before asking Claude Code to generate the script. The workflow needs actual layer names, field values, and coordinate systems, not assumptions based on filenames.

Source: QGIS User Guide

Open Layer Properties → Information for the roads and buildings, then inspect their attribute tables. Collect a compact inventory:

For the road filter, inspect the available categories and decide which belong in the analysis. Claude should not invent field names or silently interpret “main roads.” Give it the exact categories you approve.

Source: QGIS User Guide

Then provide the inventory with this instruction:

QGIS can display layers together through on-the-fly reprojection, but that does not mean their stored coordinates use the same CRS or distance units. Changing the project CRS is also different from transforming a layer. The script must handle that distinction explicitly, following QGIS’s coordinate reference system guidance.

Source: QGIS User Guide

If a source CRS is missing or questionable, stop and resolve it from the dataset documentation. Assigning a plausible CRS can place data incorrectly while still producing an output.

Ask Claude to return a short plan naming the inputs, approved filter, target CRS, operation sequence, and output paths. Review those choices before execution. This gives you a clear agreement about what the script will do, while keeping the geographical decisions in your hands.

Run the Script Through QGIS, Not an Unrelated Python Environment

Claude Code can write Python files in your Vagon project folder, but the code still needs the correct execution environment. A script that imports qgis.core depends on QGIS libraries and their supporting configuration. It will not necessarily run through a separate Python or Anaconda installation.

For this workflow, have Claude create a QGIS Processing script. Once saved in the configured Processing scripts folder, it becomes available in the QGIS Toolbox with explicit input and output parameters. QGIS’s Processing script documentation describes this approach.

Source: QGIS User Guide

Start with a Visible Test Run

Keep the editable script in your project’s scripts directory. In QGIS, use the Processing Toolbox’s Scripts menu to open Processing Script Editor, review the file, and save it to the configured scripts folder.

Ask Claude to implement a Processing algorithm rather than a console snippet. The script should expose roads, buildings, road-filter expression, target CRS, buffer distance, and output destinations as parameters.

After the first successful run, use the QGIS Processing Executor for terminal execution where supported by your installation:

Run these from a QGIS-configured shell or launcher. If the command is unavailable, locate the installed QGIS launcher rather than changing Python packages at random.

This provides a practical progression: inspect the parameters in QGIS first, then let Claude Code help automate a verified operation from the terminal.

Have Claude Build the Road-Proximity Workflow

Now ask Claude Code to create the Processing script in your Vagon project’s scripts folder. Give it the approved dataset inventory and processing plan so it can work with the actual inputs.

Keep the first version focused on one analysis:

Make the Processing Steps Explicit

The script should follow a sequence you can inspect and troubleshoot.

Validate and filter the inputs. Check that both layers load, the required fields exist, and the road expression is valid. A filter returning no roads should produce a clear message, not an unexplained empty building layer.

Reproject working copies. Transform the selected roads and buildings into the approved projected CRS. Confirm that its map units are metres before applying the distance. Preserve the originals.

Source: QGIS Training Manual

Build the road buffer. Use the requested distance and dissolve overlapping buffers into a combined screening area. Explicitly set parameters that affect the geometry, including the segment count used to approximate curves.

Source: QGIS Training Manual

The core Processing call will follow this pattern inside the algorithm:

This is a fragment, not the complete script. The variables must come from validated parameters and earlier processing steps. The segment setting is an explicit example choice, not a universal accuracy requirement.

Extract the matching buildings. Apply Extract by location using the buildings as the input and the buffer as the comparison layer. Use the approved intersects predicate. Do not substitute Clip, which would cut building footprints at the buffer boundary.

Review Before Running

Ask Claude to summarize the generated script’s inputs, algorithm identifiers, output paths, and overwrite behavior. Inspect any additional package installation, network access, or unrelated file operations it proposes.

The run record should capture the road filter, CRS, distance, buffer settings, selected-road count, extracted-building count, and saved output locations. Record the installed QGIS version too.

If invalid geometries prevent processing, have the script report the problem. Do not silently repair or skip features, because either action can change the result. Approve a separate corrective step when necessary, then rerun from the preserved inputs.

Test the Workflow and Inspect the Saved Layers

Run the first test from the QGIS Processing Toolbox inside your Vagon desktop. Choose a small, representative data subset so you can inspect individual buildings without waiting for the full analysis.

Keep the test inputs geographically consistent. If you restrict the buildings to a study area, retain roads just outside its boundary that could still fall within the buffer distance. Cropping both layers at the same boundary can incorrectly exclude nearby roads.

Set the approved filter, projected CRS, and 50-metre distance. Save the results to a new test output rather than replacing an earlier run.

Check More Than Successful Execution

Load the saved buffer and extracted buildings into QGIS alongside the source layers. Use a transparent buffer fill and a contrasting building outline to make the selection visible.

Source: QGIS Training Manual

Inspect examples comfortably inside the buffer, clearly outside it, and close to its boundary. Remember that the distance is measured from the supplied road lines, not necessarily the edge of the paved road.

For an independent cross-check, use QGIS’s Extract within distance on the same projected inputs. Compare source building identifiers, not just total counts. Investigate differences near curved buffer boundaries, where polygon approximation can affect borderline cases.

Let Claude Help Explain Discrepancies

Give Claude Code the processing log, relevant parameters, and mismatched identifiers. Ask it to identify a cause before changing the script. An unexpected count might come from the filter, invalid geometry, or the spatial predicate rather than an execution failure.

Finally, remove the generated layers from the project and reload them from disk. Save the review project as well. This confirms that you have persistent outputs, not merely temporary layers that disappear when the session closes.

Source: QGIS User Guide

Turn the Verified Analysis into a Reusable Task

Once the test passes, keep the script fixed while changing only its declared inputs. Claude Code can help prepare subsequent runs from the same Vagon project directory, using the QGIS environment you have already verified.

Ask it to create a small run configuration containing the source paths, internal layer names, road filter, target CRS, buffer distance, and output destinations. Keep these settings separate from the processing logic so another analyst can understand what changed between runs.

A useful request is:

The QGIS Processing Executor supports running Processing algorithms and script files from the command line. Have Claude inspect the installed command’s help and confirm the script’s parameter names before constructing the invocation. Do not reuse a command copied from a different installation without checking paths and requirements.

Use descriptive run folders, such as output/roads_50m_run_01, and save the corresponding configuration and log. If an output already exists, stop or choose a new destination rather than silently replacing it.

Terminal processing does not automatically update the layers in your open QGIS project. Load the new outputs, confirm their source paths, and repeat the relevant checks. A successful command is evidence that processing completed, not that the analysis meets its requirements.

With the script, settings, logs, and review project together on Vagon, the next dataset update becomes a controlled rerun rather than another round of manual reconstruction.

Where MCP and Computer Use Can Help

The workflow so far uses Claude Code to prepare files and invoke supported QGIS processing commands. It does not require an MCP server or give the agent automatic control over the open QGIS window.

That is enough for many repeatable analyses. Add another connection only when it solves a specific remaining problem.

MCP for Access to the Live QGIS Session

Community projects such as QGIS MCP connect an MCP client to QGIS through a plugin and server. Before using one, check its current installation requirements, supported clients, exposed tools, and permissions.

For this analysis, a suitable integration might help inspect loaded layers or add a generated output to the project. Those capabilities must be verified in the chosen implementation. A working connection does not establish that it supports every Processing algorithm or project operation.

Keep the validated script as the reproducible analysis source rather than replacing it with an undocumented sequence of agent actions.

Computer Use for Interface-Dependent Steps

In a supported Claude desktop workflow, computer use can help with tasks that require application interaction. For example, you could ask Claude to open an output layer’s properties and report its displayed source path and CRS without changing them.

Configure access inside the Vagon desktop where QGIS is running. Launching Claude Code in a terminal alone does not grant screen-control access.

Source: Anthropic

Use either method selectively. Reading layer metadata through a supported tool is preferable to guessing from a map screenshot, while visual inspection remains useful for spotting unexpected placement or incomplete display. Neither replaces checking the saved spatial data.

Match Your Cloud Computer to the GIS Workload

As datasets grow, this workflow can place greater demands on CPU, memory, and storage. Reprojection, buffering, and spatial extraction do not automatically become faster with a more powerful GPU.

Use Vagon’s scalable performance to select resources appropriate to the workload while retaining your applications and files. Start with the representative test, then inspect processing time, memory use, and output size before scaling up.

Keep sufficient storage for source data, intermediate layers, and separate runs. Better-suited hardware can support a larger analysis, but it cannot correct an unsuitable CRS, an incorrect filter, or incomplete source data.

Final Thoughts

Using QGIS with Claude Code works best when automation produces an analysis you can inspect and repeat. Keep the inputs intact, make the parameters explicit, and verify saved layers rather than relying on a completion message.

Vagon brings that process into one cloud desktop: QGIS for processing and review, Claude Code for script development, and your project files alongside both.

Create your Vagon Cloud Computer, select QGIS and Claude, and start with the training dataset. Build and check one road-proximity analysis, then reuse the validated workflow with your own approved data.

FAQs

Can Claude Code run QGIS processing tasks?

Yes, when it has permission to invoke a correctly configured QGIS execution environment. It can prepare scripts and run supported commands through qgis_process. Writing Python code alone does not establish that the required QGIS libraries, providers, and inputs are available.

Do I need an MCP server?

No. This workflow uses a Processing script and QGIS’s supported execution tools. MCP is an optional connection for operations exposed by a compatible integration, such as interacting with a live QGIS session. It is not required to generate or execute a processing script.

Is Claude Code ready when I select Claude in Vagon?

Claude is available through Vagon’s preinstalled application selection. For the terminal workflow, confirm that the claude command is available and complete any required Claude Code setup and authentication. Application availability does not automatically include an AI subscription or API usage.

Can I use Anaconda instead of QGIS Python?

Not as a direct substitute without configuring a compatible environment. PyQGIS depends on QGIS libraries and supporting components. For this guide, run the first analysis through QGIS Processing and use the installation’s configured command-line environment for subsequent runs. Keep unrelated Python environments separate.

Can I use this workflow from a Mac?

Yes. You can access your Vagon cloud desktop from a Mac while QGIS, Claude Code, and the processing tools run inside the cloud computer. Keep paths and commands appropriate to that cloud operating system, rather than using local Mac paths in Windows processing commands.

Does the buffer calculate walking distance?

No. It represents geometric distance from the supplied road lines in the selected analysis CRS. It does not account for entrances, crossings, fences, or traversable routes. Walking-distance analysis requires suitable network data and a separately defined routing method.

Will a GPU accelerate every QGIS operation?

No. Performance depends on the algorithm and its implementation. This vector workflow can depend heavily on CPU, available RAM, and disk access. Evaluate a representative run before changing resources, and do not assume GPU capacity will accelerate a particular Processing algorithm.

Can Claude Code work with confidential GIS data?

Only where your organization’s policies and applicable service terms permit it. Review what files, commands, and external services the agent can access. A cloud desktop separates the workspace from your personal device, but does not make its contents inaccessible to the agent. Use appropriately limited or de-identified data where necessary, and never include credentials in prompts or logs.