MCP Protocol and Agent Skills Development in Practice: The Bridge Connecting LLMs to Traditional Systems

Why LLMs Need the MCP Protocol

When you throw an e-commerce system's product query API directly at ChatGPT, it will most likely stare back blankly—what is this API for? How do you pass parameters? What does it return? Traditional APIs are designed for programs. A Java programmer instantly understands productService.query("iPhone"), but a large language model can't read the conventions of the code world.

MCP (Model Context Protocol) is designed to solve exactly this problem. According to a public lecture by instructor Shanshan on Bilibili, MCP is essentially a set of standardized protocols—just as HTTP governs requests and responses on the internet, it lets LLMs connect to external tools and business systems under a unified set of rules.

The protocol was first proposed by Anthropic at the end of 2024. Instructor Shanshan offered an analogy: previously, Java did its own thing, Python did its own thing, and LLMs did their own thing, all independently; with MCP, LLMs can call those long-existing traditional APIs through standardized wrapping—reusing rather than tearing down and rebuilding.

MCP uses a client-server architecture: the MCP server exposes tools (such as database queries and API calls) in a standardized way, while the MCP client (usually embedded in an AI application or Agent) is responsible for discovering and invoking these tools. The protocol defines the description format for tools (name, function description, parameter schema), enabling LLMs to autonomously decide which tool to call and how to pass parameters based on natural-language descriptions—this is the core mechanism that solves the problem of "LLMs not understanding APIs."

How MCP Connects to the Traditional Software World

To understand MCP's value, the key is to see what it changes. In the past, users had to go to 12306 to check train tickets, Taobao to buy things, and Meituan to order food delivery—every system had its own pages and interaction logic. In the Agent era, users face a single intelligent agent, which connects to various tools through MCP behind the scenes and directly helps users complete tasks.

Specifically, developers wrap the old e-commerce system's APIs into MCP tools, and the LLM can invoke them after understanding the natural-language descriptions of the tools. The underlying logic of querying products is still the same database access as before—no rewriting required. Instructor Shanshan emphasized that this means there is now a connection layer between LLMs and the traditional software world, and old systems don't have to be abandoned just because LLMs have arrived.

This also explains why MCP took off rapidly in 2025. With the development of AI coding tools like Claude Code and Cursor, Agents are no longer just chatting—they need to actually operate files, databases, and external services. The more external objects they operate on, the more a unified access standard is needed; otherwise, with a different integration method for every tool, programmers simply couldn't keep up.

The Difference Between Agent Skills and MCP

The public lecture divides its content into two parts: MCP and Agent Skills. MCP focuses on connectivity—enabling LLMs to reach external tools; Skills lean more toward capability encapsulation—packaging the execution logic of specific tasks into reusable skill units.

Instructor Shanshan noted that the two are often used together in actual development: MCP handles data and API connectivity, while Skills handle task workflow orchestration. For students learning LLM development, understanding the division of labor between these two layers is more important than memorizing concepts. However, the public lecture's coverage of Skills is relatively limited, and more details require the accompanying mind map.

Agent Skills typically refer to encapsulating the execution logic of specific tasks (such as "generate a weekly report" or "process a refund") into reusable skill units that include prompts, tool-call sequences, and decision logic. Unlike MCP's "connection layer" role, Skills sit at the "orchestration layer": they decide when to call which MCP tools and how to combine the results. For example, a "query and recommend products" Skill would sequentially call the product query MCP tool and the recommendation MCP tool, and handle the intermediate results. The two layers collaborate: MCP provides atomic capabilities, while Skills organize task workflows.

What This Means for Developers

A realistic assessment: MCP is becoming the infrastructure of AI application development. Instructor Shanshan stated bluntly that when job hunting today, a resume with no MCP-related experience at all will be less competitive. The reason is simple—almost every company that has built software has legacy systems, and they can't all be rewritten just because LLMs have appeared.

The implications for developers are twofold. On one hand, traditional backend experience is not a burden—wrapping old APIs into MCP tools is precisely the work that requires people who understand business logic. On the other hand, what needs to be added is an understanding of how to interact with LLMs—how to write tool descriptions so models call them accurately, and how to design an Agent's tool orchestration workflow.

From a learning-path perspective, LangChain plus FastMCP is a pragmatic combination: the former provides a mature framework for Agent orchestration, while the latter lowers the barrier to developing MCP services. The learning roadmap, resume optimization, and interview question explanations mentioned in the public lecture also indicate that market demand for these skills has moved from the exploratory phase into the hiring phase.

MCP is not a new language or a new model—it's just a protocol. But it is precisely this "unsexy" infrastructure that determines whether AI applications can truly land in the legacy systems of thousands of industries.

FastMCP is a Python-based framework for developing MCP services. Through decorators and similar mechanisms, it quickly exposes ordinary functions as MCP tools, significantly lowering the barrier to protocol implementation. LangChain, meanwhile, provides capabilities such as the Agent runtime, tool-calling chains, and memory management. Together, they enable the rapid construction of complete applications combining "Agent orchestration + tool integration." For backend developers, mastering FastMCP means being able to convert legacy APIs into LLM-callable tools at low cost, while LangChain helps them understand how Agents make decisions and schedule tasks.

One-line Summary

MCP is a protocol that lets LLMs connect to traditional systems in a standardized way, and it is becoming the infrastructure of AI application development.

Paragraph Summary

The article explains why the MCP protocol is necessary: traditional APIs are designed for programs, and LLMs struggle to understand them. MCP uses standardized tool descriptions to let LLMs call legacy systems. Proposed by Anthropic at the end of 2024, MCP acts as a connection layer between LLMs and the traditional software world, enabling old systems to be used by Agents without rewriting. The article also distinguishes MCP (connectivity) from Agent Skills (task encapsulation) and notes that MCP took off rapidly in 2025 with the development of AI coding tools. For developers, traditional backend experience is not a burden; supplementing it with an understanding of LLM interaction and the LangChain + FastMCP combination is a pragmatic path, and MCP-related experience is becoming a hiring requirement.