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.

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.

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.

Connecting an LLM to a database is the "Hello World" of agentic AI, but scaling that to production requires solving complex problems in security, context management, and reliability. You can't simply feed a 500-table schema into a context window and hope for the best.
In this session, the creators of the MCP Toolbox for Databases (12.5k stars) break down the specific architecture required to give agents safe, high-fidelity access to your data. You will learn the patterns that power over 6 million monthly tool calls, including:
Raw SQL vs. Semantic Abstraction: A framework for deciding when to give an agent raw query power vs. when to abstract logic into strict semantic tools.
Safety & Governance: Implementing read-only guardrails, query validation, and "Human-in-the-Loop" friction points to prevent accidental data loss or injection risks.
Reducing Hallucinations: How to format database metadata and column descriptions to drastically improve an agent's query accuracy.