A modular .NET 10 platform for managing georeferenced assets across web, mobile, and desktop — built on NetTopologySuite, PostGIS, and a plugin-based architecture, and developed as a working lab for AI-augmented engineering practices.
GeoAssets is a personal R&D project exploring how to design a modern, extensible geospatial platform in .NET. The codebase delivers the same domain model across multiple targets (Blazor WebAssembly, MAUI mobile and desktop) from a single shared core, integrates real spatial primitives via NetTopologySuite, and exposes data through standard OGC protocols (WFS, WMS, Shapefile) as well as a PostgreSQL + PostGIS provider.
The project also serves as a deliberate exercise in AI-augmented engineering: it is developed with Claude Code as part of the development loop, and it ships a multi-agent orchestration layer that turns a natural-language request into a compilable plugin command. The CLAUDE.md file at the repo root captures the project's conventions, architectural decisions, and key file paths so that LLM agents operate under the same engineering standards as a human contributor.
Every pull request to this repository triggers an automated code review by Claude Code, using Anthropic's official claude-code-action. Reviewers and contributors can also invoke Claude on-demand in any issue or PR comment by mentioning @claude. Workflow definitions live under .github/workflows/.
- Multi-target delivery from a single core — Blazor WebAssembly for the web, .NET MAUI for mobile and desktop, and a shared Razor Class Library (
GeoAssets.Shared) for components, CSS, and JavaScript interop. - Real spatial library — full integration with NetTopologySuite (geometry predicates, measurements, derived geometries, spatial queries) using SRID 4326 and RFC 7946 GeoJSON.
- Topology as a first-class concept — directed-graph model over features with classical graph algorithms (Dijkstra shortest path, BFS path finding, Kahn's topological sort, cycle detection, connected components).
- Pluggable providers — InMemory, PostgreSQL/PostGIS, REST, WFS, WMS, Shapefile, all behind a uniform repository contract.
- Plugin architecture — extensions live outside the core; Hydrology and GeoJSON import plugins are included as reference implementations.
- Agent-orchestrated plugin generation — a vendor-neutral multi-agent orchestrator (
GeoAssets.Core.Agents) coordinates specialist agents (analysis → plugin-spec authoring → review) that, paired with a deterministic scaffolder (GeoAssets.Commands.Generation), turn a natural-language request into a compilableGeoAssets.Plugin.*command project. - Workflow pipeline — orchestration layer with EF Core persistence and messaging integrations for Kafka and Azure Service Bus.
- Observability layer — dedicated infrastructure project (
GeoAssets.Infrastructure.Observability) for logs, metrics, and tracing. - Identity & authentication — MSAL integration for OIDC/OAuth flows, with EF Core-backed identity persistence.
- AI-augmented development —
CLAUDE.mdprovides a stable contract for LLM coding agents working in the repo.
GeoAssets/
├── core/
│ ├── GeoAssets.Core/ # Domain model, geometry, services, repositories
│ │ └── Agents/ # Vendor-neutral multi-agent orchestration abstractions
│ ├── GeoAssets.Commands/ # Command abstractions
│ │ └── Generation/ # Plugin-command scaffolder (spec → compilable project)
│ ├── GeoAssets.Workflow/ # Workflow orchestration core
│ ├── GeoAssets.Identity/ # Identity domain
│ └── GeoAssets.Infrastructure.Observability/
│
├── apps/
│ ├── GeoAssets.Shared/ # Razor Class Library — components, CSS, JS interop
│ ├── GeoAssets.Web/ # Blazor WebAssembly host
│ ├── GeoAssets.Server/ # Server-side host
│ ├── GeoAssets.MAUI/ # Mobile + desktop app
│ ├── GeoAssets.Commands.Builtin/ # Built-in command implementations
│ └── GeoAssets.Identity.EFCore/ # EF Core identity persistence
│
├── providers/
│ ├── GeoAssets.Provider.InMemory/ # In-memory repository (default for Web/WASM)
│ ├── GeoAssets.Provider.PostgreSQL/ # EF Core + Npgsql + PostGIS (server-side only)
│ ├── GeoAssets.Provider.Rest/ # Generic REST adapter
│ ├── GeoAssets.Provider.WFS/ # OGC Web Feature Service client
│ ├── GeoAssets.Provider.WMS/ # OGC Web Map Service client
│ └── GeoAssets.Provider.Shapefile/ # Shapefile reader
│
├── plugins/
│ └── commands/
│ ├── GeoAssets.Plugin.Hydrology/ # Hydrology-specific commands
│ └── GeoAssets.Plugin.GeoJsonImport/
│
├── workflow/
│ ├── GeoAssets.Workflow.EFCore/ # Persistent workflow store
│ ├── GeoAssets.Workflow.Messaging.Kafka/
│ └── GeoAssets.Workflow.Messaging.ServiceBus/
│
├── examples/
│ └── GeoAssets.Examples/ # Spatial, Topology, Workflow samples
│ └── MultiAgent/ # Anthropic-backed orchestrators + agent-generated plugins
│
├── tests/
│ ├── GeoAssets.Core.Tests/ # Unit tests for the core domain + agents
│ └── GeoAssets.Commands.Tests/ # Unit tests for the plugin-command scaffolder
│
├── CLAUDE.md # AI-agent operating instructions
└── GeoAssets.sln # .NET solution file
- Separation of concerns —
core/knows nothing about UI, infrastructure, or specific data sources. - Provider pattern — all external systems live behind a
IExternalRepositoryFactorycontract, discovered at startup; the UI renders one entry per registered factory. - Plugin extensibility — additional behavior is delivered as plugins, not core changes.
- Workflow isolation — multi-step processes are orchestrated in
workflow/rather than scattered through services. - Multi-target by design — the same domain runs in WebAssembly (no server), in a server-side host, and in MAUI, with feature flags rather than divergent codebases.
- Vendor-neutral agents — the multi-agent orchestration contracts live in
core/with no LLM-vendor dependency; the Anthropic-backed implementation is an interchangeable adapter that lives inexamples/.
GeoAssets treats generating its own extensions as a first-class, AI-augmented workflow. The pipeline is split into two layers so the intelligence is pluggable and the code generation is deterministic and testable:
- Orchestration core (
core/GeoAssets.Core/Agents/) — vendor-neutral abstractions:IMultiAgentOrchestrator,IAgentWorker, theMultiAgentOrchestratorbase (agent registry + dispatch), and theAgentCapability/AgentWorkItemrecords. No dependency on any specific LLM provider. - Deterministic scaffolder (
core/GeoAssets.Commands/Generation/) —GeoCommandPluginScaffoldertakes aGeoCommandPluginSpec(plugin name, command name, category, parameters, handler body) and emits a compilableGeoAssets.Plugin.*project:.csproj, anIGeoCommandHandlerdecorated with[ExportGeoCommand], and a README. No LLM in the loop — fully reproducible. - Anthropic adapter (
examples/MultiAgent/) —AnthropicToolOrchestratordrives a tool-use loop where each registered specialist agent (analysis, code, review, command-plugin authoring) is exposed as a tool.AnthropicCommandPluginOrchestratorchains analysis → JSON plugin spec → review, andCommandPluginGenerationExamplefeeds the resulting spec into the scaffolder to write a real plugin project togenerated-plugins/.
End to end: a natural-language task such as "summarize assets by asset type" becomes a reviewed JSON spec, then a compilable MEF command plugin that the host discovers at runtime via GeoPluginContainer. The Anthropic examples require an ANTHROPIC_API_KEY; the orchestration core and scaffolder build and unit-test without one.
| Area | Technology |
|---|---|
| Runtime | .NET 10 LTS · C# 14 |
| Web | Blazor WebAssembly · Razor Class Library · Blazored.LocalStorage |
| Mobile / Desktop | .NET MAUI |
| Spatial | NetTopologySuite 2.6 · NTS.IO.GeoJSON4STJ 4.0 |
| Map UI | Leaflet 1.9.4 · Leaflet-Geoman 2.18.3 |
| Persistence | PostgreSQL + PostGIS · Entity Framework Core · Npgsql |
| OGC providers | WFS · WMS · Shapefile |
| Auth | MSAL (OIDC / OAuth 2.0) |
| Messaging | Apache Kafka · Azure Service Bus |
| Observability | Logs / metrics / tracing infrastructure project |
| Agent orchestration | Vendor-neutral core abstractions · Anthropic .NET SDK 12.22 (tool-use loop) · claude-opus-4-7 orchestrator · claude-haiku-4-5 sub-agents |
| Testing | xUnit · FluentAssertions · 228 unit tests across GeoAssets.Core.Tests + GeoAssets.Commands.Tests |
| Conventions | RFC 7946 GeoJSON · SRID 4326 · [lon, lat] order |
| Dev workflow | Claude Code (AI-augmented engineering — see CLAUDE.md) |
- .NET 10 SDK
- Optional, for the MAUI app: the MAUI workload (
dotnet workload install maui) - Optional, for the PostgreSQL provider: a PostgreSQL instance with the PostGIS extension enabled
- Optional, for the agent-orchestration examples: an
ANTHROPIC_API_KEYenvironment variable
git clone https://github.com/yuniorsf/GeoAssets.git
cd GeoAssets
git checkout develop
dotnet restore GeoAssets.sln
dotnet build GeoAssets.slncd apps/GeoAssets.Web
dotnet runcd examples/GeoAssets.Examples
dotnet runThe examples cover spatial queries, topology graph algorithms, workflow orchestration, a multi-agent Claude orchestrator, and an agent that generates a MEF command plugin project. The two AI examples are skipped automatically when ANTHROPIC_API_KEY is not set.
# Run the whole suite (228 unit tests)
dotnet test GeoAssets.sln
# …or a single project
dotnet test tests/GeoAssets.Core.Tests/
dotnet test tests/GeoAssets.Commands.Tests/This project is under active development as a personal R&D vehicle. The public API is not yet stable and breaking changes are expected before a tagged release.
Issues, discussions, and contributions are welcome — feel free to open an issue if you want to talk about a specific design decision.
Beyond the technical exploration, GeoAssets is a deliberate exercise in three areas that matter to me as a senior engineer:
- Sustainable architecture for evolving systems — applying separation of concerns, provider patterns, plugin extensibility, and workflow isolation to a non-trivial, multi-target domain.
- Spatial computing done right — using the same algorithms and standards (NTS, RFC 7946 GeoJSON, OGC services, PostGIS) that the GIS industry relies on, rather than ad-hoc reinventions.
- AI-augmented engineering as a daily practice — using LLM agents not as a novelty but as a co-developer that operates under the same engineering standards as a human contributor (clean code, SOLID, tests, peer review).
These threads connect to my broader work as a senior software engineer focused on distributed systems, cloud-native platforms, and the integration of AI into production engineering practice.
Short-term focus areas (subject to change as the design evolves):
- Stabilize the
IAssetRepositorycontract and freeze the public surface exposed to providers. - Expand test coverage beyond
TopoGraph— now covering geometry, serialization, providers, the agent orchestrator, and the plugin scaffolder (228 tests). - Extend test coverage further into the providers and workflow projects.
- Add a CI pipeline (GitHub Actions) for build + test on every PR.
- Add agent-orchestrated generation of MEF command plugins (
GeoAssets.Core.Agents+GeoAssets.Commands.Generation). - Document the plugin contract and the
IExternalRepositoryFactorydiscovery mechanism. - Tag a
v0.1.0once the above are in place. - Add observability examples (OpenTelemetry exporter wiring) using the Observability project.
Released under the MIT License.
Yunior Sánchez Fernández
Senior Software Engineer · Cloud · Distributed Systems · AI-Augmented Development
LinkedIn · yuniorsf@xdicor.com.br