MCP Weather Server Demo

🚀 MCP Tool Invocation Capability Introduction

This document provides an in - depth introduction to the docking mechanism between the MCP (Model Context Protocol) and AI models, including how different models interact with MCP and the comparison of various docking architectures.

🚀 Quick Start

In the MCP (Model Context Protocol) architecture, although tool calling is the core capability, it doesn't mean that all operations are performed by the model itself. The actual docking process is a collaborative effort between the model and the client.

❓ Does the model have to support Function Call to use MCP?

The answer is: Function Call is a required feature for docking with MCP, but it doesn't necessarily have to be directly executed by the model itself. That is, there must be the ability to trigger tool calls, but this trigger instruction doesn't have to be in the model's native 'tool_call' format.

✨ Features

✅ Model natively supports Function Call (e.g., GPT - 4 - turbo + 5ire)

• Model Environment: GPT - 4 - turbo
• Client Platform: 5ire (used to support the docking between GPT models and external tools such as MCP)
• Model Function Call Support: ✅ Supported
• Who is responsible for executing Function Call: 5ire (automatically executes based on the tool_call instructions generated by the model)
• Can it dock with MCP: ✅ Yes
• Process Description:
  1. The client (5ire) sends the user request and the description of available tools (function schema) to the model.
  2. The model can automatically generate a structured tool_call based on the tool description.
  3. The client (5ire) is responsible for receiving, parsing this tool_call, and then executing the corresponding tool (interacting with MCP or directly calling the API).
  4. The client sends the execution result back to the model.
  5. The model generates the final response based on the result.

In this mode, the interaction between the model and MCP/tools is highly automated, and the process is relatively transparent to the user.

✅ Model does not support Function Call (e.g., DeepSeek R1 + Cline for VSCode)

• Model Environment: DeepSeek R1 (assuming it doesn't natively support Function Call)
• Client Platform: Cline (an extension plugin for VSCode, used as an intelligent client)
• Model Function Call Support: ❌ Not supported
• Who is responsible for executing Function Call: Cline (judges the intention based on the text output by the model, converts and executes it)
• Can it dock with MCP: ✅ Yes
• Process Description:
  1. Before sending the user request to the model, the client (Cline) injects the description of available tools into the prompt. This is usually in natural language or a specific format to inform the model: "You can use get_weather(latitude, longitude) to query the weather".
  2. The model receives the prompt containing the user request and tool description.
  3. After understanding the request, the model decides to use a tool, but it cannot generate a structured tool_call. So it will produce an indicative text, for example: "Okay, let me check the weather: get_weather(latitude = 24.16, longitude = 120.64)".
  4. The client (Cline) parses this text returned by the model, identifies the intention and parameters of get_weather(...).
  5. The client (Cline) converts these parameters into an appropriate format and executes the corresponding tool call (such as sending a request to the API).
  6. After the tool is executed, the client receives the response and returns it to the model.

In this mode, the model cannot directly execute tool calls, but it can interact with external tools through the client plugin.

📚 Documentation

Comparison of Model Docking Methods

Summary

The MCP protocol provides multiple ways to achieve the interaction between models and external tools. The choice of which method depends on the model's function support and specific application requirements. If the model natively supports Function Call, its tool - calling ability can be directly used; if not, the docking can be achieved through the client plugin.