Läs på engelska

Dela via

Självstudie: Använda kodtolkarsessioner i LlamaIndex med Azure Container Apps

  • Artikel

LlamaIndex är ett kraftfullt ramverk för att skapa LLM-program (context-augmented language model). När du skapar en AI-agent med LlamaIndex tolkar en LLM användarindata och genererar ett svar. AI-agenten kämpar ofta när den behöver utföra matematiska och symboliska resonemang för att skapa ett svar. Genom att integrera dynamiska Sessioner i Azure Container Apps med LlamaIndex ger du agenten en kodtolka som ska användas för att utföra specialiserade uppgifter.

I den här självstudien får du lära dig hur du kör en LlamaIndex AI-agent i ett webb-API. API:et accepterar användarindata och returnerar ett svar som genereras av AI-agenten. Agenten använder en kodtolkning i dynamiska sessioner för att utföra beräkningar.

Förutsättningar

  • Ett Azure-konto med en aktiv prenumeration.
  • Installera Azure CLI.
  • Git.
  • Python 3.10 eller senare.

Skapa Azure-resurser

Exempelappen i den här snabbstarten använder en LLM från Azure OpenAI. Den använder också Azure Container Apps-sessioner för att köra kod som genereras av LLM.

  1. Uppdatera Azure CLI till den senaste versionen.

    Bash 
     az upgrade

  2. Ta bort Azure Container Apps-tillägget om det redan är installerat och installera en förhandsversion av Azure Container Apps-tillägget som innehåller kommandon för sessioner:

    Bash 
    az extension remove --name containerapp
az extension add \
    --name containerapp \
    --allow-preview true -y

  3. Logga in på Azure:

    Bash 
    az login

  4. Ange de variabler som används i den här snabbstarten:

    Bash 
    RESOURCE_GROUP_NAME=aca-sessions-tutorial
AZURE_OPENAI_LOCATION=swedencentral
AZURE_OPENAI_NAME=<UNIQUE_OPEN_AI_NAME>
SESSION_POOL_LOCATION=eastasia
SESSION_POOL_NAME=code-interpreter-pool

    Ersätt <UNIQUE_OPEN_AI_NAME> med ett unikt namn för att skapa ditt Azure OpenAI-konto.

  5. Skapa en resursgrupp:

    Bash 
    az group create --name $RESOURCE_GROUP_NAME --location $SESSION_POOL_LOCATION

  6. Skapa ett Azure OpenAI-konto:

    Bash 
    az cognitiveservices account create \
    --name $AZURE_OPENAI_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --location $AZURE_OPENAI_LOCATION \
    --kind OpenAI \
    --sku s0 \
    --custom-domain $AZURE_OPENAI_NAME

  7. Skapa en GPT 3.5 Turbo-modelldistribution med namnet gpt-35-turbo i Azure OpenAI-kontot:

    Bash 
    az cognitiveservices account deployment create \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $AZURE_OPENAI_NAME \
    --deployment-name gpt-35-turbo \
    --model-name gpt-35-turbo \
    --model-version "1106" \
    --model-format OpenAI \
    --sku-capacity "100" \
    --sku-name "Standard"

  8. Skapa en kodtolkarsessionspool:

    Bash 
    az containerapp sessionpool create \
    --name $SESSION_POOL_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --location $SESSION_POOL_LOCATION \
    --max-sessions 100 \
    --container-type PythonLTS \
    --cooldown-period 300

Kör exempelappen lokalt

Innan du distribuerar appen till Azure Container Apps kan du köra den lokalt för att testa den.

Klona appen

  1. Klona lagringsplatsen för Azure Container Apps-sessioner.

    Bash 
    git clone https://github.com/Azure-Samples/container-apps-dynamic-sessions-samples.git

  2. Ändra till katalogen som innehåller exempelappen:

    Bash 
    cd container-apps-dynamic-sessions-samples/llamaindex-python-webapi

Konfigurera appen

  1. Skapa en virtuell Python-miljö och aktivera den:

    Bash 
    python3.11 -m venv .venv
source .venv/bin/activate

    Ändra Python-versionen i kommandot om du använder en annan version. Vi rekommenderar att du använder Python 3.10 eller senare.

    Anteckning

    Om du använder Windows ersätter .venv/bin/activate du med .venv\Scripts\activate.

  2. Installera nödvändiga Python-paket:

    Bash 
    python -m pip install -r requirements.txt

  3. Om du vill köra appen måste du konfigurera miljövariabler.

    1. Hämta Azure OpenAI-kontoslutpunkten:

      Bash 
      az cognitiveservices account show \
    --name $AZURE_OPENAI_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --query properties.endpoint \
    --output tsv

    2. Hämta azure Container Apps-sessionspoolens hanteringsslutpunkt:

      Bash 
      az containerapp sessionpool show \
    --name $SESSION_POOL_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --query properties.poolManagementEndpoint \
    --output tsv

    3. Skapa en .env fil i roten i exempelappkatalogen (samma plats som main.py). Lägg till följande innehåll i filen:

      text 
      AZURE_OPENAI_ENDPOINT=<AZURE_OPENAI_ENDPOINT>
POOL_MANAGEMENT_ENDPOINT=<SESSION_POOL_MANAGEMENT_ENDPOINT>

      Ersätt <AZURE_OPENAI_ENDPOINT> med Azure OpenAI-kontoslutpunkten och <SESSION_POOL_MANAGEMENT_ENDPOINT> med slutpunkten för hantering av sessionspooler.

  4. Appen använder DefaultAzureCredential för att autentisera med Azure-tjänster. På den lokala datorn använder den dina aktuella Inloggningsuppgifter för Azure CLI. Du måste ge dig själv rollen Cognitive Services OpenAI-användare på Azure OpenAI-kontot för att appen ska få åtkomst till modellslutpunkterna och rollen Azure ContainerApps Session Executor i sessionspoolen för att appen ska få åtkomst till sessionspoolen.

    1. Hämta ditt Azure CLI-användarnamn:

      Bash 
      az account show --query user.name --output tsv

    2. Kör följande kommandon för att hämta resurs-ID:t för Azure OpenAI-kontot:

      Bash 
      az cognitiveservices account show --name $AZURE_OPENAI_NAME --resource-group $RESOURCE_GROUP_NAME --query id --output tsv

    3. Tilldela Cognitive Services OpenAI-användarrollen till din Azure CLI-användare på Azure OpenAI-kontot:

      Bash 
      az role assignment create --role "Cognitive Services OpenAI User" --assignee <CLI_USERNAME> --scope <AZURE_OPENAI_RESOURCE_ID>

      Ersätt <CLI_USERNAME> med ditt Azure CLI-användarnamn och <AZURE_OPENAI_RESOURCE_ID> med resurs-ID:t för Azure OpenAI-kontot.

    4. Kör följande kommandon för att hämta sessionspoolens resurs-ID:

      Bash 
      az containerapp sessionpool show --name $SESSION_POOL_NAME --resource-group $RESOURCE_GROUP_NAME --query id --output tsv

    5. Tilldela azure ContainerApps-sessionskörningsrollen med hjälp av dess ID till din Azure CLI-användare i sessionspoolen:

      Bash 
      az role assignment create \
    --role "Azure ContainerApps Session Executor" \
    --assignee <CLI_USERNAME> \
    --scope <SESSION_POOL_RESOURCE_ID>

      Ersätt <CLI_USERNAME> med ditt Azure CLI-användarnamn och <SESSION_POOL_RESOURCE_ID> med resurs-ID:t för sessionspoolen.

Kör appen

Innan du kör exempelappen öppnar du main.py i ett redigeringsprogram och granskar koden. Appen använder FastAPI för att skapa ett webb-API som accepterar ett användarmeddelande i frågesträngen.

Följande kodrader instansierar en AzureCodeInterpreterToolSpec och tillhandahåller den till LlamaIndex-agenten:

Python 
code_interpreter_tool = AzureCodeInterpreterToolSpec(
    pool_management_endpoint=pool_management_endpoint,
)
agent = ReActAgent.from_tools(code_interpreter_tool.to_tool_list(), llm=llm, verbose=True)

När den behöver utföra beräkningar använder agenten kodtolkaren i AzureCodeInterpreterToolSpec för att köra koden. Koden körs i en session i sessionspoolen. Som standard genereras en slumpmässig sessionsidentifierare när du instansierar verktyget. Om agenten använder samma verktyg för att köra flera Python-kodfragment använder den samma session. För att säkerställa att varje slutanvändare har en unik session använder du en separat agent och ett verktyg för varje användare.

AzureCodeInterpreterToolSpec finns i llama-index-tools-azure-code-interpreter paketet.

  1. Kör exempelappen:

    Bash 
    fastapi dev main.py

  2. Öppna en webbläsare och navigera till http://localhost:8000/docs. Du ser Swagger-användargränssnittet för exempelappen.

  3. /chat Expandera slutpunkten och välj Prova.

  4. Ange What time is it right now? i fältet message och välj Kör.

    Agenten svarar med den aktuella tiden. I terminalen visas loggarna som visar agenten genererade Python-kod för att hämta den aktuella tiden och körde den i en kodtolkarsession.

  5. Om du vill stoppa appen anger du Ctrl+C i terminalen.

Valfritt: Distribuera exempelappen till Azure Container Apps

Om du vill distribuera FastAPI-appen till Azure Container Apps måste du skapa en containeravbildning och skicka den till ett containerregister. Sedan kan du distribuera avbildningen till Azure Container Apps. Kommandot az containerapp up kombinerar de här stegen i ett enda kommando.

Sedan måste du konfigurera en hanterad identitet för appen och tilldela den rätt roller för åtkomst till Azure OpenAI och sessionspoolen.

  1. Ange variablerna för Container Apps-miljön och appnamnet:

    Bash 
    ENVIRONMENT_NAME=aca-sessions-tutorial-env
CONTAINER_APP_NAME=chat-api

  2. Skapa och distribuera appen till Azure Container Apps:

    Bash 
    az containerapp up \
    --name $CONTAINER_APP_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --location $SESSION_POOL_LOCATION \
    --environment $ENVIRONMENT_NAME \
    --env-vars "AZURE_OPENAI_ENDPOINT=<OPEN_AI_ENDPOINT>" "POOL_MANAGEMENT_ENDPOINT=<SESSION_POOL_MANAGEMENT_ENDPOINT>" \
    --source .

    Ersätt <OPEN_AI_ENDPOINT> med Azure OpenAI-kontoslutpunkten och <SESSION_POOL_MANAGEMENT_ENDPOINT> med slutpunkten för hantering av sessionspooler.

  3. Aktivera den systemtilldelade hanterade identiteten för appen:

    Bash 
    az containerapp identity assign \
    --name $CONTAINER_APP_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --system-assigned

  4. För att appen ska få åtkomst till Azure OpenAI och sessionspoolen måste du tilldela den hanterade identiteten rätt roller.

    1. Hämta den hanterade identitetens huvud-ID:

      Bash 
      az containerapp show \
    --name $CONTAINER_APP_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --query identity.principalId \
    --output tsv

    2. Hämta sessionspoolens resurs-ID:

      Bash 
      az containerapp sessionpool show \
    --name $SESSION_POOL_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --query id \
    --output tsv

    3. Tilldela den hanterade identiteten Azure ContainerApps Session Executor och Contributor rollerna i sessionspoolen:

      Innan du kör följande kommando ersätter <PRINCIPAL_ID> du och <SESSION_POOL_RESOURCE_ID> med de värden som du hämtade i föregående steg.

      Bash 
      az role assignment create \
    --role "Azure ContainerApps Session Executor" \
    --assignee <PRINCIPAL_ID> \
    --scope <SESSION_POOL_RESOURCE_ID>

az role assignment create \
    --role "Contributor" \
    --assignee <PRINCIPAL_ID> \
    --scope <SESSION_POOL_RESOURCE_ID>

    4. Hämta resurs-ID:t för Azure OpenAI-kontot:

      Bash 
      az cognitiveservices account show \
    --name $AZURE_OPENAI_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --query id \
    --output tsv

    5. Tilldela den hanterade identiteten Cognitive Services OpenAI User rollen för Azure OpenAI-kontot:

      Innan du kör följande kommando ersätter <PRINCIPAL_ID> du och <AZURE_OPENAI_RESOURCE_ID> med de värden som du hämtade i föregående steg.

      Bash 
      az role assignment create \
    --role "Cognitive Services OpenAI User" \
    --assignee <PRINCIPAL_ID> \
    --scope <AZURE_OPENAI_RESOURCE_ID>

  5. Hämta appens fullständigt kvalificerade domännamn (FQDN):

    Bash 
    az containerapp show \
    --name $CONTAINER_APP_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --query properties.configuration.ingress.fqdn \
    --output tsv

  6. Öppna webbläsaren för att https://<FQDN>/docs testa den distribuerade appen.

Rensa resurser

När du är klar med resurserna kan du ta bort dem för att undvika avgifter:

Bash 
az group delete --name $RESOURCE_GROUP_NAME --yes --no-wait

Nästa steg

Kodtolkarsessioner