Verwendung von Funktionsaufrufen mit Microsoft-Foundry-Modellen

Hinweis

In diesem Beispiel wird die OpenAI-kompatible Chat-Abschluss-API über einen Foundry Models-Endpunkt verwendet. Funktionsaufrufe über die Antwort-API verwenden ein anderes Anforderungs- und Antwortformat. Weitere Informationen finden Sie unter Verwenden der Azure OpenAI-Antwort-API.

Wenn Sie eine oder mehrere Funktionen in Ihre Anforderung einschließen, entscheidet das Modell, ob eine der Funktionen basierend auf dem Kontext der Eingabeaufforderung aufgerufen werden soll. Wenn das Modell entscheidet, eine Funktion aufzurufen, antwortet es mit einem JSON-Objekt, das die Argumente für die Funktion enthält.

Das Modell generiert Funktionsaufrufe und strukturierte Argumente basierend auf den von Ihnen angegebenen Funktionen. Ihre Anwendung führt die Funktionen aus und gibt die Ergebnisse an das Modell zurück, sodass Sie die Kontrolle über die ausgeführten Aktionen behalten.

Auf hoher Ebene können Sie die Arbeit mit Funktionen in drei Schritte unterteilen:

Aufrufen der API für Chatabschlusse mit Ihren Funktionen und der Benutzereingabe
Verwenden der Antwort des Modells zum Aufrufen Ihrer API oder Funktion
Erneutes Aufrufen der Chatvervollständigungs-API, einschließlich der Antwort Ihrer Funktion, um eine endgültige Antwort zu erhalten

Voraussetzungen

Eine Bereitstellung eines Foundry-Modells, die Funktionsaufrufe über die Chat Completions API unterstützt.
Ein Foundry-Ressourcenendpunkt im Format https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/.
Für die Microsoft Entra ID-Authentifizierung:
- Eine benutzerdefinierte Unterdomäne konfiguriert. Weitere Informationen finden Sie unter Benutzerdefinierte Unterdomänennamen.
- Pakete: pip install openai azure-identity.

Beispiel für einzelne Tool-/Funktionsaufrufe

Dieses Beispiel zeigt einen einfachen Funktionsaufruf, der die Uhrzeit an drei hartcodierten Orten mit nur einem definierten Tool bzw. einer definierten Funktion abfragt. Druckanweisungen vereinfachen die Codeausführung:

Microsoft Entra-ID
API-Schlüssel

import os
import json
from openai import OpenAI
from datetime import datetime
from zoneinfo import ZoneInfo
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)

client = OpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  api_key=token_provider,
)

# Define the deployment you want to use for your chat completions API calls

deployment_name = "<YOUR_DEPLOYMENT_NAME_HERE>"

# Simplified timezone data
TIMEZONE_DATA = {
    "tokyo": "Asia/Tokyo",
    "san francisco": "America/Los_Angeles",
    "paris": "Europe/Paris"
}

def get_current_time(location):
    """Get the current time for a given location"""
    print(f"get_current_time called with location: {location}")  
    location_lower = location.lower()
    
    for key, timezone in TIMEZONE_DATA.items():
        if key in location_lower:
            print(f"Timezone found for {key}")  
            current_time = datetime.now(ZoneInfo(timezone)).strftime("%I:%M %p")
            return json.dumps({
                "location": location,
                "current_time": current_time
            })
    
    print(f"No timezone data found for {location_lower}")  
    return json.dumps({"location": location, "current_time": "unknown"})

def run_conversation():
    # Initial user message
    messages = [{"role": "user", "content": "What's the current time in San Francisco"}] # Single function call
    #messages = [{"role": "user", "content": "What's the current time in San Francisco, Tokyo, and Paris?"}] # Parallel function call with a single tool/function defined

    # Define the function for the model
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_current_time",
                "description": "Get the current time in a given location",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city name, e.g. San Francisco",
                        },
                    },
                    "required": ["location"],
                },
            }
        }
    ]

    # First API call: Ask the model to use the function
    response = client.chat.completions.create(
        model=deployment_name,
        messages=messages,
        tools=tools,
        tool_choice="auto",
    )

    # Process the model's response
    response_message = response.choices[0].message
    messages.append(response_message)

    print("Model's response:")  
    print(response_message)  

    # Handle function calls
    if response_message.tool_calls:
        for tool_call in response_message.tool_calls:
            if tool_call.function.name == "get_current_time":
                function_args = json.loads(tool_call.function.arguments)
                print(f"Function arguments: {function_args}")  
                time_response = get_current_time(
                    location=function_args.get("location")
                )
                messages.append({
                    "tool_call_id": tool_call.id,
                    "role": "tool",
                    "name": "get_current_time",
                    "content": time_response,
                })
    else:
        print("No tool calls were made by the model.")  

    # Second API call: Get the final response from the model
    final_response = client.chat.completions.create(
        model=deployment_name,
        messages=messages,
    )

    return final_response.choices[0].message.content

# Run the conversation and print the result
print(run_conversation())

import os
import json
from openai import OpenAI
from datetime import datetime
from zoneinfo import ZoneInfo

# Initialize the client
client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_INFERENCE_CREDENTIAL")
)

# Define the deployment you want to use for your chat completions API calls

deployment_name = "<YOUR_DEPLOYMENT_NAME_HERE>"

# Simplified timezone data
TIMEZONE_DATA = {
    "tokyo": "Asia/Tokyo",
    "san francisco": "America/Los_Angeles",
    "paris": "Europe/Paris"
}

def get_current_time(location):
    """Get the current time for a given location"""
    print(f"get_current_time called with location: {location}")  
    location_lower = location.lower()
    
    for key, timezone in TIMEZONE_DATA.items():
        if key in location_lower:
            print(f"Timezone found for {key}")  
            current_time = datetime.now(ZoneInfo(timezone)).strftime("%I:%M %p")
            return json.dumps({
                "location": location,
                "current_time": current_time
            })
    
    print(f"No timezone data found for {location_lower}")  
    return json.dumps({"location": location, "current_time": "unknown"})

def run_conversation():
    # Initial user message
    messages = [{"role": "user", "content": "What's the current time in San Francisco"}] # Single function call
    #messages = [{"role": "user", "content": "What's the current time in San Francisco, Tokyo, and Paris?"}] # Parallel function call with a single tool/function defined

    # Define the function for the model
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_current_time",
                "description": "Get the current time in a given location",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city name, e.g. San Francisco",
                        },
                    },
                    "required": ["location"],
                },
            }
        }
    ]

    # First API call: Ask the model to use the function
    response = client.chat.completions.create(
        model=deployment_name,
        messages=messages,
        tools=tools,
        tool_choice="auto",
    )

    # Process the model's response
    response_message = response.choices[0].message
    messages.append(response_message)

    print("Model's response:")  
    print(response_message)  

    # Handle function calls
    if response_message.tool_calls:
        for tool_call in response_message.tool_calls:
            if tool_call.function.name == "get_current_time":
                function_args = json.loads(tool_call.function.arguments)
                print(f"Function arguments: {function_args}")  
                time_response = get_current_time(
                    location=function_args.get("location")
                )
                messages.append({
                    "tool_call_id": tool_call.id,
                    "role": "tool",
                    "name": "get_current_time",
                    "content": time_response,
                })
    else:
        print("No tool calls were made by the model.")  

    # Second API call: Get the final response from the model
    final_response = client.chat.completions.create(
        model=deployment_name,
        messages=messages,
    )

    return final_response.choices[0].message.content

# Run the conversation and print the result
print(run_conversation())

Ausgabe:

Model's response:
ChatCompletionMessage(content=None, role='assistant', function_call=None, tool_calls=[ChatCompletionMessageToolCall(id='call_pOsKdUlqvdyttYB67MOj434b', function=Function(arguments='{"location":"San Francisco"}', name='get_current_time'), type='function')])
Function arguments: {'location': 'San Francisco'}
get_current_time called with location: San Francisco
Timezone found for san francisco
The current time in San Francisco is 09:24 AM.

Wenn wir eine Modellbereitstellung verwenden, die parallele Funktionsaufrufe unterstützt, können wir dies in ein Beispiel für parallele Funktionsaufrufe konvertieren, indem sie das Nachrichtenarray so ändern, dass die Zeit an mehreren Stellen anstelle einer von ihnen angefordert wird.

Um dies zu erreichen, tauschen Sie die Kommentare in diesen beiden Zeilen aus:

    messages = [{"role": "user", "content": "What's the current time in San Francisco"}] # Single function call
    #messages = [{"role": "user", "content": "What's the current time in San Francisco, Tokyo, and Paris?"}] # Parallel function call with a single tool/function defined

Damit es so aussieht, und führen Sie den Code erneut aus:

    #messages = [{"role": "user", "content": "What's the current time in San Francisco"}] # Single function call
    messages = [{"role": "user", "content": "What's the current time in San Francisco, Tokyo, and Paris?"}] # Parallel function call with a single tool/function defined

Dadurch wird die folgende Ausgabe generiert:

Ausgabe:

Model's response:
ChatCompletionMessage(content=None, role='assistant', function_call=None, tool_calls=[ChatCompletionMessageToolCall(id='call_IjcAVz9JOv5BXwUx1jd076C1', function=Function(arguments='{"location": "San Francisco"}', name='get_current_time'), type='function'), ChatCompletionMessageToolCall(id='call_XIPQYTCtKIaNCCPTdvwjkaSN', function=Function(arguments='{"location": "Tokyo"}', name='get_current_time'), type='function'), ChatCompletionMessageToolCall(id='call_OHIB5aJzO8HGqanmsdzfytvp', function=Function(arguments='{"location": "Paris"}', name='get_current_time'), type='function')])
Function arguments: {'location': 'San Francisco'}
get_current_time called with location: San Francisco
Timezone found for san francisco
Function arguments: {'location': 'Tokyo'}
get_current_time called with location: Tokyo
Timezone found for tokyo
Function arguments: {'location': 'Paris'}
get_current_time called with location: Paris
Timezone found for paris
As of now, the current times are:

- **San Francisco:** 11:15 AM
- **Tokyo:** 03:15 AM (next day)
- **Paris:** 08:15 PM

Parallele Funktionsaufrufe ermöglichen es Ihnen, mehrere Funktionsaufrufe zusammen auszuführen, wodurch parallele Ausführung und Abruf von Ergebnissen ermöglicht werden. Dadurch wird die Anzahl der Aufrufe an die API reduziert, die getätigt werden müssen, und kann die Gesamtleistung verbessern.

In unserer einfachen Zeit-App haben wir beispielsweise mehrmals gleichzeitig abgerufen. Dies führte zu einer Chatabschlussnachricht mit drei Funktionsaufrufen im tool_calls Array, jeweils mit einem eindeutigen id. Wenn Sie auf diese Funktionsaufrufe antworten möchten, fügen Sie der Unterhaltung drei neue Nachrichten hinzu, die jeweils das Ergebnis eines Funktionsaufrufs enthalten, mit einem tool_call_id Verweis auf die id von tool_calls.

Um zu erzwingen, dass das Modell eine bestimmte Funktion aufruft, legen Sie tool_choice es auf ein benanntes Toolobjekt fest, z. B.: tool_choice={"type": "function", "function": {"name": "get_current_time"}}. Um eine benutzerorientierte Nachricht zu erzwingen, legen Sie fest tool_choice="none".

Hinweis

Das Standardverhalten (tool_choice: "auto") dient dem Modell, sich selbst zu entscheiden, ob eine Funktion aufgerufen werden soll und welche Funktion aufgerufen werden soll.

Paralleler Funktionsaufruf mit mehreren Funktionen

Nun demonstrieren wir ein weiteres Beispiel für das Aufrufen von Spielzeugfunktionen, dieses Mal mit zwei definierten unterschiedlichen Tools oder Funktionen.

Microsoft Entra-ID
API-Schlüssel

import os
import json
from openai import OpenAI
from datetime import datetime, timedelta
from zoneinfo import ZoneInfo
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)

client = OpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  api_key=token_provider,
)

# Provide the model deployment name you want to use for this example

deployment_name = "YOUR_DEPLOYMENT_NAME_HERE" 

# Simplified weather data
WEATHER_DATA = {
    "tokyo": {"temperature": "10", "unit": "celsius"},
    "san francisco": {"temperature": "72", "unit": "fahrenheit"},
    "paris": {"temperature": "22", "unit": "celsius"}
}

# Simplified timezone data
TIMEZONE_DATA = {
    "tokyo": "Asia/Tokyo",
    "san francisco": "America/Los_Angeles",
    "paris": "Europe/Paris"
}

def get_current_weather(location, unit=None):
    """Get the current weather for a given location"""
    location_lower = location.lower()
    print(f"get_current_weather called with location: {location}, unit: {unit}")  
    
    for key in WEATHER_DATA:
        if key in location_lower:
            print(f"Weather data found for {key}")  
            weather = WEATHER_DATA[key]
            return json.dumps({
                "location": location,
                "temperature": weather["temperature"],
                "unit": unit if unit else weather["unit"]
            })
    
    print(f"No weather data found for {location_lower}")  
    return json.dumps({"location": location, "temperature": "unknown"})

def get_current_time(location):
    """Get the current time for a given location"""
    print(f"get_current_time called with location: {location}")  
    location_lower = location.lower()
    
    for key, timezone in TIMEZONE_DATA.items():
        if key in location_lower:
            print(f"Timezone found for {key}")  
            current_time = datetime.now(ZoneInfo(timezone)).strftime("%I:%M %p")
            return json.dumps({
                "location": location,
                "current_time": current_time
            })
    
    print(f"No timezone data found for {location_lower}")  
    return json.dumps({"location": location, "current_time": "unknown"})

def run_conversation():
    # Initial user message
    messages = [{"role": "user", "content": "What's the weather and current time in San Francisco, Tokyo, and Paris?"}]

    # Define the functions for the model
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_current_weather",
                "description": "Get the current weather in a given location",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city name, e.g. San Francisco",
                        },
                        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
                    },
                    "required": ["location"],
                },
            }
        },
        {
            "type": "function",
            "function": {
                "name": "get_current_time",
                "description": "Get the current time in a given location",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city name, e.g. San Francisco",
                        },
                    },
                    "required": ["location"],
                },
            }
        }
    ]

    # First API call: Ask the model to use the functions
    response = client.chat.completions.create(
        model=deployment_name,
        messages=messages,
        tools=tools,
        tool_choice="auto",
    )

    # Process the model's response
    response_message = response.choices[0].message
    messages.append(response_message)

    print("Model's response:")  
    print(response_message)  

    # Handle function calls
    if response_message.tool_calls:
        for tool_call in response_message.tool_calls:
            function_name = tool_call.function.name
            function_args = json.loads(tool_call.function.arguments)
            print(f"Function call: {function_name}")  
            print(f"Function arguments: {function_args}")  
            
            if function_name == "get_current_weather":
                function_response = get_current_weather(
                    location=function_args.get("location"),
                    unit=function_args.get("unit")
                )
            elif function_name == "get_current_time":
                function_response = get_current_time(
                    location=function_args.get("location")
                )
            else:
                function_response = json.dumps({"error": "Unknown function"})
            
            messages.append({
                "tool_call_id": tool_call.id,
                "role": "tool",
                "name": function_name,
                "content": function_response,
            })
    else:
        print("No tool calls were made by the model.")  

    # Second API call: Get the final response from the model
    final_response = client.chat.completions.create(
        model=deployment_name,
        messages=messages,
    )

    return final_response.choices[0].message.content

# Run the conversation and print the result
print(run_conversation())

import os
import json
from openai import OpenAI
from datetime import datetime, timedelta
from zoneinfo import ZoneInfo

# Initialize the client
client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=os.getenv("AZURE_INFERENCE_CREDENTIAL")
)

# Provide the model deployment name you want to use for this example

deployment_name = "YOUR_DEPLOYMENT_NAME_HERE" 

# Simplified weather data
WEATHER_DATA = {
    "tokyo": {"temperature": "10", "unit": "celsius"},
    "san francisco": {"temperature": "72", "unit": "fahrenheit"},
    "paris": {"temperature": "22", "unit": "celsius"}
}

# Simplified timezone data
TIMEZONE_DATA = {
    "tokyo": "Asia/Tokyo",
    "san francisco": "America/Los_Angeles",
    "paris": "Europe/Paris"
}

def get_current_weather(location, unit=None):
    """Get the current weather for a given location"""
    location_lower = location.lower()
    print(f"get_current_weather called with location: {location}, unit: {unit}")  
    
    for key in WEATHER_DATA:
        if key in location_lower:
            print(f"Weather data found for {key}")  
            weather = WEATHER_DATA[key]
            return json.dumps({
                "location": location,
                "temperature": weather["temperature"],
                "unit": unit if unit else weather["unit"]
            })
    
    print(f"No weather data found for {location_lower}")  
    return json.dumps({"location": location, "temperature": "unknown"})

def get_current_time(location):
    """Get the current time for a given location"""
    print(f"get_current_time called with location: {location}")  
    location_lower = location.lower()
    
    for key, timezone in TIMEZONE_DATA.items():
        if key in location_lower:
            print(f"Timezone found for {key}")  
            current_time = datetime.now(ZoneInfo(timezone)).strftime("%I:%M %p")
            return json.dumps({
                "location": location,
                "current_time": current_time
            })
    
    print(f"No timezone data found for {location_lower}")  
    return json.dumps({"location": location, "current_time": "unknown"})

def run_conversation():
    # Initial user message
    messages = [{"role": "user", "content": "What's the weather and current time in San Francisco, Tokyo, and Paris?"}]

    # Define the functions for the model
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_current_weather",
                "description": "Get the current weather in a given location",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city name, e.g. San Francisco",
                        },
                        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
                    },
                    "required": ["location"],
                },
            }
        },
        {
            "type": "function",
            "function": {
                "name": "get_current_time",
                "description": "Get the current time in a given location",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city name, e.g. San Francisco",
                        },
                    },
                    "required": ["location"],
                },
            }
        }
    ]

    # First API call: Ask the model to use the functions
    response = client.chat.completions.create(
        model=deployment_name,
        messages=messages,
        tools=tools,
        tool_choice="auto",
    )

    # Process the model's response
    response_message = response.choices[0].message
    messages.append(response_message)

    print("Model's response:")  
    print(response_message)  

    # Handle function calls
    if response_message.tool_calls:
        for tool_call in response_message.tool_calls:
            function_name = tool_call.function.name
            function_args = json.loads(tool_call.function.arguments)
            print(f"Function call: {function_name}")  
            print(f"Function arguments: {function_args}")  
            
            if function_name == "get_current_weather":
                function_response = get_current_weather(
                    location=function_args.get("location"),
                    unit=function_args.get("unit")
                )
            elif function_name == "get_current_time":
                function_response = get_current_time(
                    location=function_args.get("location")
                )
            else:
                function_response = json.dumps({"error": "Unknown function"})
            
            messages.append({
                "tool_call_id": tool_call.id,
                "role": "tool",
                "name": function_name,
                "content": function_response,
            })
    else:
        print("No tool calls were made by the model.")  

    # Second API call: Get the final response from the model
    final_response = client.chat.completions.create(
        model=deployment_name,
        messages=messages,
    )

    return final_response.choices[0].message.content

# Run the conversation and print the result
print(run_conversation())

Ausgabe

Model's response:
ChatCompletionMessage(content=None, role='assistant', function_call=None, tool_calls=[ChatCompletionMessageToolCall(id='call_djHAeQP0DFEVZ2qptrO0CYC4', function=Function(arguments='{"location": "San Francisco", "unit": "celsius"}', name='get_current_weather'), type='function'), ChatCompletionMessageToolCall(id='call_q2f1HPKKUUj81yUa3ITLOZFs', function=Function(arguments='{"location": "Tokyo", "unit": "celsius"}', name='get_current_weather'), type='function'), ChatCompletionMessageToolCall(id='call_6TEY5Imtr17PaB4UhWDaPxiX', function=Function(arguments='{"location": "Paris", "unit": "celsius"}', name='get_current_weather'), type='function'), ChatCompletionMessageToolCall(id='call_vpzJ3jElpKZXA9abdbVMoauu', function=Function(arguments='{"location": "San Francisco"}', name='get_current_time'), type='function'), ChatCompletionMessageToolCall(id='call_1ag0MCIsEjlwbpAqIXJbZcQj', function=Function(arguments='{"location": "Tokyo"}', name='get_current_time'), type='function'), ChatCompletionMessageToolCall(id='call_ukOu3kfYOZR8lpxGRpdkhhdD', function=Function(arguments='{"location": "Paris"}', name='get_current_time'), type='function')])
Function call: get_current_weather
Function arguments: {'location': 'San Francisco', 'unit': 'celsius'}
get_current_weather called with location: San Francisco, unit: celsius
Weather data found for san francisco
Function call: get_current_weather
Function arguments: {'location': 'Tokyo', 'unit': 'celsius'}
get_current_weather called with location: Tokyo, unit: celsius
Weather data found for tokyo
Function call: get_current_weather
Function arguments: {'location': 'Paris', 'unit': 'celsius'}
get_current_weather called with location: Paris, unit: celsius
Weather data found for paris
Function call: get_current_time
Function arguments: {'location': 'San Francisco'}
get_current_time called with location: San Francisco
Timezone found for san francisco
Function call: get_current_time
Function arguments: {'location': 'Tokyo'}
get_current_time called with location: Tokyo
Timezone found for tokyo
Function call: get_current_time
Function arguments: {'location': 'Paris'}
get_current_time called with location: Paris
Timezone found for paris
Here's the current information for the three cities:

### San Francisco
- **Time:** 09:13 AM
- **Weather:** 72°C (quite warm!)

### Tokyo
- **Time:** 01:13 AM (next day)
- **Weather:** 10°C

### Paris
- **Time:** 06:13 PM
- **Weather:** 22°C

Is there anything else you need?

Wichtig

Die JSON-Antwort ist möglicherweise nicht immer gültig, daher müssen Sie Ihrem Code zusätzliche Logik hinzufügen, um Fehler behandeln zu können. In einigen Anwendungsfällen werden Sie feststellen, dass Sie eine Feinabstimmung vornehmen müssen, um die Leistung von Funktionsaufrufen zu verbessern.

Prompt Engineering mit Funktionen

Wenn Sie eine Funktion als Teil Ihrer Anforderung definieren, werden die Details mithilfe bestimmter Syntax, auf die das Modell trainiert wurde, in die Systemmeldung eingefügt. Dies bedeutet, dass Funktionen Token in Ihrer Eingabeaufforderung nutzen und Prompt Engineering-Techniken anwenden können, um die Leistung Ihrer Funktionsaufrufe zu optimieren. Das Modell verwendet den vollständigen Kontext der Eingabeaufforderung, um festzustellen, ob eine Funktion aufgerufen werden soll, einschließlich Funktionsdefinition, Systemmeldung und Benutzermeldungen.

Verbesserung der Qualität und Zuverlässigkeit

Wenn das Modell Ihre Funktion nicht aufruft, wann oder wie Sie es erwarten, gibt es ein paar Dinge, die Sie versuchen können, die Qualität zu verbessern.

Bereitstellen weiterer Details in der Funktionsdefinition

Es ist wichtig, dass Sie eine aussagekräftige description Funktion bereitstellen und Beschreibungen für jeden Parameter bereitstellen, der für das Modell möglicherweise nicht offensichtlich ist. Beispielsweise können Sie in der Beschreibung für den location Parameter zusätzliche Details und Beispiele für das Format des Speicherorts einfügen.

"location": {
    "type": "string",
    "description": "The location of the hotel. The location should include the city and the state's abbreviation (i.e. Seattle, WA or Miami, FL)"
},

Bereitstellen von mehr Kontext in der Systemmeldung

Die Systemmeldung kann auch verwendet werden, um mehr Kontext für das Modell bereitzustellen. Wenn Sie beispielsweise eine Funktion namens search_hotels haben, könnten Sie eine Systemmeldung wie die folgende einschließen, um das Modell anzuweisen, die Funktion aufzurufen, wenn ein Benutzer nach Hilfe bei der Suche nach einem Hotel fragt.

{"role": "system", "content": "You're an AI assistant designed to help users search for hotels. When a user asks for help finding a hotel, you should call the search_hotels function."}

Weisen Sie das Modell an, klärende Fragen zu stellen

In einigen Fällen möchten Sie das Modell anweisen, fragende Fragen zu stellen, um annahmen zu verhindern, welche Werte mit Funktionen verwendet werden sollen. Sie könnten das Modell bei search_hotels beispielsweise anweisen, um Klärung zu bitten, wenn die Benutzendenanforderung keine Details zu location enthält. Um das Modell anzuweisen, eine klarstellende Frage zu stellen, könnten Sie Inhalte wie das nächste Beispiel in Ihre Systemnachricht einschließen.

{"role": "system", "content": "Don't make assumptions about what values to use with functions. Ask for clarification if a user request is ambiguous."}

Reduzieren von Fehlern

Ein weiterer Bereich, in dem das Prompt Engineering hilfreich sein kann, besteht darin, Fehler in Funktionsaufrufen zu reduzieren. Die Modelle werden geschult, um Funktionsaufrufe zu generieren, die dem von Ihnen definierten Schema entsprechen, aber die Modelle erzeugen einen Funktionsaufruf, der nicht mit dem von Ihnen definierten Schema übereinstimmt, oder versuchen, eine Funktion aufzurufen, die Sie nicht eingeschlossen haben.

Wenn Sie feststellen, dass das Modell Funktionsaufrufe generiert, die nicht bereitgestellt wurden, versuchen Sie, einen Satz in die Systemmeldung einzugeben, die besagt "Only use the functions you have been provided with.".

Verantwortungsvolles Verwenden von Funktionsaufrufen

Wie jedes KI-System stellt die Verwendung von Funktionsaufrufen zur Integration von Sprachmodellen mit anderen Tools und Systemen potenzielle Risiken dar. Es ist wichtig, die Risiken zu verstehen, die Funktionsaufrufe darstellen können, und Maßnahmen zu ergreifen, um sicherzugehen, dass die Funktionen verantwortungsvoll genutzt werden.

Hier sind einige Tipps, mit denen Sie Funktionen sicher und sicher verwenden können:

Überprüfen von Funktionsaufrufen: Überprüfen Sie immer die vom Modell generierten Funktionsaufrufe. Dazu gehören die Überprüfung der Parameter, die aufgerufene Funktion und die Sicherstellung, dass der Aufruf an die beabsichtigte Aktion ausgerichtet ist.
Verwenden Sie vertrauenswürdige Daten und Tools: Verwenden Sie nur Daten aus vertrauenswürdigen und überprüften Quellen. Nicht vertrauenswürdige Daten in der Ausgabe einer Funktion können verwendet werden, um das Modell anzuweisen, Funktionsaufrufe auf eine andere Weise als beabsichtigt zu schreiben.
Befolgen Sie das Prinzip der geringsten Rechte: Gewähren Sie nur den minimalen Zugriff, der für die Funktion erforderlich ist, um ihre Aufgabe auszuführen. Dies reduziert die potenziellen Auswirkungen, wenn eine Funktion missbraucht oder ausgenutzt wird. Wenn Sie beispielsweise Funktionsaufrufe zum Abfragen einer Datenbank verwenden, sollten Sie Ihrer Anwendung nur schreibgeschützten Zugriff auf die Datenbank gewähren. Sie sollten sich auch nicht ausschließlich darauf verlassen, Funktionalitäten in der Funktionsdefinition als Sicherheitskontrolle auszuschließen.
Berücksichtigen Sie die Auswirkungen in der realen Welt: Seien Sie sich der realen Auswirkungen von Funktionsaufrufen bewusst, die Sie ausführen möchten, insbesondere diejenigen, die Aktionen auslösen, wie zum Beispiel das Ausführen von Code, das Aktualisieren von Datenbanken oder das Senden von Benachrichtigungen.
Implementieren Von Benutzerbestätigungsschritten: Insbesondere für Funktionen, die Aktionen ausführen, empfehlen wir, einen Schritt einzunehmen, in dem der Benutzer die Aktion vor der Ausführung bestätigt.

Weitere Informationen zu verantwortungsvollen KI-Praktiken für Foundry Models finden Sie in der Übersicht über verantwortungsvolle KI-Praktiken.

Wichtig

In der API für Chatvervollständigungen sind die Parameter functions und function_call veraltet. Verwenden Sie den tools Parameter anstelle von functions, und verwenden Sie den tool_choice Parameter anstelle von function_call.

Unterstützung für Funktionsaufrufe

Foundry Models unterstützen Funktionsaufrufe über die Chat-Abschluss-API oder die Antwort-API. Die Unterstützung variiert je nach Modell, API, Bereitstellungstyp und Modellversion.

Um ein Modell zu finden, das Funktionsaufrufe unterstützt, lesen Sie die folgenden Kataloge:

Suchen Sie in den Modelldetails nach den folgenden Funktionen:

Api für Chatabschlusse oder Antwort-API, abhängig von der API, die Sie verwenden möchten.
Funktionen oder Tools für die Unterstützung von Funktionsaufrufen.
Parallele Toolaufrufe , wenn Ihre Anwendung das Modell benötigt, um mehrere Funktionsaufrufe in einer Antwort anzufordern.

In diesem Artikel wird gezeigt, wie Funktionsaufrufe mit der Chat-Vervollständigungs-API implementiert werden. Informationen zum Antwort-API-Anforderungs- und Antwortformat finden Sie unter Verwenden der Azure OpenAI-Antwort-API.

Hinweis

Der tool_choice Parameter wird jetzt mit o3-mini und o1unterstützt. Weitere Informationen finden Sie im Leitfaden zu Gründen von Modellen.

Wichtig

Tool- und Funktionsbeschreibungen sind derzeit auf 1.024 Zeichen beschränkt. Wir aktualisieren diesen Artikel, wenn sich dieser Grenzwert ändert.

Nächste Schritte

Verwenden Sie die Multi-Agent-Orchestrierung mit der Antwort-API.
Erfahren Sie mehr über Foundry Models.
Weitere Beispiele zum Arbeiten mit Funktionen finden Sie im OpenAI Samples GitHub Repository.

Feedback

War diese Seite hilfreich?

Last updated on 2026-08-25

Verwendung von Funktionsaufrufen mit Microsoft-Foundry-Modellen

Voraussetzungen

Beispiel für einzelne Tool-/Funktionsaufrufe

Paralleler Funktionsaufruf mit mehreren Funktionen

Prompt Engineering mit Funktionen

Verbesserung der Qualität und Zuverlässigkeit

Bereitstellen weiterer Details in der Funktionsdefinition

Bereitstellen von mehr Kontext in der Systemmeldung

Weisen Sie das Modell an, klärende Fragen zu stellen

Reduzieren von Fehlern

Verantwortungsvolles Verwenden von Funktionsaufrufen

Unterstützung für Funktionsaufrufe

Nächste Schritte

Feedback

Zusätzliche Ressourcen