The Future of Federation
Connect Everything
Federate Anything

Cosmo Connect combines the strengths of GraphQL and gRPC.

Query all your APIs, connect every system. No complex rewrites or migrations.

gRPC Simplicity
Strictly typed, performant, simple
Federation Power
Entities are the @key to success
Language agnostic
Supports Go, Rust, Java, Python, and more
The Evolution

From fragmented APIs to unified
GraphQL Federation

GraphQL as the foundation of a Microservices Architecture never felt right,
Cosmo Connect is here to fix that.

Schema Stitching

Gen 1: The Foundation
Backend for Frontend
Stitching schemas together
API 1
API 2
API 3
Quick to implement
Works with any API
Requires manual stitching
Not declarative
Doesn't scale across teams

Apollo Federation

Gen 2: The Great Leap
Apollo Router / Cosmo Router
✓ Composable Schemas
GraphQLService 1
GraphQLService 2
GraphQLService 3
The power of Entities
Scales across many teams
Forces GraphQL everywhere
Steep learning curve
Performance overhead of GraphQL

Cosmo Connect

Gen 3: The Evolution
Cosmo Router
Supports GraphQL, gRPC Services and Plugins
gRPCService 1
gRPCService 2
GraphQLService 3
Connect REST and legacy APIs through gRPC
Full support for GraphQL Federation
Stricly typed and high performance

Designed for LLM supported API Integration

Never write API glue code again.
Cosmo Connect is optimized for LLM code generation.

How it Works

From Schema to Service

Three simple steps. Cosmo Router handles the complexity. Your code stays simple.

01.

Design the Schema

Contract First

Declaratively define types, fields, and relationships

02.

Generate Code

wgc Magic

Compile the schema into a gRPC Service proto definition

03.

Implement gRPC

Simple & Fast

Build your service with generated stubs in any language

Code Transformation

See how your GraphQL schema becomes gRPC service code

GraphQL Schema

What you write

1
type Query {
employee(id: ID!): Employee
}
type Employee {
id: ID!
name: String!
department: String
}

Generated gRPC

What you implement

2
service EmployeeService {
rpc QueryEmployee(
QueryEmployeeRequest
) returns (
QueryEmployeeResponse
);
}
message QueryEmployeeRequest {
string id = 1;
}
message QueryEmployeeResponse {
Employee result = 1;
}

What Makes This Different

Beyond simplicity, this approach delivers real business value

Lightning Fast Development

Schema changes automatically generate new service contracts. No manual protobuf wrestling, no version conflicts.

End-to-End Type Safety

Types flow seamlessly from GraphQL schema through generated code to your service implementation.

Any Language, Any Stack

Implement services in Go, Rust, Java, Python, or whatever makes your team productive.

Simple Service Logic

No GraphQL complexity in your services. Just clean RPC methods that do one thing well.

Production Ready

All complexity lives in the router - query planning, DataLoader batching, performance optimization. Your services stay simple and focused.

Gradual Migration

Start with one service, migrate at your own pace. No big bang rewrites required.

The best part? Your frontend never knows the difference. It's still GraphQL all the way down, but your backend gets to be brilliantly simple.

Technology Choice

Why gRPC First?

Connect translates GraphQL to gRPC because it's the sweet spot for modern service communication.

Performance

Binary wire format; avoid double GraphQL parsing at the service level.

Coverage

Great tooling across Rust, Java, Python, C#, Go, and more.

Simplicity

Clean RPC handling, no GraphQL internals

Deployment Options

Choose Your Path

Modular Monolith, Microservices, or a mix of both. It's up to you.

Router Plugins

Speed
  • Co-located processes
  • Publish via Cosmo registry
  • Minimal ops overhead
  • Ultra-low latency

Example: Stripe/Slack wrapper

gRPC Services

Control
  • Own deployments
  • Independent scaling
  • Any infra (LBs, k8s, serverless)
  • Full operational control

Example: Employee/Identity service

Benefits

Built for Enterprise

Unlock the power of federated GraphQL without forcing your teams to rewrite everything

No GraphQL Server Overhead

Simply implement gRPC contracts while the router handles federation complexity.

Leverage Existing APIs

Wrap existing REST, SOAP, or gRPC services without costly rewrites.

Work in Any Language

Build services in Go, Java, C#, Python, Rust thanks to gRPC ecosystem.

Simplified Development Workflow

Avoid GraphQL quirks with straightforward request/response semantics.

Flexible Extension Options

Choose Router Plugins for fast iteration or gRPC Services for full control.

Unified API for the Frontend

Single GraphQL interface while backend teams work independently.

Use Cases

Works for Any Architecture

Whether you're building from scratch or modernizing legacy systems, Connect adapts to your architectural reality

New

Greenfield Projects

Small RPC surface; move fast without GraphQL internals.

  • Start with simple RPC contracts
  • No GraphQL complexity in services
  • Rapid iteration and deployment
Existing

Legacy Migration

Wrap REST/SOAP/monolith; keep investments; expose via Connect.

  • Preserve existing investments
  • Gradual modernization path
  • Bridge old and new systems
Questions & Answers

Frequently Asked Questions

Everything you need to know about implementing gRPC services with GraphQL federation

Get Started

Bridge any system
into your
Supergraph—
without GraphQL everywhere.