Samouczek: używanie sesji interpretera kodu w usłudze LangChain z usługą Azure Container Apps

LangChain to struktura przeznaczona do upraszczania tworzenia aplikacji przy użyciu dużych modeli językowych (LLMs). Podczas tworzenia agenta sztucznej inteligencji za pomocą usługi LangChain usługa LLM interpretuje dane wejściowe użytkownika i generuje odpowiedź. Agent sztucznej inteligencji często zmaga się, gdy musi wykonać matematyczne i symboliczne rozumowanie w celu utworzenia odpowiedzi. Integrując dynamiczne sesje usługi Azure Container Apps z aplikacją LangChain, możesz udostępnić agentowi interpreter kodu do wykonywania wyspecjalizowanych zadań.

Z tego samouczka dowiesz się, jak uruchomić agenta sztucznej inteligencji LangChain w internetowym interfejsie API. Interfejs API akceptuje dane wejściowe użytkownika i zwraca odpowiedź wygenerowaną przez agenta sztucznej inteligencji. Agent używa interpretera kodu w sesjach dynamicznych do wykonywania obliczeń.

Uwaga

Sesje dynamiczne usługi Azure Container Apps są obecnie dostępne w wersji zapoznawczej. Aby uzyskać więcej informacji, zobacz ograniczenia wersji zapoznawczej.

Wymagania wstępne

• Konto platformy Azure z aktywną subskrypcją.
  • Jeśli nie masz konta, możesz je utworzyć teraz za darmo.
• Zainstaluj interfejs wiersza polecenia platformy Azure.
• Git.
• Środowisko Python w wersji 3.10 lub nowszej.

Tworzenie zasobów platformy Azure

Przykładowa aplikacja w tym przewodniku Szybki start używa rozwiązania LLM z poziomu usługi Azure OpenAI. Używa również sesji usługi Azure Container Apps do uruchamiania kodu wygenerowanego przez usługę LLM.

1. Zaktualizuj interfejs wiersza polecenia platformy Azure do najnowszej wersji.

    az upgrade
   

2. Usuń rozszerzenie usługi Azure Container Apps, jeśli jest już zainstalowane i zainstaluj wersję zapoznawcza rozszerzenia Azure Container Apps zawierające polecenia dla sesji:

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

3. Zaloguj się do platformy Azure:

   az login
   

4. Ustaw zmienne używane w tym przewodniku Szybki start:

   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
   

   Zastąp <UNIQUE_OPEN_AI_NAME> ciąg unikatową nazwą, aby utworzyć konto usługi Azure OpenAI.

5. Tworzenie grupy zasobów:

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

6. Tworzenie konta usługi Azure OpenAI:

   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. Utwórz wdrożenie modelu GPT 3.5 Turbo o nazwie gpt-35-turbo na koncie usługi Azure OpenAI:

   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. Utwórz pulę sesji interpretera kodu:

   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
   

Uruchamianie przykładowej aplikacji lokalnie

Przed wdrożeniem aplikacji w usłudze Azure Container Apps możesz uruchomić ją lokalnie, aby ją przetestować.

Klonowanie aplikacji

1. Sklonuj repozytorium przykładów sesji usługi Azure Container Apps.

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

2. Przejdź do katalogu zawierającego przykładową aplikację:

   cd container-apps-dynamic-sessions-samples/langchain-python-webapi
   

Konfigurowanie aplikacji

1. Utwórz środowisko wirtualne języka Python i aktywuj je:

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

   Zmień wersję języka Python w poleceniu, jeśli używasz innej wersji. Zaleca się używanie języka Python w wersji 3.10 lub nowszej.

   Uwaga

   Jeśli używasz systemu Windows, zastąp ciąg .venv/bin/activate ciąg ..venv\Scripts\activate

2. Zainstaluj wymagane pakiety języka Python:

   python -m pip install -r requirements.txt
   

3. Aby uruchomić aplikację, należy skonfigurować zmienne środowiskowe.

   1. Pobierz punkt końcowy konta usługi Azure OpenAI:

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

   2. Pobierz punkt końcowy zarządzania pulą sesji usługi Azure Container Apps:

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

   3. .env Utwórz plik w katalogu głównym przykładowej aplikacji (w tej samej lokalizacji co main.py). Dodaj następującą zawartość do pliku:

      AZURE_OPENAI_ENDPOINT=<AZURE_OPENAI_ENDPOINT>
      POOL_MANAGEMENT_ENDPOINT=<SESSION_POOL_MANAGEMENT_ENDPOINT>
      

      Zastąp <AZURE_OPENAI_ENDPOINT> element punktem końcowym konta usługi Azure OpenAI i <SESSION_POOL_MANAGEMENT_ENDPOINT> punktem końcowym zarządzania pulą sesji.

4. Aplikacja używa DefaultAzureCredential funkcji do uwierzytelniania za pomocą usług platformy Azure. Na komputerze lokalnym używa on bieżących poświadczeń logowania interfejsu wiersza polecenia platformy Azure. Musisz przyznać sobie rolę użytkownika openAI usług Cognitive Services na koncie usługi Azure OpenAI, aby aplikacja uzyskiwała dostęp do punktów końcowych modelu, oraz rolę funkcji wykonawczej sesji usługi Azure ContainerApps w puli sesji, aby aplikacja uzyskiwała dostęp do puli sesji.

   1. Pobierz nazwę użytkownika interfejsu wiersza polecenia platformy Azure:

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

   2. Uruchom następujące polecenia, aby pobrać identyfikator zasobu konta usługi Azure OpenAI:

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

   3. Przypisz rolę użytkownika interfejsu wiersza polecenia platformy Azure w usłudze Cognitive Services OpenAI na koncie usługi Azure OpenAI:

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

      Zastąp <CLI_USERNAME> ciąg nazwą użytkownika interfejsu wiersza polecenia platformy Azure i <AZURE_OPENAI_RESOURCE_ID> identyfikatorem zasobu konta usługi Azure OpenAI.

   4. Uruchom następujące polecenia, aby pobrać identyfikator zasobu puli sesji:

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

   5. Przypisz rolę funkcji wykonawczej sesji usługi Azure ContainerApps przy użyciu jego identyfikatora do użytkownika interfejsu wiersza polecenia platformy Azure w puli sesji:

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

      Zastąp <CLI_USERNAME> ciąg nazwą użytkownika interfejsu wiersza polecenia platformy Azure i <SESSION_POOL_RESOURCE_ID> identyfikatorem zasobu puli sesji.

Uruchom aplikację

Przed uruchomieniem przykładowej aplikacji otwórz main.py w edytorze i przejrzyj kod. Aplikacja używa interfejsu FastAPI do utworzenia internetowego interfejsu API, który akceptuje komunikat użytkownika w ciągu zapytania.

Następujące wiersze kodu tworzy wystąpienie narzędzia SessionPythonREPLTool i udostępniają go agentowi LangChain:

repl = SessionsPythonREPLTool(pool_management_endpoint=pool_management_endpoint)

tools = [repl]
prompt = hub.pull("hwchase17/openai-functions-agent")
agent = agents.create_tool_calling_agent(llm, tools, prompt)

Gdy konieczne jest wykonanie obliczeń, agent uruchamia kod przy użyciu narzędzia SessionPythonREPLTool . Kod jest wykonywany w sesji w puli sesji. Domyślnie podczas tworzenia wystąpienia narzędzia jest generowany identyfikator sesji losowej. Jeśli agent używa narzędzia do uruchamiania wielu fragmentów kodu w języku Python, używa tej samej sesji. Aby upewnić się, że każdy użytkownik końcowy ma unikatową sesję, użyj oddzielnego agenta i narzędzia dla każdego użytkownika.

Narzędzie SessionPythonREPLTool jest dostępne w pakiecie langchain-azure-dynamic-sessions .

1. Uruchom przykładową aplikację:

   fastapi dev main.py
   

2. Otwórz przeglądarkę i przejdź pod adres http://localhost:8000/docs. Zostanie wyświetlony interfejs użytkownika struktury Swagger dla przykładowej aplikacji.

3. /chat Rozwiń punkt końcowy i wybierz pozycję Wypróbuj.

4. Wprowadź What time is it right now? w message polu i wybierz pozycję Wykonaj.

   Agent odpowiada z bieżącą godziną. W terminalu zobaczysz dzienniki pokazujące kod języka Python wygenerowany przez agenta, aby uzyskać bieżący czas i uruchomić go w sesji interpretera kodu.

5. Aby zatrzymać aplikację, wprowadź Ctrl+C polecenie w terminalu.

Opcjonalnie: wdrażanie przykładowej aplikacji w usłudze Azure Container Apps

Aby wdrożyć aplikację FastAPI w usłudze Azure Container Apps, musisz utworzyć obraz kontenera i wypchnąć go do rejestru kontenerów. Następnie możesz wdrożyć obraz w usłudze Azure Container Apps. Polecenie az containerapp up łączy te kroki w jedno polecenie.

Następnie należy skonfigurować tożsamość zarządzaną dla aplikacji i przypisać jej odpowiednie role, aby uzyskać dostęp do usługi Azure OpenAI i puli sesji.

1. Ustaw zmienne dla środowiska usługi Container Apps i nazwy aplikacji:

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

2. Skompiluj i wdróż aplikację w usłudze Azure Container Apps:

   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_MANAGMENT_ENDPOINT>" \
       --source .
   

   Zastąp <OPEN_AI_ENDPOINT> element punktem końcowym konta usługi Azure OpenAI i <SESSION_POOL_MANAGMENT_ENDPOINT> punktem końcowym zarządzania pulą sesji.

3. Włącz tożsamość zarządzaną przypisaną przez system dla aplikacji:

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

4. Aby aplikacja uzyskiwała dostęp do usługi Azure OpenAI i puli sesji, musisz przypisać tożsamość zarządzaną odpowiednie role.

   1. Pobierz identyfikator podmiotu zabezpieczeń tożsamości zarządzanej:

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

   2. Pobierz identyfikator zasobu puli sesji:

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

   3. Przypisz tożsamość zarządzaną i Azure ContainerApps Session Executor Contributor role w puli sesji:

      Przed uruchomieniem następującego polecenia zastąp <PRINCIPAL_ID> wartości i <SESSION_POOL_RESOURCE_ID> wartościami pobranymi w poprzednich krokach.

      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. Pobierz identyfikator zasobu konta usługi Azure OpenAI:

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

   5. Przypisz tożsamość zarządzaną Cognitive Services OpenAI User rolę na koncie usługi Azure OpenAI:

      Przed uruchomieniem następującego polecenia zastąp <PRINCIPAL_ID> wartości i <AZURE_OPENAI_RESOURCE_ID> wartościami pobranymi w poprzednich krokach.

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

5. Pobierz w pełni kwalifikowaną nazwę domeny aplikacji (FQDN):

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

6. Otwórz przeglądarkę, aby przetestować https://<FQDN>/docs wdrożona aplikację.

Czyszczenie zasobów

Gdy skończysz z zasobami, możesz je usunąć, aby uniknąć naliczania opłat:

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

Następne kroki

Sesje interpretera kodu