# Integrations (/integrations)



KubeMQ **integrations** are framework and platform adapters that wire KubeMQ into a
specific framework's programming model — so you keep writing idiomatic NestJS, Spring,
Celery, or Ray Serve code while the adapter handles the messaging underneath. Every
integration is a native gRPC SDK client on port `50000`; there is no separate protocol to
learn and no SDK call to make by hand.

The protocol gateways are documented separately: A2A and MCP under
[**Aiway**](/aiway), and CloudEvents under [**Connectors**](/connectors).

## What an integration is [#what-an-integration-is]

An integration is a thin layer over the native KubeMQ gRPC SDK: it exposes KubeMQ through
a framework's own idioms (decorators, listeners, broker URLs, scalers) and connects to the
broker on `:50000` like any other SDK client.

There are three ways to reach KubeMQ, differing in **what you install** and **where the
bridge runs**:

| Approach                        | What you install                   | Where the bridge runs             | Wire protocol                         | Example                                |
| ------------------------------- | ---------------------------------- | --------------------------------- | ------------------------------------- | -------------------------------------- |
| Native SDK client               | a KubeMQ library                   | in your app                       | gRPC `:50000`                         | [Go](/sdks/go), [Python](/sdks/python) |
| Framework adapter (integration) | the adapter package + the gRPC SDK | in your app, inside the framework | gRPC `:50000`                         | this section                           |
| Server connector                | nothing on the caller              | inside kubemq-server              | HTTP / JSON-RPC / CloudEvents `:9090` | [Connectors](/connectors)              |

An integration **is** a native SDK client — it just sits *inside* a framework, exposing
KubeMQ through that framework's idioms rather than raw SDK calls. A **server connector**,
by contrast, runs inside kubemq-server and accepts a standard wire protocol on the shared
HTTP server, so the caller installs nothing KubeMQ-specific — see
[Connectors](/connectors) for that side of the picture.

Because integrations are gRPC clients, they connect to the **gRPC server on port 50000**,
which runs independently and is **always on**. They are **not** HTTP connectors and need
**no connector enable flag** — `CONNECTORS*_ENABLE` gates only the HTTP connectors
(A2A / MCP / CloudEvents) at `:9090`. The only prerequisite for any integration is a
running KubeMQ broker reachable on `:50000`.

## Architecture [#architecture]

Different apps load different adapters, but they all converge on the same native gRPC SDK
and the same broker on port `50000`.

<Mermaid
  chart="`
graph LR
NEST[&#x22;NestJS service&#x22;]
CELERY[&#x22;Celery worker&#x22;]
KEDA[&#x22;KEDA operator&#x22;]
ANEST[&#x22;nestjs-transport&#x22;]
ACELERY[&#x22;kubemq-celery&#x22;]
AKEDA[&#x22;kubemq-keda-scaler&#x22;]
SDK[&#x22;KubeMQ gRPC SDK&#x22;]
BROKER[&#x22;Message Broker<br/>gRPC :50000&#x22;]

NEST --> ANEST
CELERY --> ACELERY
KEDA --> AKEDA
ANEST --> SDK
ACELERY --> SDK
AKEDA --> SDK
SDK -- &#x22;gRPC :50000&#x22; --> BROKER

class NEST,CELERY,KEDA client
class ANEST,ACELERY,AKEDA aiway
class SDK,BROKER broker
`"
/>

*Each framework loads its own adapter, but all integrations ride the native gRPC SDK to the broker on :50000.*

## Messaging Framework Adapters [#messaging-framework-adapters]

Wire KubeMQ in as the transport for an application-messaging framework.

<Cards>
  <Card title="NestJS" href="/integrations/nestjs" description="Integrate all five KubeMQ messaging patterns into NestJS microservices with custom decorators, dynamic modules, a CQRS bridge, and testing utilities." />

  <Card title="Spring Boot" href="/integrations/spring-boot" description="Production-grade Spring Boot starter and Spring Cloud Stream binder — auto-configuration, KubeMQTemplate, listener annotations, Kotlin, health, and metrics." />

  <Card title="MassTransit" href="/integrations/masstransit" description="Use KubeMQ as the message transport for MassTransit .NET applications, with native queues, events, persistent events, and request/response." />

  <Card title="FastStream" href="/integrations/faststream" description="Build async, event-driven Python apps on KubeMQ with all five messaging patterns through the FastStream framework's broker adapter." />

  <Card title="Watermill" href="/integrations/watermill" description="Use the Watermill Go event-driven library with KubeMQ across Events, Events Store, Queues, and native Commands/Queries." />
</Cards>

## Task & Inference Processing [#task--inference-processing]

Use KubeMQ as the work queue behind distributed task and ML-inference systems.

<Cards>
  <Card title="Celery" href="/integrations/celery" description="Use KubeMQ as your Celery broker and result backend with a one-line broker URL change — the only Kubernetes-native, in-cluster Celery broker." />

  <Card title="Ray Serve" href="/integrations/rayserve" description="Queue-based async and sync ML inference for Ray Serve, backed by KubeMQ via the KubeMQTaskProcessorAdapter." />
</Cards>

## Platform & Operations [#platform--operations]

Integrate KubeMQ with the surrounding platform — provisioning, DI, and autoscaling.

<Cards>
  <Card title=".NET Aspire" href="/integrations/aspire" description="Provision KubeMQ and wire up IKubeMQClient in .NET Aspire apps with health checks, OpenTelemetry, and keyed dependency injection." />

  <Card title="KEDA" href="/integrations/keda" description="Autoscale KubeMQ queue consumers on Kubernetes with the KubeMQ KEDA external scaler, driven by live queue depth." />
</Cards>

## Compare the integrations [#compare-the-integrations]

Every integration is a native gRPC SDK client on `:50000`. They differ by language,
framework, the KubeMQ patterns they expose, and what you install.

| Integration                              | Language / Runtime       | Framework + min version       | KubeMQ patterns                                                | Primary use case                        | Package / install                                      |
| ---------------------------------------- | ------------------------ | ----------------------------- | -------------------------------------------------------------- | --------------------------------------- | ------------------------------------------------------ |
| [NestJS](/integrations/nestjs)           | TypeScript / Node 20.11+ | NestJS 10.x / 11.x            | Events · Events Store · Queues · Commands · Queries            | Decorator-driven NestJS microservices   | `npm i @kubemq/nestjs-transport kubemq-js`             |
| [Spring Boot](/integrations/spring-boot) | Java / Kotlin / JVM 17+  | Spring Boot 3.2.0+            | Events · Events Store · Queues · Commands · Queries            | Spring services + Spring Cloud Stream   | `io.kubemq:kubemq-spring-boot-starter`                 |
| [MassTransit](/integrations/masstransit) | C# / .NET 8.0            | MassTransit 8.5+              | Events · Events Store · Queues · Commands · Queries            | KubeMQ as a MassTransit transport       | NuGet `MassTransit.KubeMQ`                             |
| [FastStream](/integrations/faststream)   | Python 3.11+             | FastStream 0.6.7+             | Events · Events Store · Queues · Commands · Queries            | Async, event-driven Python apps         | `pip install kubemq-faststream`                        |
| [Watermill](/integrations/watermill)     | Go 1.25+                 | Watermill                     | Events · Events Store · Queues · Commands · Queries            | Watermill pub/sub + CQRS in Go          | `go get github.com/kubemq-io/watermill-kubemq`         |
| [Celery](/integrations/celery)           | Python 3.10+             | Celery 5.4+                   | Queues (tasks) · result backend                                | Distributed Python task queues          | `pip install kubemq-celery`                            |
| [Ray Serve](/integrations/rayserve)      | Python 3.10+             | Ray Serve 2.50+               | Queues · Queries · Events                                      | Async / sync ML inference               | `uv pip install kubemq-rayserve`                       |
| [.NET Aspire](/integrations/aspire)      | C# / .NET 8.0 or 9.0     | .NET Aspire 9.0+              | Container provisioning + DI (all patterns via `IKubeMQClient`) | Provision KubeMQ + wire `IKubeMQClient` | NuGet `KubeMQ.Aspire.Hosting` + `KubeMQ.Aspire.Client` |
| [KEDA](/integrations/keda)               | Go (cluster service)     | KEDA 2.10+ · Kubernetes 1.27+ | Queue-depth (`Waiting`) metric                                 | Autoscale queue consumers on Kubernetes | Helm `kubemq-keda-scaler`                              |

## Which integration should I use? [#which-integration-should-i-use]

<Callout type="info">
  Power users: the [comparison matrix](#compare-the-integrations) above lists every
  integration's language, framework version, patterns, and install command side by side.
</Callout>

| If you need to…                                            | Use                                      |
| ---------------------------------------------------------- | ---------------------------------------- |
| Wire KubeMQ into a NestJS app with decorators & DI         | [NestJS](/integrations/nestjs)           |
| Add KubeMQ to a Spring Boot service (template + listeners) | [Spring Boot](/integrations/spring-boot) |
| Use KubeMQ as a MassTransit transport (.NET)               | [MassTransit](/integrations/masstransit) |
| Build async Python apps with the FastStream framework      | [FastStream](/integrations/faststream)   |
| Use KubeMQ as a Watermill pub/sub in Go                    | [Watermill](/integrations/watermill)     |
| Run distributed Python task queues (drop-in Celery broker) | [Celery](/integrations/celery)           |
| Serve async/sync ML inference on Ray Serve                 | [Ray Serve](/integrations/rayserve)      |
| Provision KubeMQ + wire `IKubeMQClient` in .NET Aspire     | [.NET Aspire](/integrations/aspire)      |
| Autoscale queue consumers on Kubernetes by queue depth     | [KEDA](/integrations/keda)               |

## Next steps [#next-steps]

<Cards>
  <Card title="Messaging Patterns" href="/learn" description="The four KubeMQ patterns every integration maps onto — Events, Events Store, Queues, RPC." />

  <Card title="Connectors" href="/connectors" description="Server-side CloudEvents HTTP gateway and wire-protocol connectors (AMQP, MQTT, STOMP, and more) for callers with no KubeMQ SDK. Looking for A2A or MCP? See Aiway." />

  <Card title="Getting Started" href="/deploy" description="Stand up a KubeMQ broker on :50000 before wiring in any integration." />
</Cards>