Agent, MCP, and Function Calling: A Complete Guide to Their Differences and Relationships

In the 2025 AI tech world, terms like Agent, MCP, Function Calling, and Prompt are flying everywhere, leaving many developers and AI enthusiasts confused. What problems does each of these solve? How do they relate to one another? This article starts from the most fundamental concept—Prompt—and builds up layer by layer, helping you connect these key concepts into one clear thread.

Starting with Prompt: The Entry Point of AI Conversations

When ChatGPT first launched in 2023, AI appeared to be nothing more than a chat box. We send a message, AI returns text—the message we send is called a User Prompt, typically a question or an instruction.

But a problem quickly emerged: AI had no "persona." Given the same input like "my stomach hurts," your dad might tell you to go to the bathroom, your mom might ask if you need to go to the hospital, and your wife might simply say "drink more hot water." Without a role definition, AI can only give generic, one-size-fits-all answers.

Thus, the System Prompt was born. Developers write role, personality, background, and tone information into the System Prompt, which is automatically sent to the AI model along with the user's message every time, making conversations more natural and targeted.

The concept of System Prompt originates from the multi-turn conversation architecture design of large language models. In OpenAI's Chat Completions API, each message carries a role field, divided into three types: system, user, and assistant. Messages with the system role are treated by the model as the highest-priority contextual instructions, influencing the generation tendency of all subsequent conversations. From a technical implementation perspective, System Prompt isn't a special model capability—rather, through positional weights in the Attention Mechanism, the model "remembers" this prefixed instruction when generating each token. This is also why an overly long System Prompt can crowd out the effective context window, degrading the model's ability to understand subsequent conversation content.

In products like ChatGPT, the System Prompt is typically preset by the platform and cannot be directly modified by users. However, platforms offer preference settings that are automatically incorporated into the System Prompt.

What Is an AI Agent: From "Talking" to "Doing"

No matter how well the persona is set up, AI is still essentially a chatbot—you ask questions, it gives answers, and you're the one who actually does the work. So can AI complete tasks on its own?

The earliest attempt was an open-source project called AutoGPT. AutoGPT was released on GitHub in March 2023 by developer Significant Gravitas, gaining over 50,000 Stars within just one week, making it one of the fastest-growing open-source projects in GitHub history. Its core innovation was introducing the "Reason-Act-Observe" loop paradigm, later summarized by academia as the ReAct framework. Before AutoGPT, similar ideas had been explored in frameworks like LangChain, but AutoGPT was the first to package it into an end-to-end autonomously running product.

Its working principle involves three steps:

1. Register tools: Pre-write functions (such as listing directories, reading files, etc.) and register their names, descriptions, and calling methods into the program
2. Generate System Prompt: The program automatically generates a System Prompt based on registration information, telling AI what tools are available, how to call them, and what format to return
3. Loop execution: Send the System Prompt and user request together to AI, AI returns call instructions in the agreed format, the program parses and executes the corresponding function, feeds the result back to AI, and repeats until the task is complete

However, early AutoGPT also exposed serious issues: due to the limited reasoning capabilities of GPT-3.5/4, Agents frequently fell into infinite loops or made incorrect tool-calling decisions, consuming massive amounts of tokens without completing tasks. This drove the development of standardized solutions like Function Calling.

The program responsible for relaying messages between the model, tools, and users is called an AI Agent. The functions or services provided for AI to call are known as Agent Tools.

The Role of Function Calling: From "Free-form" to "Standardized Calls"

Although the Agent architecture works, there's an unavoidable problem: even when the return format is clearly specified in the System Prompt, AI as a probabilistic model may still output content in the wrong format. Many Agents automatically retry when format errors are detected, but this approach is inherently unstable.

So LLM providers stepped in themselves. OpenAI, Anthropic (Claude), Google (Gemini), and others successively released Function Calling capabilities, with the core idea being to standardize the format of tool calls.

Function Calling is not simply prompt engineering—it involves dedicated optimization at both the model training and inference levels. Taking OpenAI as an example, GPT models use large amounts of function-calling annotated data during fine-tuning, teaching the model to generate structured JSON call instructions at appropriate times instead of natural language responses. During inference, the model's output passes through a dedicated Parser to ensure the generated JSON strictly conforms to predefined Schemas. This "Constrained Decoding" technique can validate syntax legality in real-time during token generation, fundamentally preventing format errors. Anthropic's Claude uses a similar Tool Use mechanism, while Google Gemini calls it Function Declaration. Notably, the open-source community is also catching up, with inference frameworks like Ollama and vLLM beginning to support Function Calling capabilities for certain models.

Compared to the pure System Prompt approach, Function Calling improves on three levels:

Standardized Tool Descriptions

Each tool is defined by a JSON object: the tool name goes in the name field, the description in the description field, and required parameters in the parameters field. These JSON objects are separated from the System Prompt and placed in dedicated fields of the API request.

Fixed Return Format

Function Calling specifies the return format that AI must follow when calling tools, eliminating the need for verbose format instructions in the System Prompt. Tool descriptions are stored uniformly with consistent formatting, and AI responses strictly follow the specification.

Server-side Error Handling

With fixed response formats, the AI server can detect and retry internally, completely transparent to the client. This reduces development difficulty and saves Token costs from client-side retries.

However, Function Calling currently has shortcomings: API definitions vary across providers, and many open-source models still don't support this feature. So in practice, System Prompt and Function Calling approaches coexist.

MCP Protocol Explained: The "USB Port" Between Agent and Tools

The previous discussion covered how AI Agents communicate with AI models. Now let's look at the other side—how AI Agents interact with Tools.

The most straightforward approach is to put Agent and Tools in the same program, interacting through direct function calls. Most early Agents indeed did this. But as the tool ecosystem grew, a practical problem emerged: some tools are highly versatile (like web browsing, database querying), needed by multiple Agents, but it's impractical to copy the same code into every Agent.

So Anthropic proposed MCP (Model Context Protocol). The MCP protocol was officially released and open-sourced by Anthropic in November 2024, with its design inspired by Microsoft's LSP (Language Server Protocol). LSP defines a standard protocol between editors and language services, allowing any editor to reuse the same set of language analysis services—for example, you get the same code completion and error checking experience in VS Code, Vim, or Sublime Text, powered by the same language server behind the scenes. MCP migrates this concept to the AI tool ecosystem, allowing different Agents to call the same set of tool services through a unified protocol.

MCP is built on the JSON-RPC 2.0 protocol, supporting both request-response and notification message patterns. JSON-RPC is a lightweight remote procedure call protocol that uses JSON as its data format, naturally suited for inter-service communication in web environments.

Core concepts of MCP include:

• MCP Server: The server-side that runs tools, exposing standardized interfaces including available tool lists, descriptions, parameter formats, etc.
• MCP Client: The Agent-side that calls tools, responsible for initiating requests and handling responses
• Three capabilities: Besides regular Tools (function calls), MCP Server can also provide Resources (data services similar to file read/write) and Prompts (reusable prompt templates)

In terms of deployment, MCP Server can run on the same machine as the Agent, communicating via standard input/output (stdio); or be deployed on remote servers, communicating over HTTP.

As of early 2025, the MCP ecosystem has produced hundreds of community-contributed Server implementations, covering common scenarios like database queries, file system operations, API integrations, and browser automation. Mainstream AI products like Cursor, Windsurf, and Claude Desktop natively support the MCP protocol. However, MCP is still in rapid iteration, with the protocol specification not yet fully stable, and the authentication/authorization mechanism (OAuth 2.1) for remote deployment scenarios still being refined.

One point deserves special emphasis: MCP is a standard designed for the AI tool ecosystem, but it has no direct relationship with AI models. MCP doesn't care whether the Agent uses GPT, Claude, or an open-source model—it only handles unified management of tools, resources, and prompts for Agents.

Complete Lifecycle of a Request

Let's connect all concepts together with a complete example. Suppose you ask an AI Agent: "My wife has a stomachache, what should I do?"

1. Agent receives the request and wraps the question as a User Prompt
2. Agent queries all available Tools information from the MCP Server via the MCP protocol
3. Agent converts the Tools information into Function Calling format (or writes it into the System Prompt), packages it with the User Prompt, and sends everything to the AI model
4. The AI model determines it needs to use a web browsing tool called Web Browse, and generates a call request via Function Calling format
5. After receiving the call request, the Agent invokes the corresponding tool in the MCP Server via the MCP protocol, which accesses the specified website and scrapes content
6. The web content is returned to the AI model, which combines the retrieved information with its own knowledge to generate the final answer
7. Agent presents the result to the user

Throughout this process, Prompt is responsible for conveying information, Function Calling standardizes the dialogue between Agent and model, MCP standardizes the interaction between Agent and tools, the AI model handles understanding and reasoning, and the Agent is the scheduling hub that ties everything together.

Summary: Five Concepts, Each with Its Own Role

System Prompt, AI Agent, Function Calling, MCP, and AI LLMs are not replacements for each other—they interlock like gears, jointly driving the complete system of AI automated collaboration:

Concept	Role
Prompt	Input information for AI, including System Prompt (role definition) and User Prompt (user instructions)
AI Agent	The core program that coordinates between model, tools, and users
Function Calling	Standardized tool-calling method between Agent and AI model
MCP	Standardized communication protocol between Agent and tool services
AI Model	The reasoning engine that understands requirements, plans steps, and generates responses

Once you understand the division of labor and collaboration among these five concepts, you've mastered the core architecture of current AI application development. Whether you're building a RAG system with LangChain or developing your own AI Agent from scratch, this cognitive framework is an essential foundation.

Among these, LangChain is one of the most popular AI application development frameworks, created by Harrison Chase in 2022, providing a complete toolkit for building Agents, managing Prompts, and orchestrating tool chains. RAG (Retrieval-Augmented Generation) is a technical architecture that combines external knowledge bases with large language models: it first uses vector retrieval to find document fragments most relevant to the user's question from the knowledge base, then injects these fragments as context into the Prompt, allowing the model to generate answers based on real data, effectively mitigating the "hallucination" problem of LLMs. A typical RAG system workflow includes five steps: document chunking, vectorization (Embedding), storage in vector databases (such as Pinecone, Milvus, Chroma), semantic retrieval, and augmented generation. In practice, RAG systems often need to be combined with Agent architecture, where the Agent decides when to trigger retrieval and how to combine multi-round retrieval results—this is precisely a typical scenario of the concepts discussed in this article working together.

Key Takeaways

• AI Agent is the intermediary program that relays messages between model, tools, and users, automatically completing tasks through loop-based tool calls
• Function Calling is the standardized tool-calling method introduced by LLM providers—more standardized and reliable than the System Prompt approach, though standards across providers haven't been unified yet
• MCP (Model Context Protocol) is the protocol that standardizes communication between Agent and tool services, like the USB standard of the AI era, independent of specific AI models
• System Prompt, Agent, Function Calling, MCP, and AI models are not replacements for each other—they interlock like gears to form the complete system of AI automated collaboration
• Currently, both System Prompt and Function Calling approaches coexist in the market, and developing cross-model universal Agents still presents challenges