MCP 和 Function Calling：示例

@api_bp.route('/flomo/save', methods=['POST'])
def save_to_flomo():
    # 获取请求数据
    data = request.get_json()

    # 验证请求数据
    if not data or 'content' not in data:
        return jsonify({"error": "Missing required field: content"}), 400

    content = data['content']
    tags = data.get('tags', [])  # 可选的标签列表

    # 验证Flomo API URL是否配置
    flomo_api_url = current_app.config.get('FLOMO_API_URL')
    if not flomo_api_url:
        return jsonify({"error": "Flomo API URL not configured"}), 500

    try:
        # 准备发送到Flomo的数据
        flomo_data = {
            "content": content
        }

        # 如果有标签，添加到内容中
        if tags:
            # Flomo使用 #tag 格式的标签
            tag_text = ' '.join([f"#{tag}" for tag in tags])
            flomo_data["content"] = f"{content}\n\n{tag_text}"

        # 发送请求到Flomo API
        headers = {
            'Content-Type': 'application/json'
        }

        response = requests.post(
            flomo_api_url,
            headers=headers,
            data=json.dumps(flomo_data),
            timeout=10  # 设置超时时间，处理大文本可能需要更长时间
        )

        # 检查响应
        if response.status_code == 200:
            return jsonify({
                "message": "Content successfully saved to Flomo",
                "flomo_response": response.json()
            }), 200
        else:
            return jsonify({
                "error": "Failed to save to Flomo",
                "status_code": response.status_code,
                "response": response.text
            }), 500

    except requests.RequestException as e:
        # 处理请求异常
        return jsonify({
            "error": f"Request to Flomo failed: {str(e)}"
        }), 500
    except Exception as e:
        # 处理其他异常
        return jsonify({
            "error": f"Unexpected error: {str(e)}"
        }), 500

import json
import requests
from qwen_agent.llm import get_chat_model

def save_to_flomo(content):
    """Save content to Flomo notes"""
    try:
        api_url = "http://localhost:6500/api/flomo/save" 

        data = {"content": content}

        response = requests.post(
            api_url,
            headers={"Content-Type": "application/json"},
            json=data,
            timeout=10
        )

        if response.status_code == 200:
            print(f"Successfully saved to Flomo: {content}")
            return json.dumps(response.json())
        else:
            error_message = f"Failed to save to Flomo. Status code: {response.status_code}, Response: {response.text}"
            print(error_message)
            return json.dumps({"error": error_message})

    except Exception as e:
        error_message = f"Error calling Flomo API: {str(e)}"
        print(error_message)
        return json.dumps({"error": error_message})

def test(fncall_prompt_type: str = 'qwen'):
    llm = get_chat_model({
        'model': 'qwen2.5:7b',
        'model_server': 'http://localhost:11434/v1',
        'api_key': "",
        'generate_cfg': {
            'fncall_prompt_type': fncall_prompt_type
        }
    })

    # 第1步：将对话和可用函数发送给模型
    messages = [{'role': 'user', 'content': "怎么学习软件架构，总结为三点，保存到笔记"}]
    functions = [{
        'name': 'save_to_flomo',
        'description': '保存内容到Flomo笔记',
        'parameters': {
            'type': 'object',
            'properties': {
                'content': {
                    'type': 'string',
                    'description': '内容',
                }
            },
            'required': ['content'],
        },
    }]

    responses = []
    for responses in llm.chat(
            messages=messages,
            functions=functions,
            stream=False,  
    ):
        print(responses)

    # 如果使用stream=False，responses直接是结果，不需要循环
    if isinstance(responses, list):
        messages.extend(responses) 
    else:
        messages.append(responses) 

    # 第2步：检查模型是否想要调用函数
    last_response = messages[-1]
    if last_response.get('function_call', None):
        # 第3步：调用函数
        available_functions = {
            'save_to_flomo': save_to_flomo,
        }
        function_name = last_response['function_call']['name']
        function_to_call = available_functions[function_name]
        function_args = json.loads(last_response['function_call']['arguments'])
        function_response = function_to_call(
            content=function_args.get('content'),
        )
        print('# Function Response:')
        print(function_response)

        # 第4步：发送每个函数调用和函数响应到模型，让大模型返回最终的结果
        messages.append({
            'role': 'function',
            'name': function_name,
            'content': function_response,
        }) 

        for responses in llm.chat(
                messages=messages,
                functions=functions,
                stream=False,
        ): 
            print(responses)

if __name__ == '__main__':
    test()