MCP Dev Summit North America

MCP launched a revolution in peoples expectations of what Generative AI could achieve. Since then, MCP has been supplemented by other protocols, techniques and extensions.

At Hugging Face we have 1000s of AI Applications deployed, using MCP for interconnectivity, as well as supporting Remote MCP via Inference Providers.

This experience based session explores how inference, compute and storage workloads are shifting in an agentic world, and how MCP supports us in a rapidly changing environment.

We will:
- Contrast how ACP and Open Responses work within our MCP infrastructure and our experience deploying them.
- Explore how Skills, and Code Generation fit, the impact future models will have on the landscape - and why things that may seem obvious in hindsight weren't.
- Discuss the value of multi-model environments and how subagent patterns are critical for certain tasks.
- Report on the trends we see in shifting Agentic and Inference workloads, and MCPs continued role in supporting them
- Examine our unique multimodal demands - and what needs we and our community have to support mixed content.

With the rapid expansion of available MCP servers, we need ways to manage our MCP workloads dynamically. Agents can help us configure agents! This talk explores a set of _primordial_ MCP tools that enable agents to discover, configure, and activate MCP servers at runtime. Rather than focusing on deferred tool loading or context reduction, we examine how agents can discover relevant servers from community registries or private catalogs, elicit configuration from users, and activate tools in the current session. We also examine the use of elicitation URLs as a key building block for constructing portable, reusable MCP configurations.

ChatGPT apps aren't websites or mobile apps. They're a new primitive - lightweight tools invoked within a conversation, surfacing minimal UI to move the user forward.

Websites are destinations. Mobile apps are rich installed experiences with device access. ChatGPT apps are in-flow utilities - joining tasks already in progress. You don't own the screen or control the journey. The model decides when to invoke you.

Wrong mental model = wrong architecture.

Drawing on first-hand experience shipping ChatGPT apps for enterprise clients, we'll cover the principles separating apps that work from those that don't:

- Scoping around single, sharp intent vs building a platform inside a chat
- Where conversational interfaces add genuine value - and where you're fighting the medium
- Leveraging context and memory instead of requiring users to re-establish state
- Using ChatGPT as infrastructure vs distribution
- Testing and iterating when the model controls invocation

We'll walk through concrete implementation examples and lessons learned.

Remember when the mobile app stores launched? The first wave of apps were glorified websites, until someone made you tilt your phone to "drink" a virtual beer. That novelty unlocked the iPhone's true potential: apps that felt native to the device. Today, we're at a similar inflection point with ChatGPT Apps and MCP integrations.

After building dozens of AI-powered applications, we’ve identified some interaction patterns that truly shine and those that fall flat.

This talk explores what makes ChatGPT (& MCP) apps fundamentally different from traditional software.

We'll examine novel use cases like adaptive gaming where models seamlessly adopt complex roles, analytics tools that merge interactive visualizations with conversational insights, and SaaS integrations that surface the right features at the right time.

You’ll learn how to design for this new paradigm: what to expose, how users move through AI-native workflows, and what doesn’t work. Your product now lives inside the highest-distribution AI platform. The real question isn’t whether to build for it, but how to make apps that feel truly revolutionary.

The AI agent ecosystem is fragmenting into competing paradigms, each promising to be the future of how AI systems interact with the world. Skills are simple markdown local workflows using scripts, MCP provides structured tool access across platforms, and Code Mode solves Context bloat problems by executing MCP Tools as code. Most people think these are competing paradigms. They are not.

This talk cuts through the hype and developer frustration to examine what these approaches actually enable, how they overlap, and how do they complete each other.

**Key Learnings**

- Clear mental model explaining the concepts behind Skills, MCP, and Code Mode: what each actually does vs. marketing claims
- How these paradigms complement rather than compete: practical patterns for combining them (Skills in MCP Servers!)
- Decision framework: when to reach for each approach based on your use case, and a map of in which MCP Client each concept is already implemented
- Where the ecosystem is heading and how to future-proof your architectural choices

MCP adoption is growing, but most agent integrations still treat tools as a prompt-time API, burning context tokens on tool definitions, re-copying intermediate results, and losing accuracy along the way. This improper use also leads to unfair criticism of MCP itself.

To address this problem, Cloudflare proposed MCP “code mode”: instead of prompt-time JSON tool calls, the model generates small programs that call tools via an API and run in a sandbox. This dramatically reduces overhead while improving accuracy in chained tool use. An alternative approach recently implemented by Cursor and Anthropic uses dynamic tool discovery to load only the relevant tools into context.

In this talk, we’ll introduce 𝚖𝚌𝚙𝚌 (https://github.com/apify/mcpc), a new open-source universal CLI client for MCP that brings both code mode and dynamic tool discovery to where they shine: the terminal. With persistent sessions, JSON output for scripting, and an MCP proxy for sandboxing, mcpc is an invaluable tool for AI engineers. We’ll live-demo a practical workflow that invokes multiple MCP servers in parallel, filters and transforms results locally, and then turns the interaction into reusable scripts.

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.

As AI agents become more capable, their biggest limitation is no longer reasoning — it’s context. Without access to procedural knowledge and domain-specific understanding, agents struggle to perform real work reliably. In this talk, we’ll explore how Skills address this gap by giving agents on-demand access to company-, team-, and user-specific context.

We’ll look at how Skills can be combined with MCP servers to build safer, more reliable agents, and walk through a real-world example of managing a Postgres database. Using evals, we’ll compare agent performance with and without Postgres-specific Skills, showing how MCP enables secure database access while dramatically improving outcomes.

The next wave of MCP servers face the same challenge: discoverability. If an LLM doesn't know when to invoke your tool, it doesn't exist. This will compound - ChatGPT has ~80 apps today, but as more LLMs launch app stores and MCP adoption accelerates, there will be millions.

Drawing from research optimizing ChatGPT apps since launch, this talk reveals metadata patterns that determine whether AI systems surface your tools - principles that apply directly to MCP server development.

What I'll cover:
- Two-channel discovery: How static search (registries i.e. ChatGPT's App Store) and dynamic invocation (LLM tool selection) require different optimization strategies.

- How LLMs read metadata: How tool names, descriptions, and parameters shape invocation decisions.

- The golden prompt set: Testing methodology using direct, indirect, and negative prompts to measure recall and precision.

- What converts: Fixed templates, workflow handoffs, context preservation vs anti-patterns that fail.

- Measuring success: Citation tracking, false positive monitoring, and iteration loops that compound discoverability gains.