Dela via

Använda Azure Functions med Azure AI Agent Service

  • Artikel

Azure AI Agent Service integreras med Azure Functions så att du kan skapa intelligenta, händelsedrivna program med minimala omkostnader. Med den här kombinationen kan AI-drivna arbetsflöden utnyttja skalbarheten och flexibiliteten i serverlös databehandling, vilket gör det enklare att skapa och distribuera lösningar som svarar på realtidshändelser eller komplexa arbetsflöden.

Azure Functions ger stöd för utlösare och bindningar, vilket förenklar hur dina AI-agenter interagerar med externa system och tjänster. Utlösare avgör när en funktion körs, till exempel en HTTP-begäran, ett meddelande från en kö eller en filuppladdning till Azure Blob Storage och tillåter agenter att agera dynamiskt baserat på inkommande händelser.

Samtidigt underlättar bindningar strömlinjeformade anslutningar till indata- eller utdatakällor, till exempel databaser eller API:er, utan att kräva omfattande pannplåtskod. Du kan till exempel konfigurera en utlösare för att köra en Azure-funktion när ett kundmeddelande tas emot i en chattrobot och använda utdatabindningar för att skicka ett svar via Azure AI-agenten.

Förutsättningar

Förbereda din lokala miljö

I följande exempel visas hur du använder funktionen Azure AI Agent Service som anropar där funktionsanrop placeras i en lagringskö av agenttjänsten som ska bearbetas av en Azure-funktion som lyssnar på kön.

Du hittar mallen och koden som används här på GitHub.

Skapa Azure-resurser för lokalt och molnbaserat utvecklingstest

När du har din Azure-prenumeration kör du följande i ett nytt terminalfönster för att skapa Azure OpenAI och andra resurser som behövs:

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

Etablera resurser

Kör följande kommando för att skapa nödvändiga resurser i Azure.

azd provision

Skapa local.settings.json

Kommentar

Den här filen ska finnas i samma mapp som host.json. Den skapas automatiskt om du körde 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"
    }
}

Kör din app med Visual Studio Code

  1. Öppna mappen i en ny terminal.
  2. code . Kör kodkommandot för att öppna projektet i Visual Studio Code.
  3. I kommandopaletten (F1) skriver du Azurite: Start, som möjliggör felsökning med lokal lagring för Azure Functions-körning.
  4. Tryck på Kör/Felsök (F5) för att köra i felsökningsprogrammet. Välj Felsök ändå om du tillfrågas om att den lokala emulatorn inte körs.
  5. Skicka POST-slutpunkter prompt med hjälp av HTTP-testverktyget. Om du har RestClient-tillägget installerat kan du köra begäranden direkt från test.http projektfilen.

Distribuera till Azure

Kör det här kommandot för att etablera funktionsappen med nödvändiga Azure-resurser och distribuera koden:

azd up

Du uppmanas att ange följande nödvändiga distributionsparametrar:

Parameter Description
Miljönamn En miljö som används för att upprätthålla en unik distributionskontext för din app. Du uppmanas inte om du har skapat det lokala projektet med hjälp av azd init.
Azure-prenumeration Prenumeration där dina resurser skapas.
Azure-plats Azure-region där du kan skapa resursgruppen som innehåller de nya Azure-resurserna. Endast regioner som för närvarande stöder Flex Consumption-planen visas.

När publiceringen har slutförts azd får du URL-slutpunkterna för dina nya funktioner, men utan de funktionsnyckelvärden som krävs för att få åtkomst till slutpunkterna. Information om hur du hämtar samma slutpunkter tillsammans med de nödvändiga funktionsnycklarna finns i Anropa funktionen på Azure i den tillhörande artikeln Snabbstart: Skapa och distribuera funktioner till Azure Functions med hjälp av Azure Developer CLI.

Distribuera om koden

Du kan köra azd up kommandot så många gånger du behöver både etablera dina Azure-resurser och distribuera koduppdateringar till funktionsappen.

Kommentar

Distribuerade kodfiler skrivs alltid över av det senaste distributionspaketet.

Rensa resurser

När du är klar med funktionsappen och relaterade resurser kan du använda det här kommandot för att ta bort funktionsappen och dess relaterade resurser från Azure och undvika att medföra ytterligare kostnader (--rensa lämnar inte en mjuk borttagning av AI-resursen och återställer din kvot):

azd down --purge

Azure AI-agenter stöder funktionsanrop, vilket gör att du kan beskriva strukturen för funktioner till en assistent och sedan returnera de funktioner som måste anropas tillsammans med deras argument. Det här exemplet visar hur du använder Azure Functions för att bearbeta funktionsanrop via kömeddelanden i Azure Storage. Du kan se ett fullständigt arbetsexempel på https://github.com/Azure-Samples/azure-functions-ai-services-agent-python

Modeller som stöds

Om du vill använda alla funktioner för funktionsanrop, inklusive parallella funktioner, måste du använda en modell som släpptes efter den 6 november 2023.

Definiera en funktion som agenten ska anropa

Börja med att definiera en azure-funktionsköutlösare som bearbetar funktionsanrop från kön.

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

Skapa en AI-projektklient och agent

I exemplet nedan skapar vi en klient och en agent som har verktygsdefinitionen för Azure-funktionen

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

Skapa en tråd för agenten

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

Skapa en körning och kontrollera utdata

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

Hämta resultatet av körningen

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