Obot.ai CEO Sheng Liang Deploys Gateway to Secure Enterprise AI Tools
Ai4
Enterprise adoption of the Model Context Protocol requires centralized proxies and task-oriented server abstractions to mitigate severe data security risks from unverified API executions.
## Background
This talk was delivered by Sheng Liang, Cofounder and CEO of Obot.ai, on the Ai4 YouTube channel on August 26, 2025. According to the page description, the presentation discusses the best practices, security challenges, enterprise authentication, and roles for IT teams implementing Model Context Protocol (MCP) servers across their organizations.
## TL;DR
Sheng Liang explores how the Model Context Protocol (MCP) evolved from early tool-calling concepts into a critical enterprise standard for AI agents. He outlines four core enterprise pillars—Discover, Secure, Use, and Build—highlighting the necessity of centralized catalogs, proxy governance, and high-level tool design over raw REST API translations. The talk concludes with an overview of how Obot.ai's open-source MCP Gateway addresses these operational and UI challenges for non-technical enterprise users.
## Atmosphere & style
The presentation carries a professional, insightful, and authoritative enterprise-tech tone typical of industry summits. Speaking as an experienced founder, Liang balances technical depth with accessible high-level guidance, making complex protocol architectures approachable. The delivery feels pragmatic and forward-looking, driven by real-world lessons from early enterprise deployments rather than theoretical hype.
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=4s) Obot.ai pivoted from its own proprietary agent framework to fully adopt Model Context Protocol (MCP) as the industry standard.
- [00:04](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=4s) Tool and function calling, popularized at OpenAI DevDay in November 2023, is what transforms basic LLM text generators into autonomous, API-executing AI agents.
- [00:35](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=35s) Over 10,000 public MCP servers exist today across directories like mcp.so, but running unverified executable code poses severe enterprise security and data exposure risks.
- [00:35](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=35s) Existing MCP clients like Claude Desktop are engineered primarily for technical developers, leaving a usability gap for ordinary enterprise business users.
- [00:35](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=35s) Enterprise IT adoption of MCP relies on four critical pillars: Discovering safe servers, Securing access, Providing usable non-developer UIs, and Building quality connectors.
- [00:55](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=55s) To govern MCP, enterprise IT departments need centralized catalogs and proxy gateways to enforce Single Sign-On (SSO), audit logging, and threat filtering.
- [01:07](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=67s) MCP servers can return dynamic UI code directly to clients, enabling custom interactive widgets and forms inside standard chat interfaces.
- [01:30](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=90s) Directly translating granular OpenAPI/REST schemas into MCP tools causes LLM performance issues; MCP servers should instead expose high-level, task-oriented abstractions.
- [01:30](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=90s) Exposing autonomous agents as MCP servers directly eliminates the need for separate, redundant Agent-to-Agent (A2A) communication protocols.
- [01:36](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=96s) The open-source Obot MCP Gateway provides proxy governance, central server catalogs, and business-focused client interfaces under a commercial open-source model.
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=4s) Introduction and the Evolution of MCP
Sheng Liang, tech entrepreneur and co-founder/CEO of Obot.ai based in California, begins his talk by introducing his background and how his team entered the Model Context Protocol (MCP) ecosystem. Obot.ai has been building AI agents, chatbots, and tools for several years, predating the release of MCP. Originally, the company developed a competing framework, but they soon recognized the industry's direction and fully embraced MCP as a standard. Earlier in the year, they co-hosted an inaugural MCP Dev Summit featuring technical leaders, steering committee members, and contributors from Anthropic and Microsoft. The next summit is open to the public and scheduled to take place in London.
Reflecting on the history of AI tooling, Liang notes that everything began with function and tool calling, which was famously showcased at OpenAI DevDay in November 2023. That release catalyzed the development of roughly a dozen frameworks allowing agent developers to build tool-invoking AI systems. While MCP initially flew under the radar, its widespread adoption by tools like Claude Desktop and Cursor cemented it as an industry standard. Without tool calling or MCP, AI remains limited to answering questions or generating text with a human in the loop; tool calling enables autonomous API execution, transforming basic chatbots into functional agents.
- **Dev Summit:** Co-organized an inaugural MCP Dev Summit with leaders from Anthropic, Microsoft, and the MCP steering committee, with the next public event hosted in London.
- **Origins of Tool Calling:** Traces the widespread adoption of AI tool integration back to OpenAI DevDay in November 2023.
---
### [00:35](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=35s) Enterprise Challenges in Adopting MCP
While working with enterprise customers attempting to deploy MCP across their organizations, Liang identified a clear pattern of hesitation. IT and business teams love the concept of MCP but struggle with deployment due to security, UX, and administrative hurdles. Claude Desktop, for example, is engineered specifically for developers and is far too technical for ordinary business users or sales representatives. Moreover, public MCP directories like `mcp.so` list over 10,000 servers, with dozens to hundreds being added every day.
Unlike early web pages—which might have looked rudimentary but were relatively harmless—MCP servers contain executable code that connects directly to internal data sources and external APIs. Running unverified MCP servers creates severe data exposure and security risks. Enterprise IT departments repeatedly voice concerns around four main pillars: Discovery, Security, Use, and Build.
- **Scale of the Ecosystem:** Over 10,000 MCP servers exist publicly, with dozens or hundreds added daily across directories like `mcp.so`.
- **Core Enterprise Pillars:** Enterprise feedback centers on four critical areas: **Discover** (finding safe servers), **Secure** (preventing backdoors), **Use** (providing non-developer UIs), and **Build** (creating high-quality connectors).
---
### [00:55](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=55s) Discover and Secure: Establishing Governance
Solving the discovery problem requires enterprise catalogs, drawing parallels to the early web era and directory services like Yahoo, or modern SaaS management tools managed via Okta. IT departments need centralized catalogs listing approved local and remote MCP servers. While future web services may natively expose themselves as websites, mobile apps, APIs, and authenticated MCP endpoints, today's landscape requires IT admins to explicitly manage approved servers.
Securing these connections requires enforcing access policies. While blocking developers from loading arbitrary MCP servers into local IDEs or Claude Desktop instances is "neither technically nor culturally possible" outside of high-security military or government environments, IT teams can control business users. By enforcing single sign-on (SSO) and corporate credentials only on approved catalog servers, organizations establish a single point of control. This centralized proxy enables audit logging, usage reporting, access control, and threat filtering.
- **Centralized Catalog:** Enterprise IT governance relies on curated MCP server directories, similar to Okta SaaS directories.
- **Access Control & Auditing:** Central proxies allow enterprise single sign-on (SSO), precise access control rules, usage logging, and filtering of unsafe data calls.
---
### [01:07](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=67s) Use: Chatbot Clients and Rich UI Extensions
MCP clients generally fall into two categories: interactive chatbots (such as Claude Desktop, Cursor, or VS Code) and embedded background agents. Liang views chatbots as "a dime a dozen," drawing an analogy to web browsers where a few underlying standards support many front-end implementations. Non-developer business users will naturally gravitate toward simple, Chat-GPT-style conversational interfaces.
An exciting development in the MCP standard is the capability for MCP servers to return not just raw text or JSON data, but also UI code. This allows the client to render dynamic, custom interfaces—such as an interactive stock trading canvas or data entry form—directly inside the chat window. This rich user experience elevates the chat window into a potential replacement for traditional mobile or desktop applications.
- **Dynamic UI Rendering:** Advanced MCP servers can supply custom UI code directly to the client, embedding rich widgets and interactive forms inside conversational interfaces.
- **Client Types:** Client consumption occurs either through interactive chatbot UIs or programmatic background agents.
---
### [01:30](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=90s) Build Best Practices and Avoiding Open API Pitfalls
Building MCP servers is generally straightforward using SDKs like `fastmcp` in Python. While hosting platforms (such as Cloudflare, AWS, or vSphere) exist to deploy these services, building the server logic itself is rarely the main blocker. The primary mistake organizations make is directly converting fine-grained OpenAPI/REST schemas into MCP servers.
APIs designed for developers are overly granular; for example, creating an email via the Microsoft Graph API requires navigating complex graph nodes across dozens of API calls. Large Language Models struggle with such multi-step granularity. Instead, MCP servers should expose high-level, task-oriented abstractions (e.g., a single `create_email` MCP call) designed around clear agent use cases. Additionally, Liang notes that agents themselves are increasingly exposed as MCP servers, rendering separate Agent-to-Agent (A2A) protocols largely redundant.
- **Tooling:** Highlights `fastmcp` as a primary Python framework for authoring MCP servers.
- **Design Guidance:** Warns against raw OpenAPI-to-MCP translation; urges developers to create task-focused, consolidated MCP tools rather than exposing low-level REST endpoints.
---
### [01:36](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=96s) Introducing Obot.ai MCP Gateway and Community
Obot.ai sponsors the event and provides an open-source solution called the Obot MCP Gateway. Operating under a Red Hat-style commercial open-source model, the code is 100% open source on GitHub, offering optional enterprise support subscriptions around $10 per month. The platform includes proxy routing, server catalog management, and a dedicated client interface designed specifically for non-technical enterprise users who lack developer tools like Cursor.
Liang concludes by praising Anthropic's open management of the MCP standard, noting that because MCP is not Anthropic's primary core business, they have fostered an unusually open community with frequent developer summits and active external contributions.
- **Obot MCP Gateway:** Open-source platform offering proxy governance, catalog management, and business-user chat interfaces.
- **Source Code & Community:** Project available on GitHub; encourages participation in ongoing community MCP Dev Summits.
## Notable quotes
> How can we make sure that the tens of thousands of MCP servers on the market are safe to use? — Sheng Liang
> How can we implement enterprise-level authentication and access control? — Sheng Liang
> How can we enable in-house developers to build AI agents and applications on these MCP servers? — Sheng Liang
> [00:55](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=55s) neither technically nor culturally possible — Sheng Liang
> [01:07](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=67s) a dime a dozen — Sheng Liang
## Mentioned
Sheng Liang, Obot.ai, Model Context Protocol (MCP), Anthropic, Microsoft, OpenAI, Claude Desktop, Cursor, mcp.so, Okta, VS Code, Python, fastmcp, Cloudflare, AWS, vSphere, Microsoft Graph API, Obot MCP Gateway, GitHub, Red Hat
## Video description
Sheng Liang, Cofounder and CEO, Obot.ai
Abstracts
Organizations seeking to leverage MCP servers to enhance business processes face several challenges. How can we make sure that the tens of thousands of MCP servers on the market are safe to use? How can we implement enterprise-level authentication and access control? How can we enable in-house developers to build AI agents and applications on these MCP servers? In this talk, we will discuss the lessons and best practices learned from building MCP servers and clients, and explain the roles and responsibilities that enterprise IT and AI teams can play in the MCP ecosystem.
Obot.ai CEO Sheng Liang 推出网关以保障企业级 AI 工具安全
企业采用模型上下文协议（MCP）需要集中式代理和面向任务的服务器抽象，以降低未经验证的 API 执行所带来的严重数据安全风险。
Sheng Liang 探讨了模型上下文协议（MCP）如何从早期的工具调用概念演变成为 AI Agent 的关键企业级标准。他概述了企业落地的四大核心支柱——发现（Discover）、安全（Secure）、使用（Use）和构建（Build），强调了集中式目录、代理治理以及相比原始 REST API 转换更高级的工具设计的必要性。演讲最后介绍了 Obot.ai 的开源 MCP Gateway 如何为非技术背景的企业用户解决这些运维与 UI 交互层面的挑战。
Obot.ai 放弃自研框架全面转向支持 Model Context Protocol (MCP)；创始人梁胜指出，自 2023 年 11 月 OpenAI DevDay 普及工具调用以来，MCP 已成为推动 LLM 执行 API 并转变为自主 Agent 的行业标准。 (0:04)
目前公开的 MCP 服务器已超 1 万个，但运行未经审核的可执行代码存在严重安全与数据泄露隐患，且现有客户端过于偏向开发者，给普通企业用户带来使用门槛。 (0:35)
企业 IT 落地 MCP 围绕发现、安全、使用与构建四大支柱，亟需引入集中服务目录和代理网关，以统一实施企业单点登录（SSO）、访问控制与威胁审计过滤。 (0:55)
在构建 MCP 服务时应避免直接将低粒度的 OpenAPI/REST 接口机械转换为工具，而应针对 Agent 场景封装高阶任务抽象，以避免复杂调用拖垮 LLM 性能。 (1:30)
Reading summary
Sheng Liang, co-founder and CEO of Obot.ai, argues that while the Model Context Protocol (MCP) enables autonomous agents by connecting models to APIs, widespread enterprise adoption requires solving critical governance, interface, and architectural challenges.
Enterprise Adoption Hurdles and Unverified Code (0:35)
Liang traces the modern AI tooling ecosystem to OpenAI's November 2023 DevDay, which popularized tool calling and catalyzed frameworks that evolved toward the Model Context Protocol. While developer-focused environments like Claude Desktop and Cursor established MCP as an emerging standard, Liang notes that enterprise IT teams remain hesitant to roll it out broadly across business units. Public directories such as mcp.so already list more than 10,000 servers, with dozens to hundreds added daily.
Unlike static early web pages, MCP servers execute code directly against internal databases and external APIs, creating acute data exposure and security risks. Liang identifies a mismatch in tooling: developer applications like Claude Desktop are too technical for typical business users. Enterprise feedback consistently centers on four core operational pillars: discovering safe servers, securing against backdoors, providing accessible user interfaces, and authoring reliable connectors.
Centralized Governance, Catalogs, and Proxy Control (0:55)
To address server discovery and security, Liang advocates for curated enterprise catalogs comparable to early web directories or SaaS registries managed through Okta. While future web services may natively offer authenticated MCP endpoints alongside existing websites and mobile apps, current IT administrators must explicitly establish trusted repositories of local and remote servers.
Controlling enterprise risk requires distinct approaches for different user tiers. Liang contends that restricting developers from loading arbitrary MCP servers into local development environments is neither technically nor culturally feasible outside military or high-security government facilities. Instead, IT organizations can manage business personnel by routing catalog access through a centralized proxy enforced with corporate single sign-on (SSO). This architecture establishes a focal point for audit logging, usage tracking, permissions enforcement, and payload filtering.
Expanding Client Capabilities with Dynamic UIs (1:07)
Liang categorizes MCP consumers into autonomous background agents and conversational clients, noting that front-end chatbots will proliferate much like web browsers did around common underlying standards. Because non-developer personnel will default to standard conversational windows rather than complex developer tools, client flexibility is essential for broader organizational deployment.
A key architectural capability within MCP is enabling servers to return functional user interface code instead of static text or raw JSON. This allows client software to render interactive components, such as data entry forms or financial trading canvases, directly inside chat streams. Liang suggests this dynamic capability positions conversational workspaces to eventually displace traditional standalone desktop and mobile applications for routine business workflows.
Task-Oriented Server Architecture Over REST Schemas (1:30)
While authoring MCP servers in Python frameworks like fastmcp is technically straightforward, Liang warns against the common pitfall of directly converting granular OpenAPI or REST endpoints into MCP tools. Low-level developer APIs often require traversing complex node hierarchies; for example, creating an email via Microsoft Graph API involves multi-step endpoint navigation that frequently causes large language models to fail.
Instead, Liang advises developers to encapsulate backend operations into high-level, task-oriented functions—such as a dedicated email creation command—designed specifically around agent execution paths. Additionally, Liang observes that AI agents themselves are increasingly exposed directly as MCP servers, an architecture he argues renders standalone Agent-to-Agent (A2A) protocols largely unnecessary.
Liang views Anthropic's open stewardship of MCP as a key driver of industry convergence, but maintains that enterprise utility depends on implementing centralized security proxies and building high-level, task-based integrations rather than exposing raw REST architectures.
## Background
本视频由 Ai4 频道于 2025 年 8 月 26 日发布在 YouTube 上。演讲者为 Obot.ai 联合创始人兼 CEO 梁胜（Sheng Liang），他在本次演讲中探讨了企业在引入和落地模型上下文协议（MCP）时面临的挑战，并分享了 Obot.ai 在构建 MCP 服务端与客户端过程中总结的最佳实践与角色分工。
## TL;DR
梁胜回顾了从 OpenAI 工具调用到 MCP 演变为行业事实标准的历程，指出企业在推广 MCP 时面临探索、安全、使用及构建四大核心关卡。为应对这些难题，企业需要通过构建统一的 MCP Catalog 与身份鉴权联动来把控安全，并推动 MCP 向富 UI 交互演进。在架构上应避免直接暴露出细粒度的 Open API，而应基于业务场景进行高阶封装，同时引入开源的 Obot MCP Gateway 简化治理。
## Atmosphere & style
这场演讲展现出务实、前瞻且极具技术洞察力的专业基调。梁胜以硅谷连续创业者的亲身经历娓娓道来，既有对技术演进趋势的宏观把握，也有深入企业真实落地痛点的切肤体验。整体氛围专业严谨而又开放包容，将复杂的架构演进与商业落地路径讲解得条理分明，传递出对 MCP 开源生态未来的强烈信心。
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=4s) Obot.ai 早期虽推出过与 MCP 竞争的方案，但随后全面转向并拥抱 MCP 生态，并联合 Anthropic、微软等发起了 MCP 开发者峰会。
- [00:04](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=4s) 工具调用（Tool Calling）让 AI 摆脱了人类在环模式，实现自主发起 API 请求并向真正自主的 Agent 跨越。
- [00:32](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=32s) 企业落地 MCP 面临海量服务质量混杂、严重安全隐患、现有客户端门槛过高及缺少业务封装四大核心挑战。
- [00:32](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=32s) 企业部署 MCP 的四大关键关卡为：探索（Discover）、安全（Secure）、使用（Use）与构建（Build）。
- [06:52](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=412s) 企业 IT 部门需要建立统一的 MCP Catalog（服务目录），对允许使用的本地与远程 MCP 服务端进行统一审核与列出。
- [06:52](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=412s) 企业可通过控制身份鉴权来防范安全风险，要求只有经过 Catalog 审核列出的 MCP 服务端才被允许对接企业统一身份认证（如 SSO）。
- [06:52](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=412s) 建立统一控制点后，企业 IT 团队能够实现访问控制规则管理、收集日志审计并过滤不安全的操作请求。
- [10:07](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=607s) MCP 正在从单纯的数据返回向富 UI（Rich UX）演进，可在客户端动态生成表单、看板或流程审批界面。
- [13:06](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=786s) 将现有的细粒度 Open API 原封不动转译为 MCP 是主要误区，LLM 无法自主拼装过多底层繁琐 API，必须围绕具体业务场景构建高层级服务。
- [13:06](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=786s) Obot.ai 实践中选择将复合 Agent 直接封装为 MCP 暴露出去，利用 MCP 标准直接覆盖 Agent 与 Agent（A2A）之间的通信交互。
- [16:33](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=993s) Obot MCP Gateway 采用 100% 开源策略，遵循 Red Hat 商业模式，软件免费提供并针对企业关键任务提供付费商业支持。
- [16:33](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=993s) 除了网关与代理外，Obot.ai 还提供了开源的 ChatGPT 式标准客户端，以降低普通业务人员的使用门槛。
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=4s) MCP 的演进历程与行业背景
Obot.ai 联合创始人兼 CEO 梁胜（Sheng Liang）首先对自己的创业背景做了简要介绍。作为一名硅谷的连续创业者，他带领团队在过去几年里一直专注于构建 AI Agent、聊天机器人及相关工具。虽然 Obot.ai 的成立早于模型上下文协议（Model Context Protocol, MCP），但双方一直处于同一赛道。梁胜坦言，团队最初甚至推出来过与 MCP 存在竞争关系的方案，但随着技术演进，他们敏锐地察觉到了 MCP 的优势与行业趋势，随后果断转向并全面拥抱 MCP 生态。为了推动生态建设，Obot.ai 在 2025 年初联合 Anthropic、微软（Microsoft）等公司的技术领袖与指导委员会，共同举办了首届 MCP 开发者峰会（MCP Dev Summit），下一届峰会也已规划在伦敦面向公众开放。
回顾技术演进，梁胜指出一切源于工具调用（Tool Calling）。2023 年 11 月的 OpenAI DevDay 首次展示了这一能力，彻底开启了 AI 应用的新篇章。在接下来的几个月里，市面上涌现出数十个 Agent 框架，帮助开发者构建能够调用工具的 AI 智能体。虽然 MCP 刚推出时并未引起轰动，但随着 Claude Desktop 和 Cursor 等开发者工具的爆发式普及，MCP 在 2025 年初迅速演化为事实上的行业标准。
没有工具调用，AI 就只能停留在回答问题或生成内容的阶段，必须依靠人类在环（Human-in-the-loop）来完成后续操作。而有了工具调用与 MCP，AI 才能自主发起 API 请求，从而实现从“聊天机器人”向真正的“自主 Agent”的跨越。
- **创业背景**：Obot.ai 位于加州，长期致力于 AI Agent、Chatbot 及相关开发工具的研发。
- **关键节点**：2023 年 11 月 OpenAI DevDay 首次演示 Tool Calling，开启 Agent 时代；2025 年初 Claude Desktop 与 Cursor 的火爆促使 MCP 成为行业标准。
- **生态活动**：Obot.ai 发起并联合 Anthropic、微软等头部厂商举办了 MCP 开发者峰会，后续峰会定于伦敦举行。
---
### [00:32](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=32s) 企业落地 MCP 面临的四大核心挑战
在与大量企业客户和 Agent 开发者沟通的过程中，梁胜发现企业虽然对向员工推广 MCP 怀有极高热情，但在实际落地时却普遍面临巨大的顾虑。像 Claude Desktop 这类主流客户端，其界面与交互完全是为程序员设计的，非技术人员（如业务人员或销售团队）根本无法直接使用。
此外，市面上像 `mcp.so` 这样的 MCP 托管目录中已经积累了超过 10,000 个 MCP 服务端，且每天仍有成百上千个新服务上线。这与早期 Web 时代网页即使粗糙也相对无害的情况截然不同——MCP 服务端本质上是具备执行能力的代码。如果加载了质量低劣或恶意编写的 MCP 服务，不仅可能导致业务崩溃，更严重的是，数据在传输和调用企业内部 API 的过程中极易发生泄漏。在与企业客户的交流中，团队总结出了企业部署 MCP 时绕不开的四大核心关卡：**探索（Discover）**、**安全（Secure）**、**使用（Use）** 和 **构建（Build）**。
```
+---------------------------------------------------------------+
| 企业落地 MCP 的四大核心挑战 |
+---------------------------------------------------------------+
| 1. Discover (探索) | 海量 MCP 难辨真伪，缺乏权威企业级目录 |
| 2. Secure (安全) | 缺乏统一鉴权与审计，存在数据泄露风险 |
| 3. Use (使用) | 缺少面向非技术业务人员的现代化 UI/Client |
| 4. Build (构建) | 过度暴露细粒度 API，缺乏场景化业务封装 |
+---------------------------------------------------------------+
```
- **海量且混杂**：公开目录中有超 10,000 个 MCP 服务端，质量参差不齐且缺乏安全验证。
- **安全性隐患**：MCP 服务端直接接收数据并调用企业内部 API，缺乏防护极易造成重大安全漏洞。
- **用户门槛**：现有客户端（如 Claude Desktop）偏向开发者，缺乏面向普通业务人员的易用界面。
---
### [06:52](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=412s) 探索与安全：构建企业级 MCP Catalog 与管控体系
针对**探索（Discover）**这一难题，当前的 MCP 生态非常类似于 1994 到 1995 年初期的互联网——缺乏统一治理，且安全隐患更为严峻。梁胜认为，企业急需一种类似早期 Yahoo! 或现代 Octa SaaS 目录的解决方案。企业 IT 部门需要建立统一的 **MCP Catalog（MCP 服务目录）**，对允许使用的本地（Local）与远程（Remote）MCP 服务端进行统一审核与列出。尽管未来所有 SaaS 服务可能都会将 MCP 与 Web、App、API 并列作为标准接口输出，但在现阶段，企业 IT 机构的标准化落地必须从建立 MCP Catalog 开始。
在**安全（Secure）**防护层面，仅有 Catalog 还不够，企业必须配合制定严格的安全策略，要求员工只能使用目录内的 MCP 服务。梁胜坦言，除非在政府、军事或顶级金融等高安保环境，否则在技术和文化上几乎不可能完全阻止开发者在自己的本地 Claude Desktop 中加载任意 MCP 服务端。但企业可以通过控制鉴权来实施有效防护：**只有经过 Catalog 审核并列出的 MCP 服务端，才被允许对接企业的统一身份认证（如 SSO/Corporate Credentials）**。
一旦建立了这个统一控制点（Single Point of Control），企业 IT 团队就能顺理成章地落地访问控制规则（Access Control）、收集使用日志与审计日志（Audit Logs），并过滤不安全的操作请求，从而在保护敏感数据源的同时不阻碍业务创新。
- **MCP Catalog**：借鉴 SaaS 目录管理模式，由 IT 部门统一筛选、验证并提供安全可信的 MCP 服务清单。
- **身份鉴权联动**：将企业统一身份认证与 MCP Catalog 绑定，未入库的服务端无法获取企业凭证，形成天然防火墙。
- **安全管控矩阵**：基于统一控制点实现细粒度访问控制、实时日志采集、审计跟踪与风险拦截。
---
### [10:07](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=607s) 使用体验：从命令行 Bot 到富 UI 画布的演进
在谈到**使用（Use）**维度时，梁胜指出当前 MCP 客户端主要有两种形态：**Chatbot**（如 Claude Desktop、Cursor、VS Code 插件）以及**嵌入式自主 Agent（Custom Agents）**。市面上的 AI 聊天机器人层出不穷，"Chatbot is a dime a dozen these days"（如今聊天机器人遍地都是，极易构建）。他预测未来 Chatbot 的竞争格局将类似于浏览器——主流浏览器可能只有两三款，但针对特定场景的 Chatbot 客户端可能会有成百上千种，普通业务人员显然更倾向于类似 ChatGPT 的交互体验。
更令人兴奋的发展趋势在于 **MCP 正在从单纯的数据返回向富 UI（Rich UX）演进**。极具前瞻性的 MCP 服务端不再仅仅返回文本或 JSON 数据，而是直接返回渲染界面所需的代码，在客户端动态生成定制化 UI（例如弹出股票交易表单、数据分析看板或流程审批界面）。这种“ChatGPT + 动态画布（Canvas）”的模式极有可能重塑现有的软件应用生态。正如业内所言，“Chatbot 可能会成为全新的浏览器或桌面操作系统”。
在另一种形态中，MCP 服务端被直接嵌入到后台运行的自定义 Agent 中，无须人工干预即可自动完成复杂的工作流交互，这是更为直接且高效的落地场景。
- **客户端形态**：Chatbot（面向交互）与 嵌入式 Custom Agent（面向后台自动化）。
- **动态 UI 突破**：新型 MCP 支持返回界面渲染代码，实现对话框内嵌富交互组件（如表单、看板），拓展应用边界。
- **行业远景**：带有富 UI 扩展能力的 Chatbot 有望替代传统浏览器与桌面应用，成为下一代企业应用入口。
---
### [13:06](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=786s) 构建实践：避开 Open API 直连误区与架构简化
关于**构建（Build）**环节，梁胜认为编写 MCP 服务端本身并不复杂，其本质与开发普通 API 服务没有太大区别，且市面上已有 FastMCP（Python 库）等大量成熟的 SDK 工具支持。虽然 Cloudflare、AWS、vSphere 等平台均提供了托管能力，但托管并非阻碍 MCP 普及的核心瓶颈。
构建层面最大的误区在于：**直接将现有的 Open API 规范原封不动地暴露为 MCP 服务**。早在 OpenAI 最初推出工具支持时，就支持直接解析 Open API Schema，但实际效果极差。因为传统 Open API 是为程序员设计的，粒度过细。以微软 Graph API 为例，在微软的视角下“一切皆图（Graph）”，如果要用 API 发送一封电子邮件，可能需要将邮件主题、收件人等拆解为数十个节点并发起几十次 API 调用。期望 LLM 自己去拼装这几十个细粒度 API 是不现实的。梁胜强调，**企业必须基于具体业务场景（Use Case-based）构建高层级、面向意图的 MCP 服务**（例如直接封装一个 `create_email` 接口）。
在前瞻架构方面，行业普遍接受的模式是“Agent -> MCP -> Apps/Data”。但 Obot.ai 在实践中发现，**当他们构建一个新的 Agent 时，也会直接将其封装为 MCP 服务暴露出去**。在他看来，MCP 协议本身就已经完美覆盖了 Agent 与 Agent 之间的通信交互（A2A），完全没有必要再单独引入一套全新的 Agent-to-Agent 协议。
```
+---------------------------------------------------------------+
| Obot.ai 推荐的 MCP 演进架构 |
+---------------------------------------------------------------+
| [ User / Client ] (如 Obot Client, Cursor, Claude) |
| | |
| v |
| [ Obot MCP Gateway ] ---> (Catalog / Security / Auth) |
| | |
| +-----------------------+ |
| | | |
| v v |
| [ Scenario MCP ] [ Sub-Agent (As MCP) ] |
| (高层级场景化服务) (复合 Agent 亦封装为 MCP) |
| | | |
| v v |
| [ Enterprise APIs ] [ Enterprise Data ] |
+---------------------------------------------------------------+
```
- **反面模式**：切忌将细粒度的 Open API 直接转译为 MCP，LLM 无法自主编排过于繁琐的底层 API。
- **最佳实践**：围绕业务场景进行高阶封装（如将复杂的 Graph API 封装为单一功能的邮件发送 MCP）。
- **架构简化**：将复合 Agent 同样封装为 MCP 输出，用统一的 MCP 标准替代额外的 Agent-to-Agent（A2A）通信协议。
---
### [16:33](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=993s) Obot MCP Gateway 开源方案与社区展望
在演讲的最后，梁胜介绍了 Obot.ai 团队推出的核心产品——**Obot MCP Gateway**。作为本次大会的白金赞助商，Obot.ai 将该网关完全以 **100% 开源**的方式提供给社区，商业模式遵循传统的 Red Hat 模式：软件本身完全免费供企业下载、部署与测试，当企业需要在生产环境中运行关键任务（Mission-Critical）并寻求 SLA 保障时，Obot.ai 提供商业化的技术支持与服务（如每月收取少量的支持费用）。
在开发网关的过程中，团队发现仅提供 Proxy（代理）和 Catalog（目录）还不够，他们还额外开发了一款开源的客户端（Client）。原因在于除了 Cursor 和 Claude Desktop 外，市面上缺乏一款能够让普通业务人员开箱即用的标准 ChatGPT 式客户端。
梁胜最后表达了对 MCP 生态的高度乐观。虽然 MCP 最初由 Anthropic 发起并主导，但 Anthropic 采取了极其开放的姿态与社区及合作伙伴协作，使得整个生态保持了极高的活力。他呼吁现场及线上开发者积极参与 GitHub 开源项目，并踊跃报名参加后续的 MCP 开发者峰会，共同推动企业级 MCP 标准的发展与落地。
- **产品定位**：Obot MCP Gateway 是一套 100% 开源的企业级 MCP 网关，包含 Catalog、Proxy、Security 控制及专属 Client 模块。
- **商业模式**：采用 Red Hat 模式，开源免费使用，针对企业级生产环境订阅提供商业支持。
- **社区生态**：赞扬 Anthropic 的开放合作态度，呼吁行业开发者共同建设开源 MCP 社区并参与全球 Dev Summit。
---
<ElicitationsGroup message="如果您想进一步了解 MCP 的企业级落地或架构设计，可以参考以下方向：">
<Elicitation label="深入分析 MCP Gateway 在企业架构中的鉴权与路由机制" query="请详细分析在企业级架构中，MCP Gateway 是如何处理统一身份认证（SSO）、权限路由与安全审计的？"/>
<Elicitation label="探讨将 Open API 重构为高阶 MCP 服务端的实战设计模式" query="如何将现有的细粒度 Open API 重构为面向 AI Agent 意图的高阶 MCP 服务端？请提供具体的设计模式与代码示例。"/>
</ElicitationsGroup>
## Notable quotes
> [10:07](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=607s) Chatbot is a dime a dozen these days — 梁胜
> [10:07](https://www.youtube.com/watch?v=vR5_J6YDpPw&t=607s) Chatbot 可能会成为全新的浏览器或桌面操作系统 — 梁胜
## Mentioned
Sheng Liang (梁胜), Obot.ai, Model Context Protocol (MCP), Anthropic, Microsoft, MCP Dev Summit, OpenAI DevDay, Claude Desktop, Cursor, mcp.so, FastMCP, Cloudflare, AWS, vSphere, Microsoft Graph API, Obot MCP Gateway, Red Hat
## Video description
Sheng Liang, Cofounder and CEO, Obot.ai
Abstracts
Organizations seeking to leverage MCP servers to enhance business processes face several challenges. How can we make sure that the tens of thousands of MCP servers on the market are safe to use? How can we implement enterprise-level authentication and access control? How can we enable in-house developers to build AI agents and applications on these MCP servers? In this talk, we will discuss the lessons and best practices learned from building MCP servers and clients, and explain the roles and responsibilities that enterprise IT and AI teams can play in the MCP ecosystem.
[Source](https://www.youtube.com/watch?v=vR5_J6YDpPw)
Source quotes
[10:07] 梁胜: Chatbot is a dime a dozen these days
[10:07] 梁胜: Chatbot 可能会成为全新的浏览器或桌面操作系统
Source quotes
Sheng Liang: How can we make sure that the tens of thousands of MCP servers on the market are safe to use?
Sheng Liang: How can we implement enterprise-level authentication and access control?
Sheng Liang: How can we enable in-house developers to build AI agents and applications on these MCP servers?
[0:55] Sheng Liang: neither technically nor culturally possible
[1:07] Sheng Liang: a dime a dozen
Original transcript
[0:04] So um
[0:06] uh just just a a bit of an introduction
[0:09] for myself. I am a tech entrepreneur. I
[0:13] I I did a
[0:15] our startup is called OA.ai and it's
[0:18] based in California. uh and we've been
[0:21] uh building like agents, chat bots,
[0:26] tools for the last couple years and uh
[0:30] we so we act on obviously predated MCP
[0:35] but we were very much in the same
[0:38] industry and then uh you know as MCP
[0:41] happened we were we were probably not
[0:44] the earliest adopter but we we actually
[0:47] uh but we were we kind of actually even
[0:50] had a competing solution at some point.
[0:52] But we saw the merit. We saw where the
[0:55] industry is going and uh we just started
[0:58] to fully embrace it and um uh one of the
[1:02] big thing was uh uh earlier this year we
[1:06] did a uh inaugural MCP dev summit that
[1:09] included some of the tech all the
[1:11] technical leaders the steering committee
[1:14] all the folks from anthropic you know
[1:16] Microsoft and and and came together and
[1:19] had a dev summit and the next one it's
[1:21] it's open to public the next one is
[1:23] going to being in London. So hopefully
[1:25] there'll be more in the US next year. Um
[1:29] so uh a bit history you know uh I mean
[1:33] you guys all interested in MCP. So I
[1:36] assume you all know about tool call
[1:39] right like does anyone not know about
[1:42] tool call? Great. Uh uh it's just really
[1:46] all started with tool call at least when
[1:49] I first saw what you know what a model
[1:52] can do. uh back in uh November of 2023
[1:58] uh uh there was a there was a open AAI
[2:00] dev day and and and and it was first
[2:03] they they kind of showcased that. I
[2:05] think that made everything happen. And
[2:07] in the ensuing months, they were just uh
[2:11] probably half a dozen, you know, to a
[2:14] dozen frameworks and things like that
[2:16] just just enabling agent writers to uh
[2:21] uh build these agents that invoke tools
[2:25] and and we built one of them. That's why
[2:27] I said we actually kind of competed with
[2:30] MCP for for a few months. uh and then
[2:33] MCP was introduced. Initially, I don't
[2:35] think anyone paid particular attention
[2:38] uh and then slowly but surely you know
[2:40] the with the with the traction of um uh
[2:44] claw desktop and and cursor it kind of
[2:47] became a standard earlier this year. So
[2:50] now there's just all this excitement
[2:52] around MCP and it's it's it's not really
[2:55] a surprise because as you know without
[2:58] it it doesn't have to be MCP but without
[3:01] some form of tool calling uh agents are
[3:04] not really possible. I mean you can have
[3:06] AI answering questions generating
[3:09] content you know but but but the human
[3:12] had to be in the loop. Now with with
[3:14] tool calling and MCP AI can make API
[3:19] calls autonomously and then and then and
[3:23] then chat bots turning to agents. So
[3:25] that's that's kind of the um but the the
[3:29] the as we as as I said earlier we've
[3:32] been working with uh enterprise uh these
[3:36] agent builders these people wanting to
[3:38] build agents for a while and and what we
[3:40] keep hearing is we love to roll out MCP
[3:44] to our employee base but how do we do
[3:48] that you know if you it it is actually
[3:51] quite uh uh uh daunting you look at I
[3:54] mean first First of all, you look at u
[3:56] uh the experience of cloud desktop, it
[4:00] is clearly designed for a developer and
[4:03] and you know, if you're a business user
[4:05] or or or a salesperson, it's I don't
[4:09] think anyone you can use that stuff.
[4:11] Then you look at you know that that
[4:13] happens to be mcp.so.
[4:15] There are tons of these MCP uh
[4:18] directories out there. uh and there's
[4:20] over 10,000 MCP servers with you know
[4:24] dozens or hundreds being created every
[4:27] day. So, and these are not like not it's
[4:30] a little different not like in the early
[4:32] days of web where you know the websites
[4:36] they more or less work and even if they
[4:38] don't look very good they're kind of
[4:40] quite harmless but but then these MCP
[4:44] servers are actually code so if you load
[4:47] it uh if they don't work it's a bad
[4:50] experience and if it works there's also
[4:52] no guarantee that you're not exposing
[4:54] because you're sending your data to it
[4:56] right and It's it is who knows what's
[4:59] going on and if it if it invokes these
[5:01] API calls that's in your enterprise I
[5:04] mean who would want to do that so so so
[5:07] really uh sec safe safety is the big
[5:10] deal so over and over again when we work
[5:13] with our customers these four things
[5:15] keep coming up the the very first thing
[5:18] is discover I talked about discover uh
[5:21] you know hundreds of thousands of MCPs
[5:23] out there which one of them is safe um
[5:26] uh you know if you search for I say I
[5:28] want to I want to use Figma Figma MCP
[5:31] server or Salesforce MCP server you
[5:34] search for it there are dozens at least
[5:35] dozens of these MCP servers come up and
[5:38] and sometimes there there's a there's an
[5:41] official one but sometimes there are
[5:42] multiple official ones and and you don't
[5:45] really even know which one to use um and
[5:47] how to make it secure how do you make
[5:50] sure it's secure if you're if you're an
[5:52] enterprise IT admin how do you make sure
[5:54] you're not opening a huge back door you
[5:57] know into your data and enterprise then
[6:00] also said use the the the if you're a
[6:03] developer it's not as much of a problem
[6:06] I would say but if you're not a
[6:08] developer I I don't I don't think good
[6:10] tools exist I mean uh it would be great
[6:13] if to be honest open AI like chat GBT
[6:16] supported MCP better but but they they
[6:19] they haven't really done it yet um uh
[6:23] build uh build is is uh
[6:27] is not the I mean it's actually not
[6:29] difficult. It's also not the easier
[6:30] thing. There are some gutos but but I
[6:33] would say that's not what's stopping.
[6:35] That's probably the least of the
[6:36] problems as indicated. I I think we need
[6:39] better quality MCPS but certainly the
[6:42] momentum around the the volume of MCPS
[6:45] is not pointing to there's a there's a
[6:48] significant build problem. Okay. Um uh
[6:52] so first I'll talk about uh discover um
[6:55] and and this is almost a bit like the
[6:57] very early days of internet I except I
[6:59] said the quality of MCP is probably
[7:01] worse than the quality of the websites
[7:04] and then let's say in 1995 or 94 and and
[7:09] and they could be quite dangerous. So
[7:11] naturally you know a solution like Yahoo
[7:14] could be quite helpful. uh you know a
[7:16] lot of enterprises have a SAS directory
[7:19] usually and they're usually maintained
[7:21] by companies like Octa and and and I
[7:24] think something similar should be done
[7:27] uh and they can they should be able to
[7:29] see the list of MCP servers and and then
[7:33] uh hopefully they'll support both local
[7:35] and remote MCP servers and I don't know
[7:38] this could be a temporary solution I you
[7:41] know the the the future of the web could
[7:42] be every service expose themselves as a
[7:47] website, as a mobile app, as API, and as
[7:50] MCP in the future, and they'll be all
[7:53] secure and validated. That's not the
[7:54] case today. So, so pretty much most of
[7:58] these enterprise uh IT things start with
[8:01] a catalog. Most of these organizations
[8:04] is adopting MCP stuff with a catalog.
[8:08] Then
[8:10] secure um what can enterprise do to try
[8:13] to secure uh MCP? Obviously having a
[8:16] catalog of high quality MCP servers help
[8:20] but you also need to to to supplement it
[8:24] with a policy that says you know every
[8:27] employee you better only use MCPs from
[8:30] this catalog. Now it's really unless I
[8:33] guess unless you work for government or
[8:35] military, it's actually pretty hard to
[8:37] actually enforce that. And for
[8:38] developers, there's really nothing you
[8:40] can do to enforce it. But but at least
[8:42] for business users, you can make sure
[8:44] that perhaps only those MCP servers
[8:47] listed in the catalog can authenticate
[8:50] against against your, you know,
[8:52] corporate credential. So that itself is
[8:55] a is a huge enabling factor and and
[8:57] motivator, right? And then once you have
[9:00] that you have you have established a
[9:01] single point of control then you can
[9:05] implement access control rules uh
[9:07] collect usage reports
[9:10] um uh logs and audit logs and filter
[9:14] unsafe access. So all these things
[9:17] become possible but but still it is just
[9:21] the the reality today. I mean I have to
[9:23] make sure you guys keep in mind that it
[9:25] is technic neither technically nor
[9:28] culturally possible unless you you truly
[9:31] work in some high security envir highly
[9:34] secure environments like government,
[9:36] military or financial services to
[9:38] prevent developers from from loading
[9:42] arbitrary MCP servers into you know
[9:45] their cloud desktop instances. That's
[9:48] just that's just the way it is. But
[9:50] certainly you could prevent them from
[9:52] that becoming a a standard practice
[9:55] inside an enterprise for your highly
[9:58] secure data sources or applications. So
[10:01] so that's that's what we can do um use
[10:07] um uh MCP uh clients basically can came
[10:12] come in two forms. Um the most popular
[10:15] form today is a chatbot. Some sort of a
[10:18] chatbot. You know, cloud desktop is a
[10:20] chatbot. Um um cursor is a is a chatbot.
[10:25] VS Code, the part that integrates with
[10:27] NCP is also a chatbot. Um the u uh I
[10:33] would claim there's still uh and just
[10:36] about every vendor, there's a lot of
[10:37] vendors in the space, we're one of them,
[10:39] but just about every vendor would
[10:41] produce a chatbot. chatbot is a dime of
[10:43] a dozen these days but um um uh so you
[10:47] can you can certainly um use um any kind
[10:52] of chatbot that supports MCP I don't
[10:54] think this will be a problem think about
[10:56] you know an analogy would be like
[10:58] browser browser we have what uh two or
[11:01] three standard browsers Apple Microsoft
[11:03] you know Google Chrome uh chat bots
[11:06] there will probably be dozens or
[11:07] hundreds literally it's these things are
[11:09] so easy to build there's this there
[11:11] there's really nothing there. Uh and uh
[11:14] and I have no doubt that that business
[11:16] users will uh prefer like chat GPT like
[11:20] experience. The there's there's one
[11:23] thing that's kind of really cool that's
[11:24] happening is with MCPS um now uh uh
[11:29] MCP's standard is so vibrant and it's
[11:33] getting you know getting to be rich. So,
[11:36] so, so, so some of the newer MCPs I've
[11:39] seen, it can actually uh not just return
[11:43] the the the result, but it returns the
[11:46] UI. So, in some sense, it returns the
[11:48] code to produce a custom UI for that
[11:52] particular connector. So, so that that
[11:55] you so you can when we say chatbot, it
[11:57] could be like these these it wouldn't be
[12:00] just like Chad GBT. It could it could
[12:01] literally be chibt enriched by a a very
[12:05] sophisticated canvas that that present
[12:08] to you, you know, a stock trading form
[12:10] or whatever. So, so this could very well
[12:13] take over the app world. Uh sometimes
[12:16] really it's not really about technology.
[12:18] What our industry really need is a just
[12:21] these compelling use cases and a reason,
[12:23] right, for for the community to come
[12:26] together. So, so I'm pretty excited
[12:28] where this whole thing could go. You
[12:30] know, people say chatbot could be the
[12:32] new browser or the new mobile desktop.
[12:35] Maybe it's true. Uh as as long as these
[12:38] richer u uh uh UX can piggyback on top
[12:42] of it, it wouldn't be just chat. Uh the
[12:45] other thing is I would MCP server. So
[12:47] chatbot is one form of consumption. The
[12:49] other form is embedded in custom agents.
[12:52] So if you have, you know, have you these
[12:54] truly background agents that just does
[12:56] things and it could use MCP and and and
[12:59] and that's probably a more
[13:01] straightforward use case. Last um build.
[13:06] So earlier I said build is really is not
[13:10] it's not the easiest thing in the world
[13:11] to build but it's not rocket science and
[13:14] it hasn't been a huge issue mainly
[13:17] because um uh building an MCP server is
[13:21] not very different from building any
[13:23] other API servers and on top of that
[13:26] there's so many tools and SDKs that's
[13:29] available I mean many of you probably
[13:31] used fast MCP you know Python library
[13:34] that's perhaps one of the most popular
[13:37] uh tools and and once you build it
[13:41] um uh there there are actually companies
[13:43] out there doing these MCP hosting
[13:46] platforms. I mean I'm still not
[13:48] convinced if hosting MCP is special
[13:53] enough, you know, to to require a a a
[13:56] new platform or it's just like any
[13:59] hosting platform. So, so, so, so you
[14:02] know, Cloudflare has one like there's
[14:04] there's there's tons of those and but
[14:06] you can host it on one of those things
[14:09] which might be a little easier or or
[14:11] just hosted on AWS or or vSphere. It
[14:15] doesn't really matter. Um uh uh uh so so
[14:18] so the last bullet is kind of becoming a
[14:20] bit of a cliche now in the in the MCCP
[14:23] space is the earlier practice of
[14:26] exposing open API as MCP uh is just not
[14:32] wise. you know, early days people say I
[14:35] mean even even back when um uh Open AI
[14:39] uh uh uh uh created like that tool
[14:43] support it actually a lot of people
[14:45] don't know but it came with it the
[14:47] ability to integrate with open API
[14:50] schema. So, so in theory any open API
[14:54] you can you can you can just straight
[14:56] connect to
[14:58] um um um you can straight connect to a
[15:01] model even without MCP but it didn't
[15:04] work very well because as you know open
[15:06] like these APIs are very fine grain
[15:09] they're designed for coders you could
[15:11] probably vip code a a a a a something on
[15:15] top of it but like what what what AI
[15:18] wants is say the say given new example
[15:21] say create an email you know it should
[15:25] be just one call one MCP call but if you
[15:28] expose the Microsoft graph API to create
[15:32] email and and it's it's first of it's
[15:34] called Microsoft graph API from
[15:36] Microsoft perspective everything is a
[15:38] graph so email is a graph now how do you
[15:40] and and maybe maybe the subject line is
[15:43] a node maybe the the the two object the
[15:47] receiver is a node so you compose that
[15:49] right with with maybe a few dozen API
[15:51] calls and AI is not going to figure that
[15:53] out, you know. So, so, so, so you kind
[15:56] of need more use case-based MCP
[15:59] services. Um, and and and last thing is
[16:02] I would say just looking forward, I mean
[16:04] this is the standard diagram that people
[16:07] see agents call MCP, MCPS call apps and
[16:10] data, but um but these days whenever we
[16:13] build an agent, we expose it as MCP as
[16:16] well. So there's just no reason uh at
[16:19] least from my personal perspective
[16:21] there's no reason for A2A because
[16:23] because MCP is already I mean pretty
[16:25] much uh already take care of the the the
[16:30] agent case. Um uh so with that I mean
[16:33] just last minute I'll just introduce you
[16:36] know we are company OTO the reason I'm
[16:38] here talking about this sponsoring the
[16:39] show as a platinum sponsor is u uh
[16:42] because we introduced the OOTT MCP
[16:44] gateway it's open 100% open source
[16:46] software we kind of follow a Red Hat
[16:48] model uh that's all kind of in our
[16:51] history I've I've always done open
[16:53] source software in my in my whole career
[16:55] works very well organizations love to
[16:57] just try it put it in production and and
[17:00] and when they really need it for mission
[17:02] critical use, they they reach out to us
[17:05] for support. So that's kind of our
[17:07] business model. We we we we charge like
[17:10] I don't know 10 bucks a month for
[17:11] something for for um uh for supporting
[17:15] the software uh and and and the software
[17:18] underneath it has a few modules uh and
[17:21] and you know coming where we actually
[17:23] turned out we had to do a client as
[17:25] well. We didn't just do proxy and
[17:27] catalog simply because today outside of
[17:30] these cursor and claude there really
[17:33] isn't a standard client chatbt like
[17:36] client that uh um that business users
[17:40] can use. So with that I'll end and you
[17:44] can you can you know visit our GitHub
[17:46] for for the code install it you can
[17:48] reach out to me if you have any more
[17:50] questions or would like to have a
[17:52] technical discussion or business
[17:53] discussion and if you want to really get
[17:56] engaged in the MCP community really the
[17:59] best thing to do is it's very open it's
[18:01] although it's managed by um uh um uh by
[18:06] anthropic they're very very open I mean
[18:09] I think it helps this is perhaps not the
[18:11] core business of Anthropic. So, they've
[18:13] taken a very open approach to to uh
[18:17] working with customers and partners like
[18:20] us and we've really had a great
[18:22] experience working with the creators and
[18:25] contributors. We're a contributor of of
[18:27] MCP as well. So, yeah, there's a there's
[18:29] a there's a there's a there's a there's
[18:31] a summit that everyone all come together
[18:33] uh once every few months. So, it would
[18:36] be great if you guys can register and
[18:38] attend. That's all I wanted to say about
[18:41] MCP. Hopefully that's helpful.
[18:44] [Applause]
