import  requests
Check today's weather in Beijing
response = requests.get( 'http://localhost:5000/api/weather?city=Beijing&date=today' )
data = response.json()
 print ( f"Today's weather in Beijing is: {data[ 'weather' ]} , temperature range: {data[ 'temperature' ]} , rainfall probability: {data[ 'rain_probability' ]} " )

import  json
import  requests
from  typing  import Dict ,  List ,  Any 
Define available functions
def search_weather ( city:  str , date:  str  =  "today" ) ->  Dict [ str ,  Any ]: 
 """
 Search for weather in a specific city and date
Args:  
    city: city name, such as "Beijing", "Shanghai"  
    date: date, in the format of YYYY-MM-DD or "today" for today  
    
Returns:  
    A dictionary containing weather information  
"""  
# Calling the weather API  
response = requests.get( f'http://weather-api.example.com/api/weather?city= {city} &date= {date} ' )  
return  response.json()  
def search_restaurants ( location:  str , cuisine:  str  =  None , price_range:  str  =  None ) ->  Dict [ str ,  Any ]: 
 """
 Search for restaurants in a specific location
Args:  
    location: location, such as "Beijing Haidian District"  
    cuisine: cuisine, such as "Sichuan cuisine", "Cantonese cuisine" (optional)  
    price_range: price range, such as "below 100", "100-300", "above 300" (optional)  
    
Returns:  
    A dictionary containing restaurant information  
"""  
# Constructing query parameters  
params = { "location" : location}  
if  cuisine:  
    params[ "cuisine" ] = cuisine  
if  price_range:  
    params[ "price_range" ] = price_range  
    
# Calling the restaurant API  
response = requests.get( 'http://restaurant-api.example.com/api/search' , params=params)  
return  response.json()  

Function dictionary, mapping function names to actual functions
available_functions = {
 "search_weather" : search_weather,
 "search_restaurants" : search_restaurants
 }
Function description, used by the AI ​​model to determine which function should be called
function_descriptions = [
 {
 "name" :  "search_weather" ,
 "description" :  "Get weather information for a specified city and date" ,
 "parameters" : {
 "type" :  "object" ,
 "properties" : {
 "city" : {
 "type" :  "string" ,
 "description" :  "City name, such as Beijing, Shanghai"
 },
 "date" : {
 "type" :  "string" ,
 "description" :  "Date, in the format of YYYY-MM-DD or today for today"
 }
 },
 "required" : [ "city" ]
 }
 },
 {
 "name" :  "search_restaurants" ,
 "description" :  "Search for restaurants in a specified location" ,
 "parameters" : {
 "type" :  "object" ,
 "properties" : {
 "location" : {
 "type" :  "string" ,
 "description" :  "Location, such as Beijing Haidian District"
 },
 "cuisine" : {
 "type" :  "string" ,
 "description" :  "Cuisine, such as Sichuan cuisine, Cantonese cuisine"
 },
 "price_range" : {
 "type" :  "string" ,
 "description" :  "Price range, such as less than 100, 100-300, and more than 300"
 }
 },
 "required" : [ "location" ]
 }
 }
 ]
Simulate the Function Call decision made by the AI ​​model
def simulate_ai_function_call ( user_message:  str ) ->  Dict [ str ,  Any ]: 
 """
 Simulate an AI model to analyze user messages and decide which function to call
In actual applications, this part is completed by the AI ​​model, and this is only for demonstration  
"""  
if "weather" in  user_message  or "raining" in  user_message:      
    # Extract cities  
    city ​​=  "Beijing" # Simplified processing, should actually be extracted from the message    
    if "tomorrow" in  user_message:    
        date =  "2025-04-06" # Simulate tomorrow's date    
    else :  
        date =  "today"  
        
    return  {  
        "function" :  "search_weather" ,  
        "parameters" : {  
            "city" : city,  
            "date" : date  
        }  
    }  
elif "restaurant" in  user_message  or "eating" in  user_message:      
    # Extracting location and preferences  
    location =  "Beijing Haidian District" # Simplified processing    
    cuisine =  "Sichuan cuisine" if "Sichuan cuisine" in  user_message  else None      
    price_range =  "100-300" # Default medium price    
    
    return  {  
        "function" :  "search_restaurants" ,  
        "parameters" : {  
            "location" : location,  
            "cuisine" : cuisine,  
            "price_range" : price_range  
        }  
    }  
else :  
    return None # no need to call function     
Simulate the process of processing user messages
def process_user_message ( user_message:  str ) ->  str : 
 """Process user messages and return replies"""
    print ( f"User:  {user_message} " )
# Determine whether a Function Call is needed  
function_call = simulate_ai_function_call(user_message)  

if  function_call:  
    function_name = function_call[ "function" ]  
    parameters = function_call[ "parameters" ]  
    
    print ( f"AI decided to call function:  {function_name} " )  
    print ( f"Parameters:  {json.dumps(parameters, ensure_ascii= False )} " )  
    
    # Execute Function Call  
    if  function_name  in  available_functions:  
        function_to_call = available_functions[function_name]  
        function_response = function_to_call(**parameters)  
        
        print ( f"Function return result:  {json.dumps(function_response, ensure_ascii= False )} " )  
        
        # Generate a reply based on the function return result (simplified processing)  
        if  function_name ==  "search_weather" :  
            return f" {parameters[ 'city' ]} { 'tomorrow' if  parameters[ 'date' ] !=  'today' else 'today' } the weather is {function_response[ 'weather' ]} , temperature range {function_response[ 'temperature' ]} , rainfall probability {function_response[ 'rain_probability' ]} ."      
        elif  function_name ==  "search_restaurants" :  
            restaurants = function_response.get( "restaurants" , [])  
            if  restaurants:  
                restaurant_names = [r[ "name" ]  for  r  in  restaurants[: 3 ]]  
                return f"I found the following restaurants for you: { ', ' .join(restaurant_names)} , ​​they are all in {parameters[ 'location' ]} { ', provide'  + parameters[ 'cuisine' ]  if  parameters[ 'cuisine' ]  else '' } ."    
            else :  
                return f"Sorry, no restaurants matching the criteria were found."   
    else :  
        return f"Sorry, I can't process this request because the function {function_name} is not available."   
else :  
    # No need to call function, just reply directly  
    return "I understand your question, but there is no need to call a specific tool to answer it. [Here is a direct reply generated by the AI ​​model]"   
test
test_messages = [
 "What's the weather like in Beijing today? Will it rain?" ,
 "Recommend several Sichuan restaurants in Haidian District" ,
 "What is the history of the development of artificial intelligence?"
 ]
for  message  in  test_messages:
 response = process_user_message(message)
 print ( f"AI:  {response} \n" )

MCP definition file example
Usually passed to AI models as system prompts or configurations

MCP_DEFINITION =  """
Intelligent Assistant Code of Conduct (Model Context Protocol)
1. Basic Code of Conduct
Identity and Tone
You are a professional and friendly AI assistant
Use a polite yet natural tone, avoiding being too formal or too casual
Use consistent pronouns in your responses, using "I" instead of "AI assistant" or third-person pronouns
Response Format
Provide clear and concise answers to simple questions
Provide structured responses to complex questions, using headings and paragraphs
Use Markdown format to improve the readability of your answers
Avoid unnecessary repetition and redundant statements
Knowledge Boundaries
Acknowledge the timeliness of knowledge. Your knowledge is valid until April 2023.
When you are unsure of an answer, state your uncertainty clearly and avoid making up information
For the latest information, proactive alerts require the use of search tools
2. Tool Usage Guidelines
Search Tool Usage
When users ask about events, news or data after April 2023
When users explicitly request the latest information
When the problem involves rapidly changing information (e.g., weather, stock prices)
When you need to verify information that may be out of date
Data analysis tools used
When a user uploads a data file that needs to be analyzed
When complex numerical calculations need to be processed
When you need to generate data visualizations
When you need to extract insights from structured data
Image generation tool usage
When the user explicitly requests that an image be created or generated
When complex concepts are better expressed with images
When users need visual creativity or design inspiration
3. Safety and ethical standards
Handling sensitive topics
Maintain a neutral and objective stance on sensitive topics such as politics and religion
Provide diverse perspectives and avoid being biased towards any particular position
Refuse to generate content that may be controversial or offensive
Harmful request handling
Politely refuse to generate information that could cause harm
Refuse to provide detailed instructions for illegal activities
Redirect users to constructive alternatives
Personal Data Protection
Do not store or remember users' sensitive personal information
Remind users to avoid sharing sensitive information in conversations
Do not attempt to collect private user data
4. Multi-turn dialogue management
contextual understanding
Maintain the continuity of the conversation and remember the previous communication content
Understand pronoun reference and implicit information
Politely ask for clarification when the context is unclear
Dialogue Initiative
Provide follow-up suggestions related to the current topic when appropriate
Recognize and respond to the user’s emotional state
Steer the conversation in a constructive and helpful direction
Error handling
When you recognize an error in a previous answer, you can proactively correct it.
Accept corrections from users and express gratitude
Avoid making excuses for mistakes and focus on providing correct information
5. Responsive Style Guide
Technical content
Adapt the use of technical terminology to the expertise level of the user
Provide easy-to-understand explanations for complex concepts
Use analogies when necessary to explain abstract concepts
Educational Content
Use progressive explanation, starting with the basics and then the advanced
Provide examples and application scenarios
Encourage users to ask questions and explore
Creative Content
Demonstrate flexibility of thought and creativity
Provide diverse creative options
Balancing practicality and innovation
6. Tool call detailed specifications
Search tools (search)
Parameter construction: 
Keywords: concise search keywords, no more than 5 words
rewritten_query: detailed search query, including full context
Result processing: 
Extract the most relevant information points
Verify consistency of information
Cite the source of the information
Data analysis tools (data_analysis)
When to use: 
When the file ID is available
Code builds follow best practices
The results need to be explained in easy-to-understand terms
Coding standards: 
Data processing using pandas
Visualization using matplotlib or seaborn
Include appropriate comments
Image generation tool (text_to_image)
Prompt word structure: 
Describe in detail the visual elements, style and mood
Avoid requesting specific brands or celebrity likenesses
Specify an appropriate art style
 """
In actual applications, this MCP will be loaded and used to configure the behavior of the AI ​​model
def configure_ai_model_with_mcp ( ai_model, mcp_definition=MCP_DEFINITION ): 
 """Configure the behavior specifications of the AI ​​model"""
 # In actual implementation, this may involve setting system prompts or specific parameters of the model
 # This is just for illustration
    ai_model.set_system_prompt(mcp_definition)
    return  ai_model
Simulate the process of AI processing user messages
def process_with_mcp ( user_message ): 
 """Use MCP specification to process user messages"""
    print ( f"User:  {user_message} " )
    #Simulate the process of AI thinking according to MCP  
    print ( "\n[AI's thinking process based on MCP]" )  

# Determine the message type and required processing method  
if "weather" in  user_message:    
    print ( "1. The message is about weather and belongs to the real-time information category" )  
    print ( "2. According to the MCP tool usage specifications, you should use the search tool to obtain the latest weather information" )  
    print ( "3. Need to construct appropriate search parameters, including location and time" )  
    
    # Simulate Function Call decision  
    function_call = {  
        "function" :  "search" ,  
        "parameters" : {  
            "keywords" :  "Beijing's weather today" ,  
            "rewritten_query" :  "Today's latest weather forecast for Beijing: temperature and rainfall probability"  
        }  
    }  
    
    print ( f"4. Decided to call: {function_call[ 'function' ]} " )  
    print ( f"5. Parameters: {json.dumps(function_call[ 'parameters' ], ensure_ascii= False )} " )  
    
    #Simulate the function return result  
    function_result = {  
        "weather" :  "clear" ,  
        "temperature" :  "22-28℃" ,  
        "rain_probability" :  "5%"  
    }  
    
    print ( "6. Get weather information and organize the answer according to the MCP response format specification" )  
    print ( "7. Provide clear and concise answers to simple questions based on MCP" )  
    
    # Generate a reply  
    response =  f"Today's weather in Beijing is sunny, with temperatures between 22-28℃ and a very low probability of rainfall of only 5%. It is suitable for outdoor activities, but the ultraviolet rays are strong, so it is recommended to take sunscreen."  

elif "artificial intelligence" in  user_message  and "history" in  user_message:      
    print ( "1. The message asks about the history of artificial intelligence, which is a knowledge question" )  
    print ( "2. According to MCP, this is a complex question and a structured answer should be provided" )  
    print ( "3. This is within the scope of the model's knowledge and does not require the use of tools" )  
    print ( "4. According to the MCP Educational Content Guidelines, progressive explanations should be used" )  
    
    # Generate a reply  
    response =  """# The history of the development of artificial intelligence  
The development of artificial intelligence (AI) can be divided into several key stages:
Early exploration (1940s-1950s)
1943: McCulloch and Pitts create the first mathematical model of a neural network
1950: Alan Turing proposes the famous "Turing Test"
1956: Dartmouth Conference formally establishes the term "artificial intelligence"
Early development (1960s-1970s)
Expert systems begin to emerge
The rise of rules-based AI systems
Preliminary research on natural language processing
The First AI Winter (1970s-1980s)
Funding cuts, research slows
Computational power limitations hinder progress
Renaissance and progress (1990s-2000s)
Machine learning methods become popular
1997: IBM's Deep Blue defeats chess champion Kasparov
Deep Learning Revolution (2010s to Present)
2012: AlexNet achieves breakthrough in ImageNet competition
2016: AlphaGo defeats Go champion Lee Sedol
2020s: Large language and multimodal models such as GPT series and DALL-E emerge
Artificial intelligence continues to advance, impacting every aspect of our lives. """
elif "help me generate" in  user_message  and "picture" in  user_message:      
    print ( "1. Message request to generate image, image generation tool is required" )  
    print ( "2. According to the MCP image generation tool usage specifications, detailed prompt words need to be constructed" )  
    print ( "3. Need to extract image description elements from user messages" )  
    
    # Simulate Function Call decision  
    function_call = {  
        "function" :  "text_to_image" ,  
        "parameters" : {  
            "prompt" :  "A cute orange cat sits on the windowsill, looking at the birds outside the window, the sun shines through the window onto the cat, creating a warm and cozy atmosphere" ,  
            "style" :  "digital-art"  
        }  
    }  
    
    print ( f"4. Decided to call: {function_call[ 'function' ]} " )  
    print ( f"5. Parameters: {json.dumps(function_call[ 'parameters' ], ensure_ascii= False )} " )  
    print ( "6. Image generated, answer organized according to MCP response specification" )  
    
    # Generate a reply  
    response =  "I have generated for you an image of a cute orange cat sitting on a windowsill, in a digital art style. The cat is looking out the window at the birds, the sun is shining on it, and the whole picture is warm and cozy. I hope this meets your expectations!"  

else :  
    print ( "1. Unable to determine the specific message type" )  
    print ( "2. According to MCP, when a message is unclear, one should politely ask for clarification" )  
    
    # Generate a reply  
    response =  "Sorry, I'm not sure what you're looking for. Are you looking for weather forecasts, searching for information, or do you need help with something else? Please provide more details so I can better help you."  

print ( "\n[AI final reply]" )  
return  response  
Testing different types of user messages
test_messages = [
 "What's the weather like in Beijing today? Is it suitable for going out?" ,
 "What is the history of the development of artificial intelligence?" ,
 "Help me generate a picture of a cat" ,
 "What do you think will happen tomorrow?"
 ]
for  message  in  test_messages:
 ai_response = process_with_mcp(message)
 print ( f"User:  {message} " )
 print ( f"AI:  {ai_response} \n" )