The Future of Federation ConnectEverything FederateAnything

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
• 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
• 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
• Connect REST and legacy APIs through gRPC
• Full support for GraphQL Federation
• Strictly typed and high performance
• Designed for LLM supported API Integration

How it Works

From Schema to Service

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

1. Design the Schema

• Contract First
• Declaratively define types, fields, and relationships

2. Generate Code

• wgc Magic
• Compile the schema into a gRPC Service proto definition

3. Implement gRPC

• Simple & Fast
• Build your service with generated stubs in any language

Code Transformation

GraphQL Schema

What you write

type Query {
  employee(id: ID!): Employee
}

type Employee {
  id: ID!
  name: String!
  department: String
}

Code Generation

$ wgc generate

Generated gRPC

What you implement

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.

Speed Control

Router Plugins

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

gRPC Services

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

Benefits

Built for Enterprise

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

For Developers

• No GraphQL Server Overhead
• Leverage Existing APIs
• Work in Any Language
• Simplified Development Workflow
• Flexible Extension Options
• Unified API for the Frontend

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

• Do backend teams need to implement GraphQL servers when using Cosmo Connect?
• What advantage does gRPC provide over GraphQL for backend services?
• How are Cosmo Connect gRPC Services different from Apollo Federation Subgraphs?
• How does Cosmo Connect enable LLM code generation?
• Is Cosmo Connect compatible with Apollo Federation Subgraphs?
• How does Cosmo Connect compare to Apollo Connectors?
• What about N+1 queries?

Get Started

Bridge any system into your Supergraph—without GraphQL everywhere.