Verwenden von Azure-Funktionen mit dem Dienst Azure KI Agent

Artikel
01/30/2025

Der Dienst Azure KI-Agenten ist in Azure Functions integriert und ermöglicht Ihnen die Erstellung intelligenter, ereignisgesteuerter Anwendungen mit minimalem Overhead. Dank dieser Kombination können KI-gesteuerte Workflows die Skalierbarkeit und Flexibilität von serverlosem Computing nutzen. Dies erleichtert die Entwicklung und Bereitstellung von Lösungen, die auf Echtzeitereignisse oder komplexe Workflows reagieren.

Azure Functions bietet Unterstützung für Trigger und Bindungen, die die Interaktion Ihrer KI-Agenten mit externen Systemen und Diensten vereinfachen. Trigger legen fest, wann eine Funktion ausgeführt wird – z. B. eine HTTP-Anfrage, eine Nachricht aus einer Warteschlange oder ein Datei-Upload in Azure Blob Storage – und ermöglichen es Agenten, dynamisch auf der Grundlage eingehender Ereignisse zu handeln.

Gleichzeitig ermöglichen Bindungen optimierte Verbindungen zu Eingabe- oder Ausgabedatenquellen, wie Datenbanken oder APIs, ohne dass umfangreicher Boilerplate-Code erforderlich ist. So können Sie beispielsweise einen Trigger konfigurieren, um eine Azure-Funktion auszuführen, sobald eine Kundennachricht in einem Chatbot eingeht, und Output-Bindungen verwenden, um eine Antwort über den Azure KI Agent zu senden.

Voraussetzungen

Vorbereiten der lokalen Umgebung

Die folgenden Beispiele zeigen, wie der Dienst Azure KI-Agent Funktionsaufrufe verwendet, bei denen Funktionsaufrufe vom Agent-Dienst in eine Speicherwarteschlange gestellt werden, um von einer Azure-Funktion verarbeitet zu werden, die an diese Warteschlange lauscht.

Sie finden die hier verwendete Vorlage und den Code auf GitHub.

Erstellen von Azure-Ressourcen für lokale und Cloud-Entwicklungstests

Sobald Sie Ihr Azure-Abonnement haben, führen Sie den folgenden Befehl in einem neuen Terminalfenster aus, um Azure OpenAI und andere benötigte Ressourcen zu erstellen:

azd init --template https://github.com/Azure-Samples/azure-functions-ai-services-agent-python

Mac/Linux:

chmod +x ./infra/scripts/*.sh

Windows:

set-executionpolicy remotesigned

Bereitstellen von Ressourcen

Führen Sie den folgenden Befehl aus, um die erforderlichen Ressourcen in Azure zu erstellen.

azd provision

Erstellen der Datei „local.settings.json“

Hinweis

Diese Datei sollte sich im selben Ordner befinden wie host.json. Sie wurde automatisch erstellt, wenn Sie azd provision ausgeführt haben.

{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "python",
    "STORAGE_CONNECTION__queueServiceUri": "https://<storageaccount>.queue.core.windows.net",
    "PROJECT_CONNECTION_STRING": "<project connnection for AI Project>",
    "AzureWebJobsStorage": "UseDevelopmentStorage=true"
    }
}

Ausführen Ihrer Anwendung mit Visual Studio Code

Öffnen Sie den Ordner in einem neuen Terminal.
Führen Sie den Codebefehl code . aus, um das Projekt in Visual Studio Code zu öffnen.
Geben Sie in der Befehlspalette (F1) den Befehl Azurite: Start ein, der das Debugging mit lokalem Speicher für Azure Functions Runtime aktiviert.
Drücken Sie Ausführen/Debuggen (F5), um die Ausführung im Debugger zu starten. Wählen Sie Trotzdem debuggen aus, wenn Sie darüber informiert werden, dass der lokale Emulator nicht ausgeführt wird.
Senden Sie POST prompt Endpunkte bzw. verwenden Sie Ihr HTTP-Testtool. Wenn die RestClientErweiterung installiert haben, können Sie Anfragen direkt aus der Projektdatei test.http ausführen.

Bereitstellung in Azure

Führen Sie diesen Befehl aus, um die Funktions-App mit allen erforderlichen Azure-Ressourcen und Ihren Code bereitzustellen:

azd up

Sie werden aufgefordert, die erforderlichen Bereitstellungsparameter einzugeben:

Parameter	BESCHREIBUNG
Umgebungsname	Eine Umgebung, die dazu dient, einen eindeutigen Bereitstellungskontext für Ihre Anwendung zu erhalten. Sie werden nicht dazu aufgefordert, wenn Sie das lokale Projekt mit `azd init` erstellt haben.
Azure-Abonnement	Das Abonnement, in dem Ihre Ressourcen erstellt werden.
Azure-Standort	Die Azure-Region, in der die Ressourcengruppe erstellt werden soll, die die neuen Azure-Ressourcen enthält. Es werden nur Regionen angezeigt, die den Flex-Verbrauchsplan derzeit unterstützen.

Nachdem die Veröffentlichung erfolgreich abgeschlossen wurde, stellt azd Ihnen die URL-Endpunkte Ihrer neuen Funktionen zur Verfügung, allerdings ohne die Funktionsschlüsselwerte, die für den Zugriff auf die Endpunkte erforderlich sind. Wie Sie dieselben Endpunkte zusammen mit den erforderlichen Funktionsschlüsseln erhalten, erfahren Sie unter Aufrufen der Funktion in Azure im Begleitartikel Schnellstart: Erstellen und Bereitstellen von Funktionen in Azure Functions mit der Azure Developer CLI.

Erneutes Bereitstellen Ihres Codes

Sie können den azd up-Befehl beliebig oft ausführen, um sowohl Ihre Azure-Ressourcen als auch Codeupdates für Ihre Funktions-App bereitzustellen.

Hinweis

Bereitgestellte Codedateien werden immer vom neuesten Bereitstellungspaket überschrieben.

Bereinigen von Ressourcen

Wenn Sie mit der Arbeit mit Ihrer Funktions-App und verwandten Ressourcen fertig sind, können Sie diesen Befehl verwenden, um die Funktions-App und die zugehörigen Ressourcen aus Azure zu löschen und weitere Kosten zu vermeiden (--purge hinterlässt kein vorläufiges Löschen der KI-Ressource und stellt Ihr Kontingent wieder her):

azd down --purge

Azure KI-Agents unterstützen Funktionsaufrufe, mit denen Sie einem Assistenten die Struktur von Funktionen beschreiben und dann die Funktionen zurückgeben können, die zusammen mit ihren Argumenten aufgerufen werden müssen. Dieses Beispiel zeigt, wie Sie Azure Functions verwenden, um die Funktionsaufrufe über Warteschlangen-Nachrichten in Azure Storage zu verarbeiten. Ein vollständiges funktionierendes Beispiel finden Sie unter https://github.com/Azure-Samples/azure-functions-ai-services-agent-python

Unterstützte Modelle

Um alle Funktionen von Funktionsaufrufen einschließlich paralleler Funktionen zu verwenden, müssen Sie ein Modell verwenden, das nach dem 6. November 2023 veröffentlicht wurde.

Definieren einer Funktion für ihren Agent, die aufgerufen werden soll

Definieren Sie zunächst eine Triggerfunktion für die Azure Function-Warteschlange, die Funktionsaufrufe aus der Warteschlange verarbeitet.

# Function to get the weather from an Azure Storage queue where the AI Agent will send function call information
# It returns the mock weather to an output queue with the correlation id for the AI Agent Service to pick up the result of the function call
@app.function_name(name="GetWeather")
@app.queue_trigger(arg_name="msg", queue_name="input", connection="STORAGE_CONNECTION")  
def process_queue_message(msg: func.QueueMessage) -> None:
    logging.info('Python queue trigger function processed a queue item')

    # Queue to send message to
    queue_client = QueueClient(
        os.environ["STORAGE_CONNECTION__queueServiceUri"],
        queue_name="output",
        credential=DefaultAzureCredential(),
        message_encode_policy=BinaryBase64EncodePolicy(),
        message_decode_policy=BinaryBase64DecodePolicy()
    )

    # Get the content of the function call message
    messagepayload = json.loads(msg.get_body().decode('utf-8'))
    location = messagepayload['location']
    correlation_id = messagepayload['CorrelationId']

    # Send message to queue. Sends a mock message for the weather
    result_message = {
        'Value': 'Weather is 74 degrees and sunny in ' + location,
        'CorrelationId': correlation_id
    }
    queue_client.send_message(json.dumps(result_message).encode('utf-8'))

    logging.info(f"Sent message to output queue with message {result_message}")

Erstellen eines KI-Projektclients und -Agents

Im folgenden Beispiel erstellen wir einen Client und einen Agenten, der über die Definition der Tools für die Azure Function verfügt

# Initialize the client and create agent for the tools Azure Functions that the agent can use

# Create a project client
project_client = AIProjectClient.from_connection_string(
    credential=DefaultAzureCredential(),
    conn_str=os.environ["PROJECT_CONNECTION_STRING"]
)

# Get the connection string for the storage account to send and receive the function calls to the queues
storage_connection_string = os.environ["STORAGE_CONNECTION__queueServiceUri"]

# Create an agent with the Azure Function tool to get the weather
agent = project_client.agents.create_agent(
    model="gpt-4o-mini",
    name="azure-function-agent-get-weather",
    instructions="You are a helpful support agent. Answer the user's questions to the best of your ability.",
    headers={"x-ms-enable-preview": "true"},
    tools=[
        {
            "type": "azure_function",
            "azure_function": {
                "function": {
                    "name": "GetWeather",
                    "description": "Get the weather in a location.",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "location": {"type": "string", "description": "The location to look up."}
                        },
                        "required": ["location"]
                    }
                },
                "input_binding": {
                    "type": "storage_queue",
                    "storage_queue": {
                        "queue_service_uri": storage_connection_string,
                        "queue_name": "input"
                    }
                },
                "output_binding": {
                    "type": "storage_queue",
                    "storage_queue": {
                        "queue_service_uri": storage_connection_string,
                        "queue_name": "output"
                    }
                }
            }
        }
    ],
)

Erstellen eines Threads für den Agent

# Create a thread
thread = project_client.agents.create_thread()
print(f"Created thread, thread ID: {thread.id}")

Erstellen einer Ausführung und Überprüfen der Ausgabe

# Send the prompt to the agent
message = project_client.agents.create_message(
    thread_id=thread.id,
    role="user",
    content="What is the weather in Seattle, WA?",
)
print(f"Created message, message ID: {message.id}")

# Run the agent
run = project_client.agents.create_run(thread_id=thread.id, assistant_id=agent.id)
# Monitor and process the run status. The function call should be placed on the input queue by the Agent Service for the Azure Function to pick up when requires_action is returned
while run.status in ["queued", "in_progress", "requires_action"]:
    time.sleep(1)
    run = project_client.agents.get_run(thread_id=thread.id, run_id=run.id)

    if run.status not in ["queued", "in_progress", "requires_action"]:
        break

print(f"Run finished with status: {run.status}")

Abrufen des Ergebnisses des Vorgangs

# Get messages from the assistant thread
messages = project_client.agents.get_messages(thread_id=thread.id)
print(f"Messages: {messages}")

# Get the last message from the assistant
last_msg = messages.get_last_text_message_by_sender("assistant")
if last_msg:
    print(f"Last Message: {last_msg.text.value}")

# Delete the agent once done
project_client.agents.delete_agent(agent.id)
print("Deleted agent")

Freigeben über