KI-Agenten-Loop mit Function Calling implementieren

Konversationshistorie initialisieren.

Beginnen Sie mit einer Liste von Nachrichten, die die Konversation repräsentieren. Die erste Nachricht ist normalerweise die Benutzeranfrage.

messages = [
    {"role": "user", "content": "Wie ist das Wetter in Boston?"}
]

Ersten API-Aufruf mit Tools tätigen.

Senden Sie die Nachrichtenhistorie und die Tool-Definitionen an die OpenAI API. 'tool_choice="auto"' lässt das LLM entscheiden, ob ein Tool aufgerufen werden soll.

response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools, # Die zuvor definierte Liste von Tool-Schemas
    tool_choice="auto"
)

Antwort des LLM verarbeiten und Tool-Aufrufe erkennen.

Überprüfen Sie, ob die LLM-Antwort 'tool_calls' enthält. Wenn ja, müssen diese ausgeführt werden.

response_message = response.choices[0].message
tool_calls = response_message.tool_calls

if tool_calls:
    messages.append(response_message) # Füge die Antwort des Assistenten mit Tool-Aufrufen zur Historie hinzu
    
    # Mapping von Funktionsnamen zu den tatsächlichen Python-Funktionen
    available_functions = {
        "get_current_weather": get_current_weather,
        # "get_n_day_forecast": get_n_day_forecast # Fügen Sie hier weitere Funktionen hinzu
    }

    for tool_call in tool_calls:
        function_name = tool_call.function.name
        function_to_call = available_functions[function_name]
        function_args = json.loads(tool_call.function.arguments)
        
        # Führe die Funktion aus und füge das Ergebnis zur Historie hinzu
        function_response = function_to_call(**function_args)
        messages.append(
            {
                "tool_call_id": tool_call.id,
                "role": "tool",
                "name": function_name,
                "content": function_response,
            }
        )
    
    # Zweiter API-Aufruf mit den Tool-Ergebnissen
    second_response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages
    )
    print(second_response.choices[0].message.content)
else:
    # Keine Tools wurden aufgerufen, gib die direkte Antwort des LLM aus
    print(response_message.content)

Den Agenten-Loop in eine Funktion kapseln.

Um den Agenten wiederverwendbar zu machen, kapseln Sie die Logik in eine Funktion, die eine Benutzeranfrage entgegennimmt und die Antwort zurückgibt.

def run_conversation(user_message, client, tools, available_functions):
    messages = [
        {"role": "user", "content": user_message}
    ]
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=tools,
        tool_choice="auto"
    )
    response_message = response.choices[0].message
    tool_calls = response_message.tool_calls

    if tool_calls:
        messages.append(response_message)
        for tool_call in tool_calls:
            function_name = tool_call.function.name
            function_to_call = available_functions[function_name]
            function_args = json.loads(tool_call.function.arguments)
            function_response = function_to_call(**function_args)
            messages.append(
                {
                    "tool_call_id": tool_call.id,
                    "role": "tool",
                    "name": function_name,
                    "content": function_response,
                }
            )
        second_response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages
        )
        return second_response.choices[0].message.content
    else:
        return response_message.content

# Beispielaufruf
# final_answer = run_conversation("Wie ist das Wetter in Berlin?", client, tools, available_functions)
# print(final_answer)

Fehlerbehandlung und Robustheit verbessern.

Fügen Sie `try-except`-Blöcke hinzu, um API-Fehler, JSON-Parsing-Fehler oder Fehler bei der Funktionsausführung abzufangen und zu behandeln.