gRPC Conf 2025

Protobuf holds schema evolution as a central design principle. In 2024 we launched Protobuf Editions, a new evolution mechanism that allows for evolution of the code generated from a schema and the Protobuf language itself. This talk will discuss how Editions works in open-source ecosystems, what we've done so far, and some of what's coming in the future.

This talk explores Cloudflare's multi-year work that helped drive new Internet protocol standards development and large-scale deployment; culminating in work to bring support for gRPC over HTTP/3 to the edge.

QUIC is a transport protocol that offers security and performance advantages compared to TCP and TLS. HTTP/3 defines how QUIC's multiplexed streams can be leveraged to avoid head-of-line blocking issues. Cloudflare launched early support in 2018, and open sourced the quiche Rust library in 2019. With close to 7 years deployment experience, there's lots to share.

We launched support for gRPC over HTTP/2 in 2020. We'll explore how we implemented it within a legacy stack using gRPC-Web conversion, and touch on broader HTTP/2 DoS vulnerabilities that have hit headlines since.

The talk concludes by covering the gRPC over HTTP/3 protocol, implementation details (including testing with h3i), and how our gRPC-Web approach yields seamless version agility for a migration path to HTTP/3.

When the volume of incoming requests greatly exceeds cluster capacity, some calls will fail. Instead of failing calls randomly, an overload protection mechanism can load shed low priority calls. But when should load shedding be engaged? Have the requests been correctly prioritized? By successfully answering these questions for each gRPC service, we can safely operate with fewer resources while minimizing the risk of an overload event.

At Netflix, we built a system to automatically tune, test, and deploy customized load shedding configurations to each cluster. We will give an overview of how we reason about the available buffer for a cluster, our automation to achieve this buffer, what did and did not work for system utilization signals, and how these techniques are allowing us to run both fewer clusters and smaller clusters.

Streaming is where gRPC truly shines—but building scalable, low-latency real-time systems requires more than just enabling a stream. This session takes a deep dive into gRPC streaming paradigms—client-side, server-side, and bidirectional—and how to implement them effectively for live data applications such as telemetry ingestion, collaborative tools, and chat systems.

We’ll explore advanced patterns for managing stream lifecycle, backpressure, flow control, reconnections, and message ordering. You'll also learn how to integrate streaming with observability stacks and handle failure gracefully using retries, deadlines, and context management.

Through architecture diagrams and examples, we’ll demonstrate how to scale streaming infrastructure to support high-concurrency workloads.

Whether you're building live dashboards or full-duplex APIs, this session will provide the technical depth and operational guidance to stream at scale with gRPC.

Are you passionate about Protocol Buffers? Join fellow Protobuf users in this interactive Birds of a Feather session! This isn't a typical presentation; instead, it's a unique opportunity to engage in open discussion, share your experiences, and get answers to your burning Protobuf questions from the collective wisdom of the group. Come prepared to connect, learn, and contribute!

Unlock robust, scalable LLM integrations using the Model Context Protocol (MCP) with gRPC. This session explores MCP, an emerging open standard by Anthropic for LLM context and tool use, and demonstrates how gRPC is ideal for serving production MCP servers with an adapter. Learn to build efficient, observable, and production-ready LLM applications, overcoming common integration challenges. Discover architectural patterns for structuring services, managing complex context, and ensuring reliable LLM interactions in your gRPC ecosystem.

The Model Context Protocol (MCP) has quickly become the standard for exposing tool interfaces to LLMs since its debut in late 2024. But MCP is JSON Schema-based and HTTP-first - so where does that leave gRPC and Protobuf? At Redpanda Data, we believe they can and should coexist.

In this session, we introduce protoc-gen-go-mcp, an open-source plugin that generates MCP servers from existing gRPC APIs. With just one additional protoc plugin, developers can expose structured, validated MCP endpoints backed by gRPC - no manual glue code needed.

We’ll explore:

- How MCP works and why it matters for gRPC developers
- Benefits of reusing the Protobuf ecosystem for MCP
- The design and usage of protoc-gen-go-mcp
- Schema translation challenges between Protobuf and JSON Schema
- LLM vendor differences and what they mean for API developers

Attendees will gain a clear path to exposing gRPC services as MCP tools - enabling LLM integration without sacrificing infrastructure or tooling.