MCP Dev Summit Mumbai 2026

**Space Limited - First Come, First Served.  Please bring a fully charged laptop to the workshop**

Most MCP tutorials stop at "hello world." This session goes further. We will walk through how we built a production-grade, open source MCP server template at Red Hat, covering FastMCP + FastAPI integration, multiple transport protocols (HTTP, SSE, streamable-HTTP), OAuth with PostgreSQL token storage, structured logging, and OpenShift deployment manifests. Attendees will leave with a clear mental model of what it actually takes to go from a local MCP prototype to something you can run in production on Kubernetes. We will also share the design decisions we made, the mistakes we avoided, and how developers can use this template as a starting point for their own MCP servers.

We design MCPs assuming idempotency, apply the same action twice nothing changes, reconcile repeatedly, and state is declarative.

But in reality, most MCP actions are only partially idempotent, because beneath the abstraction external systems mutate independently, side effects escape the control plane, ordering of operations matters, and “same input” doesn’t always mean “same result”. At scale, MCPs rely on many things like reconciliation loops, declarative APIs, retry-based execution.

We’ll unpack how MCPs unintentionally, violate idempotency through hidden side effects, depend on ordering guarantees that don’t exist, produce divergent states under retries, mask unsafe operations behind “safe” abstractions. This isn’t a talk about retries or Kubernetes patterns. There are no controller frameworks, just a deeper examination of why MCPs aren’t as safe as we assume, and how to design them with fewer hidden risks.

Because the most dangerous systems aren’t the ones that fail.
They’re the ones you believe are safe to retry.

MCP tools give AI agents direct access to external services - production databases, internal APIs, third-party platforms. But most teams deploying MCP today have no answer to a simple question: who authorized that tool call?

MCP has made remarkable strides in standardizing agent-to-tool connectivity - but AuthN and AuthZ at the tool invocation layer remain an open problem. Tool calls are dynamic and runtime-driven; static Kubernetes RBAC has no vocabulary for per-tool, per-agent, or per-parameter enforcement. There is no native spec primitive to say "only this agent can call this tool."

In multi-tenant environments this gets worse - one misconfigured agent can invoke tools across tenant boundaries and nobody finds out until the damage is done. Teams filling this gap today are relying on custom middleware, app-level checks, or nothing at all.

This talk explores where MCP's authorization model falls short and how policy-as-code closes the gap - with Kyverno as one strong implementation path. The session walks through real ClusterPolicy configurations, multi-tenant isolation patterns, and hard-won lessons from tuning enforcement without breaking production agents.

Jupyter Notebooks are critical medium for code, data, and ML, demanding a paradigm shift for AI assistance. With Jupyter's real-time collaboration and cloud-native evolution, it's becoming a powerful portal to a full data platform, beyond mere notebooks.

This session explores MCP as the essential framework for human-AI synergy within this expanded Jupyter ecosystem. Leveraging Jupyter's extensibility, MCP expands its API, opening gateways to services across the entire data, ML, and AI landscape. By extending Jupyter’s real-time collaborative models, MCP enables AI agents to seamlessly co-create alongside human developers. This integration moves beyond traditional AI coding assistance, fostering true parallel work without conflicting edits, eliminating friction and accelerating development.

The speakers will give the live demo showing how MCP provides the blueprint for connecting AI assistance directly with the Jupyter environment, both locally and in the cloud. This empowers builders to redefine human-AI interaction and unlock unprecedented productivity across the entire AI development lifecycle – from data preparation and feature engineering to LLMs fine-tuning and evaluations.

Everyone's heard the AAIF framing: MCP handles agent-to-tool, A2A handles agent-to-agent. Clean in theory. In practice, every multi-agent system lives at the boundary of both, and that boundary has no standard.
Context gets dropped. Errors go silent. A state that survived an entire A2A task lifecycle vanishes the moment it crosses into an MCP tool call. Nobody is talking about this publicly.
This session replaces the "vertical vs horizontal" mental model with something more honest: a precise seam diagram showing what each protocol guarantees, what it doesn't, and what falls into the gap. We'll go deep on MCP's Tasks primitive (SEP-1686)- including its two admitted gaps: no retry semantics, no expiry policies. We'll map the real failure modes developers are hitting today, drawn from open GitHub issues across both protocol repos.
Then a live demo using Google's open-source A2A sample repo: no custom code. We'll run a real multi-agent task, cross the protocol boundary, sever the trace header, and watch the silent failure happen in real time.
You'll leave with a clear mental model, a three-point failure checklist, and a concrete picture of what the spec needs next.

At Motorola Solutions, downtime isn’t just an inconvenience—it’s a public safety risk where lives are at stake. This session explores how we revolutionized incident response for mission-critical applications by moving beyond fragmented tools and alert fatigue. Historically, siloed data across Kubernetes and Grafana led to 45-minute MTTRs and manual context-switching.

We will detail our adoption of the Model Context Protocol (MCP), specifically utilizing Red Hat Kubernetes and Grafana MCP servers to build an AI-assisted operations layer. Learn how this unified context allows an AI agent to correlate metrics with cluster states in seconds, reducing MTTR to under 4 minutes while sustaining 99.99% uptime.

We'll share our production architecture for natural language incident resolution and our "human-in-the-loop" approach that ensures SREs remain in control of all write operations. Attendees will leave with practical guidance on scaling reliability in regulated environments and empowering junior engineers with senior-level operational context. Discover how to turn fragmented data into a mission-critical intelligence amplifier.

MCP brings structure and standardization to how LLMs interact with tools and resources—but that power comes with cost. We’ve built multiple MCP servers across different use cases, and not all of them should have existed.
This session distills hard-earned lessons from real-world implementations: where MCP created long-term leverage, where it introduced unnecessary complexity, and where a direct API call would have shipped faster and cleaner. We’ll share a clear evaluation checklist you can use before starting your next build—so you choose MCP intentionally, not reflexively.