快来看,n8n更新了!人工智能让集成成为供应商的问题

内容来源:https://blog.n8n.io/ai-made-integrations-the-vendors-problem/
内容总结:
人工智能代理开发工具报告第二版将“可集成性”维度替换为“企业就绪度”,意在标志与2020年代集成平台即服务(iPaaS)模式的告别。随着MCP(模型上下文协议)获得广泛采用,几乎所有厂商都提供MCP服务器,集成负担已转移至服务器提供方——由后者负责加载工具、定义、管理模式与访问权限,代理只需通过服务器认证即可。
传统iPaaS模式的核心痛点在于跨API端点全生命周期管理繁琐,而如今这种模式正在被取代。但厂商在简报中普遍表示“可与用户选择的代理工具集成”,所用手段包括钩子、SDK及MCP,集成形态已不同于以往Zapier式的API调用。作者因此希望以“代理优先”思维重新审视集成问题。
在旧API世界中,负担集中在客户端:提供方仅负责通过端点暴露产品功能并编写文档,认证流程、重试、数据映射、破坏性变更跟进等均由API消费方承担,且每集成一次便重复承担一次,这正是iPaaS市场兴起的根源。如今提供方发布MCP服务器,客户端自主决定何时及如何调用,MCP确实改写了部分契约:服务器通过标准化协议暴露能力(工具用于操作、资源用于上下文、提示用于模板),宿主应用为每个服务器启动客户端维持连接。但厂商承担了版本管理、发现机制、传输安全等繁重工作,协议规范快速演进,近期修订使协议转为无状态并按请求发现能力,部分功能在版本间被弃用。消费者则只需发现可用能力,由模型决定何时使用。
仅暴露模式并不足以产生胜任的工具使用。MCP服务器可发布完全合法的工具定义,模型也能解析,但代理未必知道工作流——即按什么顺序调用哪些工具、提供方有哪些约定、如何处理边界情况。这需要通过“技能”注入指令,通常为运行时加载至模型上下文的Markdown文件,MCP服务器提供方现已将技能模板纳入产品。
归根结底,MCP只是API封装,其HTTP传输推荐使用OAuth获取令牌,规范正式指定OAuth 2.1作为客户端获取服务器范围化访问权的授权机制。MCP的能力建立在API持续演进之上:REST本身经历多重改造,包括GraphQL规范刷新、gRPC用于高性能内部微服务、HTTP/3与QUIC大幅提速;OpenAPI 3.1.1实现与JSON Schema完全对齐,对代理意义重大,使模型能准确解析规范;Arazzo与OpenAPI Overlays等新标准可描述多步骤工作流并在不改写规范的前提下叠加策略。安全层面,API正针对非人类行为者加固,包括持有证明(DPoP)、防重放令牌绑定、细粒度范围富授权请求、金融级API配置、动态速率限制及针对可每秒生成数千请求的代理的行为分析。
钩子是代理循环固定节点(会话开始、提示提交、工具调用前后、轮次结束)运行的确定性脚本。代理欲调用工具时,钩子先行触发,向服务发送POST请求获取是/否裁决,或在本地运行shell脚本或二进制程序,通过stdin传入上下文并返回退出码。钩子配置为项目中的JSON文件,宿主通过stdin/stdout与钩子通信。Claude Code钩子可按三种节奏触发:每会话一次、每轮次一次、每次工具调用时。钩子由安全或平台团队负责,是在非确定性代理流程中插入确定性策略的廉价直接方式,可提供将所有工具调用流式发送至SIEM的集中审计轨迹,并在模型行为异常时中途终止代理进程。
除钩子外,还可将工具或流程集成至自有应用代码。尽管许多提供方已通过MCP服务器暴露产品,严肃代理应用中越来越多的集成与应用程序捆绑。Claude Agent SDK是最清晰的例子,可通过三种方式注册MCP服务器:作为通过stdin/stdout通信的本地进程、作为面向云托管服务器和远程API的HTTP/SSE服务、或作为直接在应用内定义的SDK MCP服务器。第三种方式意味着无需启动独立服务器进程,在同一代码库中定义自定义工具,SDK处理初始请求时即完成连接。子代理延伸同一逻辑,开发者通过agents参数或.claude/agents/下的Markdown文件组合代理实例,隔离上下文、并行运行并限制各代理工具权限。嵌入什么、如何组合、允许哪些工具等决策落在应用开发者身上,集成由此成为编码关切。
2026年的n8n集成:集成第三方产品不再是单车道 exercise,MCP亦然——作者观察到开发者和厂商仅聚焦MCP服务器及其技能而遗忘API。作为提供方,不得不兼顾所有集成途径。尽管MCP工具调用的绝对数量预计增长,但MCP与API、钩子、SDK的份额将趋于平衡。经济规律决定了无法对每次工具调用都进行“token最大化”,回归API等更简单的工具反而更划算。n8n可提供大量API集成、SDK、MCP服务器及钩子。
中文翻译:
在第二版《AI智能体开发工具》报告中,我将“可集成性”维度替换为“企业就绪度”。我希望以此表明与2020年代IPaaS模式的告别。随着MCP获得越来越多的关注,以至于每个厂商都提供MCP服务器,我认为集成负担现在落在了服务器提供方身上。他们负责加载工具、定义、管理schema、访问权限等等。你的智能体只需要向服务器完成认证,就万事大吉了。
IPaaS那套说辞的核心在于:管理遍布整个生命周期的众多API端点令人头疼,但你可以购买这个工具,让这件事变成拖拽式的操作。但我们其实已经不再这么做了(我是相对而言)。所以再见吧,集成维度,没人再需要你了。
但等等!我经常参加厂商简报会,通常涉及某种智能体产品。他们都说“我们可以与你选择的智能体工具集成”。他们不叫它们API,而是用hooks、SDK,当然还有MCP。
所以集成的形态正在发生变化,不再是Zapier那种从MongoDB GET user_1的方式。现在我想以“智能体优先”的思维重新审视集成,看看能得出什么结论。
MCP与配置负担
在旧的API世界里,负担完全在客户端一侧。提供方的工作是通过一组端点以合理的全面程度暴露产品的功能,并编写文档让客户知道该怎么用。此后的一切(认证流程、重试、数据映射、跟进破坏性变更)都是API消费者的问题。客户端承担负担,而且反复承担,每做一个集成就承担一次。这就是IPaaS成为一个市场的原因——它成长起来,就是为了吸收将N个系统与M个其他系统对接的客户端成本。
如今,消费者不再针对暴露的API进行集成,而是由提供方发布MCP服务器,客户端自主决定何时以及如何调用它。MCP确实改写了部分契约。服务器通过标准化协议暴露能力,比如用于操作的工具、用于上下文的资源、用于模板的提示词,而宿主应用为每个服务器启动一个客户端来维持连接,本地通过stdio,远程通过可流式HTTP。
厂商处于不利地位。他们要应对快速演进的规范进行版本管理、处理发现机制、保障传输安全。保持服务器与最新规范同步很困难。例如,最近的修订使协议变为无状态,采用逐请求的能力发现,而且特性会在版本之间被弃用。
消费者则轻松多了,他们只需发现有什么可用的,由模型决定何时使用。所以没错,一大块负担确实转移到了发布方:如果你想让你的服务能被智能体使用,你现在就得搭建并维护一个服务器。
仅靠schema暴露并不能产生合格的工具有效使用。一个MCP服务器可以发布完全合法的工具定义,模型也能解析它,但这并不意味着智能体知道工作流程。也就是说,不知道该按什么顺序调用哪些工具、提供方的约定是什么、如何处理边缘情况。
这就是你通过技能(skills)来给出指令的地方。这些通常是运行时加载到模型上下文中的markdown文件。它们告诉智能体如何操作某个特定的集成。
MCP服务器提供方现在也将技能模板作为其产品的一部分。
API的改头换面
归根结底,MCP只是一个API封装。它推荐在其HTTP传输上使用OAuth获取令牌,规范正式指向OAuth 2.1作为客户端获取服务器范围化访问的授权机制。所以MCP能做它所做的,只是因为API在不断更新。
REST本身经历了一系列改头换面,包括GraphQL的规范刷新、用于高性能内部微服务的gRPC,以及快得多的HTTP/3或QUIC。OpenAPI 3.1.1终于实现了与JSON Schema的完全对齐,这对智能体意义重大,因为这意味着模型可以准确解析规范。Arazzo和OpenAPI Overlays等新标准描述了多步骤工作流,并能在不重写规范的情况下将策略叠加到规范上。
在安全方面,API正在专门针对非人类行为者进行加固。例如,展示持有证明(DPoP)、防重放的令牌绑定、用于细粒度范围控制的富授权请求、金融级API配置文件、动态速率限制,以及针对每秒能生成数千个请求的智能体的行为分析。
Hooks
我知道内核钩子,但不确定这是不是同一回事。这些是harness在智能体循环的固定节点(会话开始、提交提示词、工具调用前、工具调用后、轮次结束)运行的决定性脚本。如果智能体想调用工具,hook会先触发,向某个服务发送POST请求以获取是/否的裁决。或者hook在你的机器上运行本地shell脚本或二进制文件(如Python或Bash),通过stdin传递上下文并返回退出码。
Hook配置是项目中的JSON文件,harness通过stdin/stdout与hook通信。Claude Code的hooks可以三种节奏触发:每会话一次(SessionStart、SessionEnd)、每轮次一次(UserPromptSubmit、Stop、StopFailure),以及每次工具调用时(PreToolUse、PostToolUse)。
Hooks是安全或平台团队的职责。它们是一种低成本且直接的方式,在原本非确定性的智能体流程中插入确定性策略。它们提供集中化的审计追踪,将每次工具调用流式发送到SIEM,并提供一种在模型像不听话的小智能体一样行为异常时中途杀死智能体进程的手段。
SDK
除了hooks,你还可以将工具或流程集成到你自己的应用代码中。尽管很多提供方现在通过MCP服务器暴露其产品,但在严肃的智能体应用中,越来越多的集成与应用程序捆绑在一起。
Claude Agent SDK是最清晰的例子。你可以通过三种方式注册MCP服务器:作为通过stdin/stdout通信的本地进程、作为面向云托管服务器和远程API的HTTP/SSE服务,或作为直接在你的应用程序内部定义的SDK MCP服务器。
第三种选项意味着,你不需要搭建单独的服务器进程,而是在与智能体相同的代码库中定义自定义工具,SDK处理初始请求时它们就连接上了。
子智能体延伸了同样的逻辑。开发者通过agents参数或.claude/agents/中的markdown文件组合智能体实例。然后隔离它们的上下文、并行运行它们,并限制每个智能体的工具——比如文档审查员只能使用Read和Grep,不能触碰其他任何东西。
嵌入什么、如何组合、允许哪些工具等决策现在落在了应用开发者桌上。从这个意义上说,集成变成了一项编码工作,当我把集成归入“可编码性”维度时,这倒是意外地契合得很好。
2026年的n8n集成
集成第三方产品不再是一条单行道。这也包括MCP——我看到开发者和厂商只关注MCP服务器及其技能,却忘了API。作为提供方,不幸的是你得兼顾所有集成途径。虽然预期MCP工具调用的绝对数量会增加是合理的,但MCP与API、Hooks、SDK之间的份额将变得更加均衡。经济规律决定了你不可能对每次工具调用都搞token最大化,回归更简单的工具(如API)反而更划算。
不管怎样,这是CTA部分,所以如果你想要大量API集成、SDK、MCP服务器或hooks,n8n都能满足你。
英文来源:
In the second iteration of the AI Agent Development Tools report, I replaced the integrability axis with enterprise-readiness. I wanted this to signify the departure from 2020-style IPaaS. With MCP getting traction to the point where every vendor offers an MCP server, I said the integration burden now lies with the server providers. They load the tools, definitions, manage schemas, access, and whatever. Your agent just needs to authenticate to the server and that’s it.
The whole spiel with IPaaS was that managing however many API endpoints across their lifecycle was a headache, but you can buy this tool that makes it just a drag-and-drop exercise. But we’re not really doing that anymore (I’m speaking in relative terms). So bye-bye integrations axis, nobody wants you anymore.
But wait! I regularly have vendor briefings, often with agent products of some kind. They all said “we integrate with your agent tool of choice”. They didn’t call them APIs, they were using hooks, SDKs, and obviously MCP.
So integrations are taking a different shape compared to Zapier GET user_1 from MongoDB. Now I want to revisit integrations with this agent-first mindset and see what conclusions we get to.
MCP et Le burden de configuration
In the old API world, the burden sat squarely on the client side. The provider's job was to expose their product’s functions via a set of endpoints to a reasonable degree of comprehensiveness and document those so customers know what the hell to do with them. Everything after that (auth flows, retries, data mapping, keeping up with breaking changes) was the API consumer's problem. The client carried the burden, and carried it repeatedly, once per integration. This is why the IPaaS became a market, it grew up to absorb the client-side cost of wiring N systems to M others.
Today, instead of consumers integrating against exposed APIs, providers publish an MCP server, and the client autonomously decides when and how to call it. MCP genuinely does rewrite part of this contract. A server exposes capabilities through a standardized protocol, like tools for actions, resources for context, prompts for templates, while a host application spins up a client per server to hold the connection, over stdio locally or streamable HTTP remotely.
Short end of the stick for vendors. They deal with versioning it against a fast-moving spec, handling discovery, securing the transport. Keeping the server current is tough. For example, recent revisions made the protocol stateless with per-request capability discovery, and features get deprecated between versions.
Happy days for consumers, they just discover what's available and the model decides when to use it. So yes, a real chunk of burden moved to the publisher: if you want your service usable by agents, you now stand up and maintain a server.
Schema exposure alone doesn't produce competent tool use. An MCP server can publish a perfectly valid tool definition, and a model can parse it, but that doesn't mean the agent knows the workflow. Namely, which tools to call in what order, what the provider's conventions are, how to handle edge cases.
This is where you give instruction via skills. These are typically markdown files loaded into the model's context at runtime. They tell the agent how to operate a specific integration.
MCP server providers are now also including Skills templates as part of their product.
APIs get facelifts
At the end of the day, MCP is just an API wrapper. It recommends OAuth for obtaining tokens over its HTTP transport, and the spec formally points at OAuth 2.1 as the authorization mechanism for clients to get scoped access to servers. So MCP can only do what it does because APIs are getting updates.
REST itself has a whole bunch of facelifts, including GraphQL’s spec refresh, gRPC for high-performance internal microservices, and HTTP/3 or QUIC are much faster. OpenAPI 3.1.1 finally reached full JSON Schema alignment, which matters enormously for agents, because it means a model can parse a specification accurately. New standards like Arazzo and OpenAPI Overlays describe multi-step workflows and layer policy onto specs without rewriting them.
On security, APIs are hardening specifically against non-human actors. For example, demonstrating proof of possession (DPoP), token binding against replay, rich authorization requests for fine-grained scopes, financial-grade API profiles, dynamic rate limiting and behavioral analysis aimed at agents that can generate thousands of requests a second.
Hooks
I knew about kernel hooks but wasn’t sure if this is the same thing. These are deterministic scripts the harness runs at a fixed point in the agent loop (session start, prompt submit, before a tool call, after it, turn end). If an agent wants to call a tool, a hook triggers first and sends a POST request to a service to get a verdict back with a yes/no. Or the hook runs a local shell script or binary (like Python or Bash) on your machine, passing context via stdin and returning exit codes
Hook configuration is a JSON file in the project and the harness talks to the hook over stdin/stdout. Claude Code hooks can fire in three cadences: once per session (SessionStart, SessionEnd), once per turn (UserPromptSubmit, Stop, StopFailure), and on every tool call (PreToolUse, PostToolUse).
Hooks are the responsibility of security or platform teams. They’re a cheap and straightforward way to plug in a deterministic policy in an otherwise non-deterministic agent flow. They offer a centralized audit trail streaming every tool call to a SIEM, and a way to kill an agent process mid-run when the model misbehaves like a bad little agent.
SDKs
Other than hooks, you can integrate tools or processes into your own application code. Even though a lot of providers now expose their products via MCP servers, a growing share of integration in serious agent applications gets bundled with the application.
The Claude Agent SDK is the clearest example. You can register an MCP server three ways: as a local process that talks over stdin/stdout, as an HTTP/SSE service for cloud-hosted servers and remote APIs, or as an SDK MCP server defined directly inside your application.
That third option means that instead of standing up a separate server process, you define custom tools in the same codebase as the agent, and they connect as soon as the SDK processes the initial request.
Subagents extend the same logic. The developer composes agent instances via an agents parameter or markdown files in .claude/agents/. They then isolate their context, run them in parallel, and restrict each one's tools so a doc-reviewer gets only Read and Grep and can't touch anything else.
Decisions like what to embed, how to compose it, which tools to allow now landed on the application developer desk. In this respect, integration became a coding concern, which unintentionally landed quite well when I moved integrations under Codability.
n8n integrations in 2026
Integrating third-party products is no longer a single-lane exercise. This includes MCP as well - I see devs and vendors solely focusing on MCP servers and their skills, whilst forgetting about APIs. As a provider, you will unfortunately have to juggle all the integration avenues. While it’s reasonable to expect an increase in the absolute number of MCP tools calls, the share of MCP vs API, Hooks, SDKs will become more balanced. Economics dictate that you won’t be able to tokenmaxx every tool call, and will be better off reverting to simpler tools, like APIs.
Regardless, this is the CTA section, so if you want a whole bunch of API integrations, an SDK, MCP servers, or hooks, n8n’s got you covered.
文章标题:快来看,n8n更新了!人工智能让集成成为供应商的问题
文章链接:https://news.qimuai.cn/?post=5579
本站文章均为原创,未经授权请勿用于任何商业用途