polyglot-go-service

Build a geospatial matchmaking service using Kafka and gRPC.

Updated Apr 21, 2026
One-click install
npx skills add https://github.com/erikshafer/CritterCab --skill polyglot-go-service
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: polyglot-go-service
Source: https://github.com/erikshafer/CritterCab/tree/main/docs/skills/polyglot-go-service
Command: npx skills add https://github.com/erikshafer/CritterCab --skill polyglot-go-service

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

The Skill unit helps solve the problem of building polyglot systems by demonstrating how Go services can interoperate with .NET services, and by providing a concrete example of a geo-matching service within a ride-sharing architecture.

Core Features & Use Cases

  • Cross-Lang Interop: Showcases seamless integration of a Go service within a .NET-centric architecture, leveraging gRPC for inter-process communication.
  • Geo-Matchmaking: Implements a geospatial matching service using an in-memory spatial index to match drivers based on location data from a Kafka topic.
  • Use Case: Develop and maintain a robust geo-matching service within a ride-sharing application that can handle high volume and low-latency requests efficiently.

Quick Start

Build and run the cab-go service within your development environment using Aspire's AddContainer functionality with the Dockerfile located in ../services/cab-go/.

Frequently Asked Questions about polyglot-go-service

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I build a geospatial matchmaking service for a ride-sharing app in Go?

To build a geospatial matchmaking service, this Skill implements an in-memory spatial index that matches drivers based on location data consumed from a Kafka topic and handles ride requests via gRPC. It targets high volume, low latency microservice operations.

How does cross-language interoperability work between Go and .NET microservices?

Cross-language interoperability is achieved by using gRPC for inter-process communication and buf to generate Go code from protobuf files. This allows the Go service to seamlessly integrate and operate within a .NET-centric polyglot architecture.

Can I use Kafka for driver position pings and gRPC for ride requests in the same service?

Yes, this Skill combines Kafka for consuming driver position pings and gRPC for handling ride requests simultaneously. It leverages Wolverine and OpenTelemetry to ensure robust system integration and observability across these concurrent operations.

Does this geo-matching service require Aspire to run in a development environment?

The service is designed to build and run within your development environment using Aspire's AddContainer functionality. It utilizes a Dockerfile located in the services directory to provision the Go microservice container.

What is the best way to handle high volume, low latency location-based matching in a polyglot architecture?

The best way to handle high volume, low latency matching in a polyglot architecture is using an in-memory spatial index paired with gRPC. This Skill provides a concrete example of matching drivers efficiently without relying on external database queries.

Why use buf to generate Go code from protobuf files for a gRPC service?

Buf is used to generate Go code from protobuf files to enforce schema consistency and streamline cross-language interoperability. It ensures the gRPC contract remains synchronized between the Go service and interacting .NET clients.