MCP Dev Summit North America

As MCP deployments grow beyond a few tools, the failure mode isn’t the model—it’s the integration surface. Teams quickly accumulate many MCP servers, inconsistent authentication, duplicated “almost-the-same” tools, and no single place to apply policy, observe behavior, or onboard agents and new systems.

This talk introduces the MCP Gateway pattern: a single MCP entrypoint that federates multiple servers into curated tool surfaces for each agent, workflow, or IDE. Borrowing lessons from the API boom, we’ll show how to structure capabilities into layered building blocks—system access, reusable orchestration, and channel-specific experiences—so you avoid point-to-point spaghetti while keeping integrations composable.

You’ll see a reference architecture that separates front-door caller identity from downstream tool authorization (scoped OAuth or API keys), supports tool allowlists and LLM-facing usage guidance, and adds the controls teams need: routing, versioning, rate limits, audit logs, and end-to-end tracing. You’ll leave with a practical checklist for turning tool sprawl into a governed integration platform that stays interoperable as new agents, clients, and systems arrive.

Additional Authors/Contributors:

• Andrey Velichkevich – Kubeflow Steering Committee
• Zach Sailer - Jupyter Executive Council

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.

How MCP Can Be Used to Build Scalable, Secure, Cloud-Native Agentic Systems on AWS, Azure, and GCP

As enterprises adopt agentic AI, the need for scalable, secure, cloud-native architectures becomes critical. This session explores how the Model Context Protocol (MCP) enables agents to reliably connect with cloud services across AWS, Azure, and GCP using a unified, open standard. Attendees will learn architecture patterns for deploying agents on serverless runtimes and container platforms, strategies for scaling multi-agent workflows, and methods to enforce enterprise-grade security using IAM, secret management, VPC networking, and policy controls. The talk also covers best practices for integrating MCP agents with databases, storage, monitoring, and enterprise APIs, along with techniques for cost optimization and observability. By the end, participants will understand how MCP simplifies interoperability and provides a foundation for building robust, production-ready agentic systems across multi-cloud environments.

The Model Context Protocol (MCP) was designed for robust, cloud-based LLM interactions. However, the proliferation of Small Language Models (SLMs) and their deployment on resource-constrained edge devices (e.g., IoT, mobile) introduces critical challenges to the protocol's current specification. This talk provides a deep-dive into the necessary technical adaptations for MCP to thrive at the edge. We will explore:
Context Window Optimization: Protocol-level strategies for efficient context serialization and deserialization to minimize latency and memory footprint on SLMs.
Asynchronous Context Management: How to handle intermittent connectivity and power-saving modes on edge devices through novel MCP transport and state management mechanisms.
Edge-Native Context Caching: A proposal for a lightweight, on-device context caching layer that adheres to the MCP specification while ensuring data freshness and integrity. Attendees will leave with a clear understanding of the current limitations and a roadmap for contributing to the MCP specification's evolution for the next generation of ubiquitous, context-aware edge AI.

AI agents are rapidly becoming the primary consumers of technical documentation. At Apollo GraphQL, our traffic data shows agents on pace to become our #1 traffic source, prompting a shift in how we write, structure, and serve docs. We now have two distinct audiences that read differently: AI needs patterns, not paragraphs. Connecting sentences that help humans are now wasted tokens.

As the sole documentation engineer at Apollo, I’ve spent the past year building MCP tooling for our docs. This talk covers what worked, what failed, how we tested, and what surprised us.

I’ll walk through the evolution from serving AI full pages to chunked retrieval strategies that balance completeness with token usage. You’ll see how we used AI tooling to restructure docs for AI readability and exposed them as MCP tools agents are compelled to use.

To measure progress, we built an evaluation suite: a sandboxed runner that executes end-user prompts against our MCP server, builds an application, seals the output, then passes it to a second model for scoring against a reference solution and rubric. I’ll demo this live and share how it produced stable metrics in a non-deterministic AI world.

So you found an MCP server on npm that does exactly what you need. You run npx and... now what? One reason people skip security verification for MCP servers is that it's genuinely hard to know what you're actually running. The package works, so why question it?

Here's the thing: MCP servers are getting access to your files, your APIs, your credentials. We should probably know what's in them before we hand over the keys.

In this talk, we'll dig into using OCI containers as the packaging standard for MCP servers - not because containers are trendy, but because they unlock supply chain security constructs that npm and PyPI simply don't have. We'll walk through building repackaging pipelines that verify source packages, run MCP-specific security scans, and produce attestations with Sigstore. Real pipelines, real commands, real output.

Note that this won't solve every trust problem - but it gets us a lot closer to "I know what I'm running" than the current state of affairs.

The Model Context Protocol enables AI assistants to interface with external tools and data sources, but most examples focus on high-level APIs and databases. This talk explores building a production MCP server that exposes low-level Linux kernel observability data to AI assistants, enabling natural language debugging of complex systems.

`scxtop` is an observability tool for Linux's new sched_ext extensible scheduler framework (https://github.com/sched-ext/scx/tree/main/tools/scxtop). By implementing MCP, it allows developers to ask questions like "Why is my application experiencing high scheduling latency?" and receive AI-driven analysis that correlates kernel tracing data, hardware topology, performance counters, and scheduler internals.

Implementing the Model Context Protocol (MCP) in Java poses a challenge: mapping a fast-evolving specification onto a language that favors strict type safety and stability. This session explores the evolution of the official MCP Java SDK, moving beyond naive implementation to address the "hectic" reality of a shifting protocol while providing an enterprise-grade AI enabler.

We’ll discuss the transition from early bidirectional transports to recent Streamable HTTP with sessions and stateless patterns. You’ll learn how Java’s type system led to a "correct-by-construction" approach, ensuring invalid states are unrepresentable, rather than just throwing runtime errors. We will cover Java-specific security considerations, including pluggable authorization hooks designed for a fragmented security ecosystem.

Finally, we’ll share lessons on balancing abstraction with pragmatism: how we decoupled JSON serialization for pluggability and managed the friction between Java’s synchronous heritage and MCP’s asynchronous nature. Whether you're building AI-enabled apps or designing cross-language SDKs, this talk provides a blueprint for robust MCP adoption.

Less than 20% of remote MCP servers fully comply with the MCP Specification.
MCP adoption took off quickly, but full compliance didn't follow at the same pace. Today, partial implementations are common across both clients and servers, and the reasons go beyond just a fast-moving spec.
In this session, we'll walk you through:
-The first version of the MCP Specification and what it was designed for
-How MCP evolved to keep up with the quickly evolving AI ecosystem
-How clients and servers deviate from the spec and why developers choose not to comply
-What we can do to shrink the gap between design and implementation
This isn't a story about bad developers or tight deadlines. It's about how bending the rules has become part of how agents get built.