Build at the right layer. Ship with repeatable infrastructure.
Extend GeoLibre, call the platform API, connect AI through MCP, add core or companion services, and deploy through Helm, Kubernetes, Terraform and automated release pipelines.
The platform is deliberately not limited to one plugin language, one process model or one AI client.
Extension seam
Use it for
Contract
Tradeoff
GeoLibre frontend plugin
Panels, map tools, data-source browsers, renderers, workflows and client-side analysis
TypeScript/React components, plugin registration, shared map/project state and backend REST calls
Fastest UI iteration; browser security and memory constraints apply
Public API integration
Custom web apps, mobile clients, BI, automations and third-party systems
600+ HTTP routes, OGC/Esri service surfaces, WebSockets and JSON/GeoJSON
Loose coupling; consumers must manage versioning, auth and network failure
Core service module
High-throughput core capabilities, protocol handlers, persistent state and edge-resident processing
Backend package with explicit handlers and lifecycle registration
Highest performance and simplest deployment; changes ship with the server binary
Companion / worker service
Python ML, GDAL-heavy processing, proprietary SDKs, GPU jobs and organization-specific tools
HTTP/job contract, shared or object storage for artifacts, health and capability discovery
Independent dependencies and scaling; requires process supervision and observability
AI / MCP integration
External assistants, agent workflows and tools hosted by QGIS, ArcGIS or other approved systems
Claude/GPT skills, streamable-HTTP MCP server, outbound MCP client and the shared capability registry
Explicit enablement, authentication, tool scope and network controls are required
GeoLibre plugin model
Extend the open frontend without replacing the platform.
GeoLibre uses MapLibre GL JS, deck.gl and an in-browser DuckDB path. More than 30 existing plugins demonstrate the intended integration pattern.
UI
Workflow panels and tools
Add navigation entries, panels, map interactions, editors, charts and specialized business workflows.
DATA
Source plugins
Connect catalogs such as NASA Earthdata, Microsoft Planetary Computer, USGS National Map, FEMA, Overture Maps and organization-specific APIs.
MAP
Layer and overlay adapters
Render raster, vector, MVT, PMTiles, COG, 3D Tiles, I3S, video and deck.gl analytical overlays through shared project state.
SQL
Browser analytical components
Use DuckDB-WASM and Pyodide workers for local processing while keeping large or privileged workloads on the backend.
SYNC
Web and desktop parity
The same frontend detects browser versus Wails desktop mode and calls the corresponding HTTP or native bridge path.
Real product capture
Map & Layers — panels registered through the same plugin pattern described above.The Plugins menu itself — where installed GeoLibre plugins surface to the operator.Split Map View — a plugin-composed panel running alongside the map, not a separate window.
See it in motion
Theme and workspace layout, switched live.
The dark-theme toggle and Split Map View above, recorded running against the real client over the San Francisco Bay 3D map.
Real product captureOne-click switch to dark theme, then Split Map View running the live 3D map and workspace tool launcher side by side.
Companion services as capability packs
Keep specialist runtimes optional and replaceable.
The Python server is a substantial capability pack, but the pattern is language-agnostic. A Rust, Java, .NET, GPU or proprietary-vendor service can follow the same boundary.
GEOPROCESSING
GDAL + WhiteboxTools
Raster/vector conversion, hydrology, terrain, GeoPDF, NITF, COG authoring, tile generation and hundreds of Whitebox tools.
Object detection, wildlife/camera-trap analysis, acoustic classification, natural-language processing and local or OpenAI-compatible model routing.
DOCUMENTS
Publication workers
Generate controlled DOCX, PDF and mapbook artifacts from approved mission baselines, with an HTML fallback when the service is unavailable.
CUSTOM
Organization-specific SDKs
Wrap systems that require their own runtime, license, GPU driver or update cadence instead of embedding them in the core process.
REMOTE TOOLS
Bidirectional MCP capabilities
Register namespaced QGIS/ArcGIS tools into GeoAgent, or enable the authenticated MCP server so external AI clients can invoke governed platform capabilities.
The outbound client extends GeoAgent with approved external tools. The opt-in server exposes the platform’s schema-described capability catalog to compatible external AI clients.
INBOUND
External AI → 3DGeoServEngine
Claude · Cursor · compatible clients→Authenticated MCP server→100+ platform capabilities
Server-build only, disabled by default and protected through the existing bearer-token API boundary.
OUTBOUND
GeoAgent → external systems
GeoAgent→Namespaced MCP client→QGIS · ArcGIS · other servers
Remote tools retain their source identity and can be disconnected without affecting native platform capabilities.
Microservice boundary
Separate dependency risk without fragmenting the product.
The server remains the control plane for identity, catalog, data registration and client contracts. Sidecars perform bounded jobs and return portable artifacts or register a new service.
Core serviceAuth, TLS, rate limits, CORSCatalog and data connectionsOGC/Esri endpoint contractsJob request and health checks
→
Sidecar / workerVersioned request schemaProgress, cancellation and logsCPU/GPU/runtime isolationIdempotent artifact production
From source to a repeatable, policy-controlled release.
The deployment layer now includes Kubernetes packaging, infrastructure-as-code examples, registry publishing and software-supply-chain evidence—not just a Dockerfile.
HELM + K8S
Chart and Kubernetes manifests
Deploy backend and web workloads with configurable services, persistent storage, ingress, secrets, health probes and production scheduling controls.
TERRAFORM
Reusable infrastructure module
Install the Helm release into an existing cluster or follow examples for Amazon EKS, Azure AKS and Google GKE.
CI/CD
GitHub and GitLab release pipelines
Use the existing GitHub Actions workflows or the GitLab CI release pipeline for validation, packaging, publication and release promotion.
REGISTRIES
Container and package publishing
Publish versioned multi-architecture images and installable packages to organization-controlled container and package registries.
SUPPLY CHAIN
SBOMs, signing and checksums
Generate software bills of materials, sign release artifacts and images, and publish checksums for independent verification.
OPERATIONS
State-aware operations and network policy
Configure PVCs, Ingress, Kubernetes Secrets, readiness/liveness probes, web-tier scheduling controls and NetworkPolicy through deployment values. The stateful backend defaults to one replica with a Recreate strategy.
Cloud and existing-cluster examples
Choose the platform without changing the application contract.
The Terraform examples keep the 3DGeoServEngine Helm release consistent while adapting the cluster and registry inputs to each operating environment.
AWS
Amazon EKS
Example inputs and module wiring for an EKS cluster, AWS-region configuration, registry coordinates and an environment-specific Helm release.
AZURE
Azure Kubernetes Service
Example AKS deployment with resource-group, location, cluster, registry and chart configuration kept explicit.
GCP
Google Kubernetes Engine
Example GKE deployment with project, region, cluster, Artifact Registry and Helm release inputs.
Already have a cluster?
Use the existing-cluster Terraform example to install the same chart into a conforming Kubernetes environment without creating new cloud infrastructure.
Deployment profiles
One backend from central server to disconnected edge.
The headless server is a Wails-free build that boots the same application lifecycle as desktop and serves browser frontends plus APIs.
BIN
Native server binary
Run on bare Linux with a configured data directory, no GTK/WebKit GUI runtime and no mandatory Python process.
CTR
Docker container
Package the server and mount persistent data; place behind nginx or Traefik for routing and TLS termination. Use the dedicated deployment paths for Compose, Kubernetes and infrastructure-as-code details.
LAN
On-premises service node
Share feature, tile, imagery, catalog and application services across a private network to desktop, browser and mobile clients.
EDGE
Disconnected deployment
Stage GeoPackage, MBTiles, PMTiles, COG, models and runtime assets so core mapping and analysis continue without cloud dependencies.
API
Baseline production controls
Bearer-token API auth, optional TLS with eager certificate validation, per-client token-bucket rate limiting, configurable CORS and /healthz readiness.
Secure multi-user web platform
From single-operator server to an ArcGIS-Enterprise-style platform.
The server build (-tags server) can become a full multi-user web platform: login, identity, per-user apps, managed data, and filesystem sync—all behind cookie-based session auth that secures every same-origin request, including the tile and image URLs a browser loads without an Authorization header.
AUTH
Cookie sessions + optional OIDC SSO
An httpOnly, SameSite=Strict session cookie secures JSON APIs and tile/WMS/OGC/ESRI image requests alike. Optional OIDC (authorization-code) links to an enterprise IdP; a bootstrap admin and session persistence round out the model. API clients fall back to a bearer token.
PORTAL
App registry and launcher
Users create web maps, dashboards, story maps and experience apps—each with a URL slug (/apps/:slug), owner, and sharing level (private / group / public). A launcher portal browses, filters and launches them; admins see all.
FILES
Sandboxed file manager
A path-sandboxed browse/upload/download/CRUD manager over the data directory with segment-level .. rejection and read-only protection for service-owned subdirs (the catalog DB, secure store, tile caches). Upload collisions are explicit, never silent clobbers.
WEBDAV
Mount the data directory
Mount the platform data dir over WebDAV at /dav/ for desktop-folder-to-platform sync from macOS Finder, Windows Explorer, or Linux davfs2—Basic-auth, read-write, with the same protected-subdir enforcement.
Zero impact on desktop builds.
All web-platform wiring lives behind //go:build server files; the desktop binary never compiles them in. When web auth is unset, behavior is byte-identical to the legacy single-token or pass-through gate—opt-in by environment variable, not by default.
Production assets are ready; security and scaling policy remain environment-specific.
The chart supplies Kubernetes Secrets, probes, persistence and NetworkPolicy controls. The current backend uses a shared SQLite catalog and local data directory, so it intentionally runs as a single writer; scale stateless web components separately. Multi-tenant or regulated deployments should also integrate the organization’s identity-aware proxy, SSO/OIDC, external secrets manager, centralized audit/log aggregation and backup policy.
Extend the platform—and ship it through a repeatable production path.
