• 如何使用GPT-4o函数调用构建一个实时应用程序？

    本教程介绍了如何使用OpenAI最新的LLM GPT-4o通过函数调用将实时数据引入LLM。

    我们在LLM函数调用指南(详见https://thenewstack.io/a-comprehensive-guide-to-function-calling-in-llms/)中讨论了如何将实时数据引入聊天机器人和代理。现在，我们将通过将来自FlightAware.com的API与新的GPT-4o模型集成，进一步探究这个概念，以便实时跟踪航班状态。

    FlightAware的AeroAPI是一个可靠的充分利用REST的API，提供按需访问航班跟踪和状态数据。它允许开发人员通过一个基于查询的简单系统，获取实时、历史或未来的航班信息。API支持基于航班标识符、飞机注册号或机场或运营商等位置的详细请求。它旨在以JSON格式提供精确、可操作的航空数据，支持整个航空业从航空公司到机场的运营需求。

    在继续之前，注册FlightAware并获得API密钥，这对于调用REST API至关重要。免费的个人套餐足以完成本教程。

    第1步：定义获取航班状态的函数

    一旦您获得了API密钥，用Python创建以下函数来检索任何航班的状态。

    1. import ast
    2. 	import json
    3. 	import random
    4. 	from datetime import datetime, timedelta
    5. 	import requests
    6. 	import pytz
    7. 	
    8. 	def get_flight_status(flight):
    9. 	    """Returns Flight Information"""
    10. 	
    11. 	    AEROAPI_BASE_URL = "https://aeroapi.flightaware.com/aeroapi"
    12. 	    AEROAPI_KEY="YOUR FLIGHTAWARE API KEY"
    13. 	    
    14. 	    def get_api_session():
    15. 	        session = requests.Session()
    16. 	        session.headers.update({"x-apikey": AEROAPI_KEY})
    17. 	        return session
    18. 	
    19. 	    def fetch_flight_data(flight_id, session):
    20. 	        if "flight_id=" in flight_id:
    21. 	            flight_id = flight_id.split("flight_id=")[1]    
    22. 	        
    23. 	        start_date = datetime.now().date().strftime('%Y-%m-%d')
    24. 	        end_date = (datetime.now().date() + timedelta(days=1)).strftime('%Y-%m-%d')
    25. 	        api_resource = f"/flights/{flight_id}?start={start_date}&end={end_date}"
    26. 	        response = session.get(f"{AEROAPI_BASE_URL}{api_resource}")
    27. 	        response.raise_for_status()
    28. 	        return response.json()['flights'][0]
    29. 	
    30. 	    def utc_to_local(utc_date_str, local_timezone_str):
    31. 	        utc_datetime = datetime.strptime(utc_date_str, '%Y-%m-%dT%H:%M:%SZ').replace(tzinfo=pytz.utc)
    32. 	        local_timezone = pytz.timezone(local_timezone_str)
    33. 	        local_datetime = utc_datetime.astimezone(local_timezone)
    34. 	        return local_datetime.strftime('%Y-%m-%d %H:%M:%S')    
    35. 	    
    36. 	    session = get_api_session()
    37. 	    flight_data = fetch_flight_data(flight, session)
    38. 	    
    39. 	    dep_key = 'estimated_out' if 'estimated_out' in flight_data and flight_data['estimated_out'] else \
    40. 	          'actual_out' if 'actual_out' in flight_data and flight_data['actual_out'] else \
    41. 	          'scheduled_out'
    42. 	    
    43. 	    arr_key = 'estimated_in' if 'estimated_in' in flight_data and flight_data['estimated_in'] else \
    44. 	          'actual_in' if 'actual_in' in flight_data and flight_data['actual_in'] else \
    45. 	          'scheduled_in'    
    46. 	    
    47. 	    flight_details = {
    48. 	        'flight':flight,
    49. 	        'source': flight_data['origin']['city'],
    50. 	        'destination': flight_data['destination']['city'],
    51. 	        'depart_time': utc_to_local(flight_data[dep_key], flight_data['origin']['timezone']),
    52. 	        'arrival_time': utc_to_local(flight_data[arr_key], flight_data['destination']['timezone']),
    53. 	        'status': flight_data['status']
    54. 	    }
    55. 	    return json.dumps(flight_details)
    56. 	
    57. 	flight_info = get_flight_status("EK524")
    58. 	print(flight_info)
    59. 	#'{"flight": "EK524", "source": "Dubai", "destination": "Hyderabad", "depart_time": "2024-05-23 22:00:00", "arrival_time": "2024-05-24 03:05:00", "status": "Scheduled"}'

    虽然代码很简单，但还是不妨解释一下关键步骤。

    get_flight_status函数接受一个航班参数(假设是航班标识符)，并以JSON格式返回格式化的航班详细信息。它查询AeroAPI以根据给定的航班标识符获取航班数据，并确定关键细节的格式，比如出发地、目的地、离开时间、到达时间和状态。

    不妨看看脚本的组件：

    API凭据：

    AEROAPI_BASE_URL是FlightAware AeroAPI的基础URL。

    AEROAPI_KEY是用于身份验证的API密钥。

    会话管理：

    get_api_session：这个嵌套函数初始化请求。会话对象使用API密钥设置所需的报头，并返回会话对象。该会话将处理所有API请求。

    数据获取：

    fetch_flight_data：这个函数接受flight_id和session作为参数。它使用适当的日期过滤器构造端点URL，用于获取一天的数据，并发送GET请求以检索航班数据。该函数处理API响应，并提取相关的航班信息。

    时间转换：

    utc_to_local：根据所提供的时区字符串将UTC时间(来自API响应)转换为本地时间。这个函数可以帮助我们获得基于城市的到达和离开时间。

    数据处理：

    脚本根据估计或实际时间的可用性确定离开时间和到达时间的键，并返回到计划时间。然后，它构造一个含有格式化航班详细信息的字典。

    上面的截图显示了我们从FlightAware API收到的从迪拜飞往海得拉巴的阿联酋航空EK524航班的响应信息。请注意，到达和离开时间是基于城市的当地时间。

    我们的目的是将该函数与GPT-4 Omni集成，使其能够实时访问航班跟踪信息。

    第2步：用GPT- 4o实现函数调用

    不妨从导入OpenAI库并初始化它入手。

    1. from openai import OpenAI
    2. client = OpenAI()

    这一行创建了OpenAI类的一个实例。这个实例(客户端)将用于与OpenAI API交互。

    我们将定义一个名为tools的列表，含有一个字典，该字典指定了函数get_flight_status。该函数旨在用作OpenAI API上下文中的工具，描述参数和所需输入。

    繁重工作在下面的函数中进行，其中LLM检查提示以确定是否需要调用函数/工具，然后继续生成适当的响应。

    1. def chatbot(prompt):
    2.     # Step 1: send the conversation and available functions to the model
    3.     messages = [{"role": "user", "content": prompt}]
    4.     response = client.chat.completions.create(
    5.         model="gpt-4o",
    6.         messages=messages,
    7.         tools=tools,
    8.         tool_choice="auto"
    9.     )
    10.     response_message = response.choices[0].message
    11.     tool_calls = response_message.tool_calls
    12.  
    13.     # Step 2: check if the model wanted to call a function
    14.     if tool_calls:
    15.         available_functions = {
    16.             "get_flight_status": get_flight_status,
    17.         }  
    18.         messages.append(response_message)  
    19.         
    20.         # Step 3: send the function response to the model
    21.         for tool_call in tool_calls:
    22.             function_name = tool_call.function.name
    23.             function_to_call = available_functions[function_name]
    24.             function_args = json.loads(tool_call.function.arguments)
    25.             function_response = function_to_call(flight=function_args.get("flight"))
    26.             messages.append(
    27.                 {
    28.                     "tool_call_id": tool_call.id,
    29.                     "role": "tool",
    30.                     "name": function_name,
    31.                     "content": function_response,
    32.                 }
    33.             )  
    34.         final_response = client.chat.completions.create(
    35.             model="gpt-4o",
    36.             messages=messages,
    37.         )  
    38.         return final_response

    这个函数chatbot接受用户提示，并使用OpenAI API对其进行处理。它将提示和定义的工具发送到OpenAI模型并处理响应。

    通过嵌入来自用户的提示并将其发送到OpenAI API(chat.completion .create)来创建消息。API使用指定的工具(如果适用)处理这些消息。

    比如说，当我们发送提示“EK524的状态是什么?”，GPT- 4o需要调用工具列表中提供的函数，并返回以下响应：

    注意，响应包括函数(get_flight_status)和参数(EK226)。

    下一步检查是否调用了任何工具(即工具中的函数)。它使用提供的参数执行这些函数，将它们的输出集成到对话中，并将这些更新后的信息发回到OpenAI API以进行进一步处理。

    1. # Step 2: check if the model wanted to call a function
    2.     if tool_calls:
    3.         available_functions = {
    4.             "get_flight_status": get_flight_status,
    5.         }  
    6.         messages.append(response_message)  
    7.         
    8.         # Step 3: send the info for each function call and function response to the model
    9.         for tool_call in tool_calls:
    10.             function_name = tool_call.function.name
    11.             function_to_call = available_functions[function_name]
    12.             function_args = json.loads(tool_call.function.arguments)
    13.             function_response = function_to_call(flight=function_args.get("flight"))
    14.             messages.append(
    15.                 {
    16.                     "tool_call_id": tool_call.id,
    17.                     "role": "tool",
    18.                     "name": function_name,
    19.                     "content": function_response,
    20.                 }
    21.             )

    此时，messages列表包括原始提示、带有函数名和变量的初始响应以及函数的实际输出。下面的屏幕截图显示了含有所有要素的列表。

    由于来自工具的响应附加到历史记录中，我们可以调用聊天完成端点，从LLM获得最终答案。

    1. final_response = client.chat.completions.create(
    2.             model="gpt-4o",
    3.             messages=messages,
    4.         )  
    5.         return final_response

    final_response对象有我们所寻找的答案：

    将提示发送给函数chatbot将返回指定航班的实时状态。

    下面是本教程的完整代码：

    1. from openai import OpenAI
    2.  
    3. #Initialize the environment variable OPENAI_API_KEY with your api key
    4. 	client = OpenAI()
    5. 	
    6. 	
    7. #Function is available at 
    8. https://gist.github.com/janakiramm/2143b909626f5f01d64739e3fe90c9c8
    9. 	
    10. 	tools = [
    11. 	    {
    12. 	        "type": "function",
    13. 	        "function": {
    14. 	            "name": "get_flight_status",
    15. 	            "description": "Get status of a flight",
    16. 	            "parameters": {
    17. 	                "type": "object",
    18. 	                "properties": {
    19. 	                    "flight": {
    20. 	                        "type": "string",
    21. 	                        "description": "Flight number"
    22. 	                    }
    23. 	                },
    24. 	                "required": ["flight"]
    25. 	            }
    26. 	        }
    27. 	    }
    28. 	]
    29. 	
    30. 	
    31. def chatbot(prompt):
    32. 	    # Step 1: send the conversation and available functions to the model
    33. 	    messages = [{"role": "user", "content": prompt}]
    34. 	    response = client.chat.completions.create(
    35. 	        model="gpt-4o",
    36. 	        messages=messages,
    37. 	        tools=tools,
    38. 	        tool_choice="auto"
    39. 	    )
    40. 	    response_message = response.choices[0].message
    41. 	    tool_calls = response_message.tool_calls
    42. 	
    43. 	
    44.     # Step 2: check if the model wanted to call a function
    45. 	    if tool_calls:
    46. 	        available_functions = {
    47. 	            "get_flight_status": get_flight_status,
    48. 	        }  
    49. 	        messages.append(response_message)  
    50. 	        
    51. 	        # Step 3: send the info for each function call and function response to the model
    52. 	        for tool_call in tool_calls:
    53. 	            function_name = tool_call.function.name
    54. 	            function_to_call = available_functions[function_name]
    55. 	            function_args = json.loads(tool_call.function.arguments)
    56. 	            function_response = function_to_call(flight=function_args.get("flight"))
    57. 	            messages.append(
    58. 	                {
    59. 	                    "tool_call_id": tool_call.id,
    60. 	                    "role": "tool",
    61. 	                    "name": function_name,
    62. 	                    "content": function_response,
    63. 	                }
    64. 	            ) 
    65. 	        final_response = client.chat.completions.create(
    66. 	            model="gpt-4o",
    67. 	            messages=messages,
    68. 	        )  
    69. 	        return final_response
    70. 	
    71. 	
    72. res=chatbot("What's the status of EK226?")
    73. 	print(res.choices[0].message.content)

    我们在本教程中探讨了如何通过函数调用将实时数据引入LLM。在本系列的下一部分中，我们将把GPT-4o换成Gemini Pro，以探究相同的概念，但使用不同的模型。

  • 相关阅读:
    游戏工程管理
    Web:体验原生的组件化开发
    css大屏动画效果
    微服务之间的横向关系与微服务与数据层之间的纵向关系
    Java连接FTP服务器，并使用ftp连接池进行文件操作
    前端try和catch
    手把手调参最新 YOLOv7 模型 推理部分 - 最新版本（一）
    Yield Guild Games：社区更新——2022 年第二季度
    使用 Dapr JS SDK 让 Nest.js 集成 Dapr
    电动力学专题研讨：运动电荷之间的相互作用是否满足牛顿第三定律？
  • 原文地址：https://blog.csdn.net/2401_85157201/article/details/139544729