Quick Takeaways
- The article explains how transitioning from local, duplicated tool definitions to using a shared MCP server streamlined tool management, improved interoperability, and decoupled ML and application teams’ responsibilities.
- It highlights MCP (Model Context Protocol) as an open standard enabling agents to discover and call tools via a protocol, facilitating cross-platform compatibility and easier updates.
- The implementation details compare stdio and HTTP transports, emphasizing minimal latency and local deployment advantages of stdio, while noting HTTP suits shared or scalable environments.
- The system’s design improves reliability and maintenance by centralizing tool control, simplifies human-in-the-loop approval processes, and allows rapid deployment of new capabilities without changing core graphs.
The Problem with Traditional Agent Architecture
Recently, a team needed to update their database schema. The change was simple: add two new columns. However, implementing this was complicated. The tool definition was stored in multiple places—inside the orchestrator, a validation agent, and outdated utility modules. Each change required editing several files and retesting many agents. This caused delays and risks of silent errors. Essentially, their system’s architecture made updates slow and fragile. They realized that having tools defined locally in each agent created many problems when scaling or trying to make quick changes. As their system grew, the traditional setup couldn’t keep pace. This led them to ask: is there a better way to organize these tools?
Introducing the Model Context Protocol (MCP)
The answer came with the Model Context Protocol, or MCP. Published by Anthropic in 2024, MCP is an open standard. It changes how AI agents discover and call tools. Instead of defining tools inside each agent, tools run on a separate shared server. When an agent needs a tool, it contacts this server at runtime. The server then provides a list of available tools. This approach offers many benefits. First, it creates a clear boundary between tools and agents. Second, any MCP-compatible client can connect, whether in Python, TypeScript, or other frameworks. Importantly, it separates ownership—teams controlling tools and teams building agents can work independently. This clear protocol improves flexibility and scalability for complex systems.
How MCP Changes Deployment and Maintenance
Building an MCP server is straightforward with available SDKs. For example, the FastMCP library handles schema creation and communication. Developers decorate functions with special tool tags, and the server manages the rest. Communication can happen over local processes using stdio, which is fast and simple, or through HTTP, suitable for distributed environments. Switching transport types only takes a line of code. Connecting MCP to existing frameworks, like LangChain, becomes seamless. The langchain-mcp-adapters library manages sessions and tool discovery, making integration easy. The new setup allows for better management of human-in-the-loop approvals. Instead of embedding approval logic within graphs, it now resides near the protocol boundary. This makes updates faster and governance clearer. Moreover, the system becomes more resilient: if the server crashes, the agent can handle errors more effectively. Overall, MCP helps organizations deploy, update, and scale their tools with less risk and more agility.
Discover More Technology Insights
Learn how the Internet of Things (IoT) is transforming everyday life.
Explore past and present digital transformations on the Internet Archive.
AITechV1
