Azure Functions gebruiken met Azure AI Agent Service

De Azure AI Agent Service kan worden geïntegreerd met Azure Functions, zodat u intelligente, gebeurtenisgestuurde toepassingen kunt maken met minimale overhead. Met deze combinatie kunnen AI-gestuurde werkstromen gebruikmaken van de schaalbaarheid en flexibiliteit van serverloze computing, zodat u eenvoudiger oplossingen kunt bouwen en implementeren die reageren op realtime gebeurtenissen of complexe werkstromen.

Azure Functions biedt ondersteuning voor triggers en bindingen, wat de interactie tussen uw AI-agents en externe systemen en services vereenvoudigt. Triggers bepalen wanneer een functie wordt uitgevoerd, zoals een HTTP-aanvraag, een bericht uit een wachtrij of een bestandsupload naar Azure Blob Storage, zodat agents dynamisch kunnen handelen op basis van binnenkomende gebeurtenissen.

Ondertussen vergemakkelijken bindingen gestroomlijnde verbindingen met invoer- of uitvoergegevensbronnen, zoals databases of API's, zonder uitgebreide standaardcode te vereisen. U kunt bijvoorbeeld een trigger configureren om een Azure-functie uit te voeren wanneer een klantbericht in een chatbot wordt ontvangen en uitvoerbindingen gebruiken om een antwoord te verzenden via de Azure AI-agent.

Vereisten

• Azure Functions Core Tools v4.x
• Azure AI Agent Service
• Azuriet

Uw lokale omgeving voorbereiden

In de volgende voorbeelden ziet u hoe u de Azure AI Agent Service-functie gebruikt die aanroept waar functieaanroepen worden geplaatst in een opslagwachtrij door de agentservice die door een Azure-functie wordt verwerkt die naar die wachtrij luistert.

U vindt de sjabloon en code die hier worden gebruikt op GitHub.

Azure-resources maken voor lokale en cloud dev-test

Nadat u uw Azure-abonnement hebt, voert u het volgende uit in een nieuw terminalvenster om Azure OpenAI en andere resources te maken die nodig zijn:

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

Resources inrichten

Voer de volgende opdracht uit om de vereiste resources in Azure te maken.

azd provision

Local.settings.json maken

Notitie

Dit bestand moet zich in dezelfde map bevinden als host.json. Deze wordt automatisch gemaakt als u het hebt uitgevoerd azd provision.

{
  "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"
    }
}

Uw app uitvoeren met Visual Studio Code

1. Open de map in een nieuwe terminal.
2. Voer de code . codeopdracht uit om het project te openen in Visual Studio Code.
3. Typ in het opdrachtpalet (F1), Azurite: Startwaarmee foutopsporing met lokale opslag voor Azure Functions-runtime mogelijk is.
4. Druk op Run/Debug (F5) om uit te voeren in het foutopsporingsprogramma. Selecteer Toch foutopsporing als u wordt gevraagd of de lokale emulator niet wordt uitgevoerd.
5. Verzend respectievelijk POST-eindpunten prompt met behulp van uw HTTP-testhulpprogramma. Als u de RestClient-extensie hebt geïnstalleerd, kunt u aanvragen rechtstreeks vanuit het test.http projectbestand uitvoeren.

Implementeren op Azure

Voer deze opdracht uit om de functie-app in te richten met eventuele vereiste Azure-resources en implementeer uw code:

azd up

U wordt gevraagd om deze vereiste implementatieparameters op te geven:

Parameter	Description
Omgevingsnaam	Een omgeving die wordt gebruikt voor het onderhouden van een unieke implementatiecontext voor uw app. U wordt niet gevraagd of u het lokale project hebt gemaakt met behulp van azd init.
Azure-abonnement	Abonnement waarin uw resources worden gemaakt.
Azure-locatie	Azure-regio waarin de resourcegroep wordt gemaakt die de nieuwe Azure-resources bevat. Alleen regio's die momenteel ondersteuning bieden voor het Flex Consumption-abonnement, worden weergegeven.

Nadat de publicatie is voltooid, azd krijgt u de URL-eindpunten van uw nieuwe functies, maar zonder de waarden van de functiesleutel die nodig zijn voor toegang tot de eindpunten. Als u wilt weten hoe u dezelfde eindpunten samen met de vereiste functiesleutels kunt verkrijgen, raadpleegt u De functie in Azure aanroepen in de bijbehorende quickstart : Functies maken en implementeren in Azure Functions met behulp van de Azure Developer CLI.

Uw code opnieuw implementeren

U kunt de azd up opdracht zo vaak uitvoeren als nodig is om uw Azure-resources in te richten en code-updates te implementeren in uw functie-app.

Notitie

Geïmplementeerde codebestanden worden altijd overschreven door het nieuwste implementatiepakket.

Resources opschonen

Wanneer u klaar bent met het werken met uw functie-app en gerelateerde resources, kunt u deze opdracht gebruiken om de functie-app en de bijbehorende resources uit Azure te verwijderen en te voorkomen dat er verdere kosten in rekening worden gebracht (--opschonen laat geen voorlopig verwijderen van AI-resources achter en herstelt uw quotum):

azd down --purge

Azure AI Agents ondersteunt functieaanroepen, waarmee u de structuur van functies kunt beschrijven aan een assistent en vervolgens de functies kunt retourneren die samen met hun argumenten moeten worden aangeroepen. In dit voorbeeld ziet u hoe u Azure Functions gebruikt om de functieaanroepen te verwerken via wachtrijberichten in Azure Storage. U kunt een volledig werkvoorbeeld bekijken voor https://github.com/Azure-Samples/azure-functions-ai-services-agent-python

Ondersteunde modellen

Als u alle functies van functieaanroepen wilt gebruiken, inclusief parallelle functies, moet u een model gebruiken dat is uitgebracht na 6 november 2023.

Een functie definiëren die door uw agent moet worden aangeroepen

Begin met het definiëren van een azure-functiewachtrijtriggerfunctie waarmee functieaanroepen uit de wachtrij worden verwerkt.

# 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}")

Een AI-projectclient en -agent maken

In het onderstaande voorbeeld maken we een client en een agent met de definitie van de hulpprogramma's voor de Azure-functie

# 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"
                    }
                }
            }
        }
    ],
)

Een thread voor de agent maken

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

Een uitvoering maken en de uitvoer controleren

# 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}")

Het resultaat van de uitvoering ophalen

# 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")