Kurz: Část 2 – Vytvoření vlastní chatovací aplikace pomocí sady SDK toku výzvy

V tomto kurzu pomocí sady SDK toku výzvy (a dalších knihoven) sestavíte, nakonfigurujete, vyhodnotíte a nasadíte chatovací aplikaci pro maloobchodní společnost s názvem Contoso Trek. Vaše maloobchodní společnost se specializuje na venkovní kempování a oblečení. Chatovací aplikace by měla odpovídat na otázky týkající se vašich produktů a služeb. Chatovací aplikace může například zodpovědět otázky, jako je "který stan je nejvíce vodotěsný?" nebo "jaká je nejlepší spací taška pro chladné počasí?".

Tato část 2 ukazuje, jak vylepšit základní chatovací aplikaci přidáním načítání rozšířené generace (RAG) k základu odpovědí ve vašich vlastních datech. Načtení rozšířené generace (RAG) je vzor, který používá vaše data s velkým jazykovým modelem (LLM) k vygenerování odpovědí specifických pro vaše data. V této části 2 se naučíte:

Tento kurz je druhou částí třídílného kurzu.

Požadavky

• Kompletní kurz: Část 1 – Vytvoření prostředků pro vytvoření vlastní chatovací aplikace pomocí sady SDK toku výzvy

• Potřebujete místní kopii dat o produktech. Úložiště Azure-Samples/rag-data-openai-python-promptflow na GitHubu obsahuje ukázkové informace o maloobchodním produktu, které jsou relevantní pro tento scénář kurzu. Stáhněte si ukázková prodejní data společnosti Contoso Trek v souboru ZIP do místního počítače.

Struktura kódu aplikace

Vytvořte složku s názvem rag-tutorial na místním počítači. Tato série kurzů vás provede vytvořením obsahu jednotlivých souborů. Po dokončení série kurzů vypadá struktura složek takto:

rag-tutorial/
│   .env
│   build_index.py
│   deploy.py
│   evaluate.py
│   eval_dataset.jsonl
|   invoke-local.py
│
├───copilot_flow
│   └─── chat.prompty
|   └─── copilot.py
|   └─── Dockerfile
│   └─── flow.flex.yaml
│   └─── input_with_chat_history.json
│   └─── queryIntent.prompty
│   └─── requirements.txt
│
├───data
|   └─── product-info/
|   └─── [Your own data or sample data as described in the prerequisites.]

Implementace v tomto kurzu používá tok flex toku výzvy, což je první přístup kódu k implementaci toků. Zadáte vstupní funkci (která je v copilot.py) a pak pro váš tok použijete možnosti testování, vyhodnocení a trasování toku výzvy. Tento tok je v kódu a nemá DAG (směrovaný acyklický graf) ani jinou vizuální komponentu. Přečtěte si další informace o tom, jak vyvíjet flexibilní tok v dokumentaci k toku výzvy na GitHubu.

Nastavení počátečních proměnných prostředí

Existuje kolekce proměnných prostředí používaných napříč různými fragmenty kódu. Přidejte je všechny do souboru .env .

Začněte těmito hodnotami. V průběhu kurzu přidáte několik dalších hodnot.

1. Ve složce rag-tutorial vytvořte soubor .env. Přidejte tyto proměnné:

   AZURE_SUBSCRIPTION_ID=<your subscription id>
   AZURE_RESOURCE_GROUP=<your resource group>
   AZUREAI_PROJECT_NAME=<your project name>
   AZURE_OPENAI_CONNECTION_NAME=<your AIServices or Azure OpenAI connection name>
   AZURE_SEARCH_ENDPOINT=<your Azure Search endpoint>
   AZURE_SEARCH_CONNECTION_NAME=<your Azure Search connection name>
   

Zástupné symboly nahraďte následujícími hodnotami:

• V AI Studiu najděte soubor <your subscription id>, <your resource group>a <your project name> v zobrazení projektu:

  1. V AI Studiu přejděte do projektu a v levém podokně vyberte Nastavení .
  2. V části Vlastnosti projektu vyhledejte ID předplatného a skupinu prostředků. Pole Název je <your project name>

• V nastavení projektu se v části Připojené prostředky zobrazí položka azure AIServices nebo Azure OpenAI. Výběrem názvu otevřete podrobnosti o připojení. Název připojení se zobrazí v horní části stránky Podrobnosti připojení. Zkopírujte tento název, který chcete použít pro <your AIServices or Azure OpenAI connection name>.

• Vraťte se na stránku Nastavení projektu. V části Připojené prostředky vyberte odkaz pro Azure AI Search.

  • Zkopírujte cílovou adresu URL pro <your Azure Search endpoint>.
  • Zkopírujte název v horní části pro <your Azure Search connection name>.

  

Modely nasazení

K vytvoření chatovací aplikace založené na RAG potřebujete dva modely: model chatu Azure OpenAI (gpt-3.5-turbo) a model vkládání Azure OpenAI (text-embedding-ada-002). Nasaďte tyto modely do projektu Azure AI Studio pomocí této sady kroků pro každý model.

Tento postup nasadí model do koncového bodu v reálném čase z katalogu modelů AI Studio:

1. Přihlaste se k AI Studiu a přejděte na domovskou stránku.

2. Na levém bočním panelu vyberte Katalog modelů.

3. Ve filtru Kolekce vyberte Azure OpenAI.

   

4. Vyberte model z kolekce Azure OpenAI. Poprvé vyberte gpt-3.5-turbo model. Podruhé vyberte text-embedding-ada-002 model.

5. Výběrem možnosti Nasadit otevřete okno nasazení.

6. Vyberte centrum, do kterého chcete model nasadit. Použijte stejné centrum jako váš projekt.

7. Zadejte název nasazení a upravte další výchozí nastavení v závislosti na vašich požadavcích.

8. Vyberte Nasadit.

9. Dostanete se na stránku s podrobnostmi o nasazení. Vyberte Otevřít v dětském hřišti.

10. Výběrem možnosti Zobrazit kód získáte ukázky kódu, které můžete použít k využívání nasazeného modelu ve vaší aplikaci.

Když model nasadítegpt-3.5-turbo, v části Zobrazit kód vyhledejte následující hodnoty a přidejte je do souboru .env:

AZURE_OPENAI_ENDPOINT=<endpoint_value>
AZURE_OPENAI_CHAT_DEPLOYMENT=<chat_model_deployment_name>
AZURE_OPENAI_API_VERSION=<api_version>

Když model nasadíte text-embedding-ada-002 , přidejte název do souboru .env :

AZURE_OPENAI_EMBEDDING_DEPLOYMENT=<embedding_model_deployment_name>

Instalace Azure CLI a přihlášení

Nainstalujete Azure CLI a přihlásíte se z místního vývojového prostředí, abyste mohli pomocí přihlašovacích údajů uživatele volat službu Azure OpenAI.

Ve většině případů můžete Azure CLI nainstalovat z terminálu pomocí následujícího příkazu:

winget install -e --id Microsoft.AzureCLI

curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

brew update && brew install azure-cli

Pokud tyto příkazy nefungují pro konkrétní operační systém nebo nastavení, můžete postupovat podle pokynů , jak nainstalovat Azure CLI .

Po instalaci Azure CLI se přihlaste pomocí az login příkazu a přihlaste se pomocí prohlížeče:

az login

Teď vytvoříme naši aplikaci a zavoláme službu Azure OpenAI z kódu.

Vytvoření nového prostředí Pythonu

Nejprve potřebujeme vytvořit nové prostředí Pythonu, které můžeme použít k instalaci balíčků sady SDK pro výzvy toku. Neinstalujte balíčky do globální instalace Pythonu. Při instalaci balíčků Pythonu byste měli vždy používat virtuální prostředí nebo prostředí Conda, jinak můžete přerušit globální instalaci Pythonu.

V případě potřeby nainstalujte Python.

Doporučujeme používat Python 3.10 nebo novější, ale vyžaduje se aspoň Python 3.8. Pokud nemáte nainstalovanou vhodnou verzi Pythonu, můžete postupovat podle pokynů v kurzu VS Code Python pro nejjednodušší způsob instalace Pythonu do operačního systému.

Vytvoříte virtuální prostředí.

Pokud už máte nainstalovaný Python 3.10 nebo novější, můžete vytvořit virtuální prostředí pomocí následujících příkazů:

py -3 -m venv .venv
.venv\scripts\activate

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

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

Aktivace prostředí Python znamená, že při spuštění python nebo pip z příkazového řádku pak použijete interpret Pythonu obsažený ve .venv složce vaší aplikace.

Upgrade pipu

Pokud chcete mít jistotu, že máte nejnovější verzi pipu, spusťte následující příkaz:

python -m pip install --upgrade pip

Instalace sady SDK toku výzvy

Tok výzvy je sada vývojových nástrojů navržených tak, aby zjednodušila kompletní vývojový cyklus aplikací AI založených na LLM– od ideace, vytváření prototypů, testování, hodnocení až po produkční nasazení a monitorování.

Pomocí nástroje pip nainstalujte sadu SDK toku výzvy do virtuálního prostředí, které jste vytvořili.

pip install promptflow
pip install azure-identity

Sada SDK toku výzvy využívá závislost na několika balíčcích, které můžete samostatně nainstalovat, pokud je nechcete mít:

• promptflow-core: obsahuje modul runtime toku výzvy jádra, který se používá ke spouštění kódu LLM.
• promptflow-tracing: Zjednodušená knihovna používaná pro generování trasování OpenTelemetry ve standardech
• promptflow-devkit: obsahuje nástroje pro testovací testovací prostředí toku výzvy a prohlížeče trasování pro místní vývojová prostředí.
• openai: Klientské knihovny pro používání služby Azure OpenAI
• python-dotenv: slouží k nastavení proměnných prostředí jejich čtením ze .env souborů.

Vytvoření indexu Azure AI Search

Cílem této aplikace založené na RAG je uzemnění odpovědí modelu ve vašich vlastních datech. Použijete index Azure AI Search, který ukládá vektorizovaná data z modelu vkládání. Index vyhledávání se používá k načtení relevantních dokumentů na základě otázky uživatele.

Pokud ještě nemáte vytvořený index Azure AI Search, projdeme si, jak ho vytvořit. Pokud už máte index, který chcete použít, můžete přeskočit na nastavení oddílu proměnné prostředí vyhledávání. Index vyhledávání se vytvoří na Search Azure AI, který byl vytvořen nebo odkazován v předchozím kroku.

1. Použijte vlastní data nebo si stáhněte ukázková prodejní data společnosti Contoso Trek v souboru ZIP do místního počítače. Rozbalte soubor do složky rag-tutorial/data . Tato data představují kolekci souborů markdownu, které představují informace o produktu. Data jsou strukturovaná způsobem, který se snadno ingestuje do vyhledávacího indexu. Z těchto dat vytvoříte vyhledávací index.

2. Balíček RAG toku výzvy umožňuje ingestovat soubory Markdownu, místně vytvořit index vyhledávání a zaregistrovat ho v cloudovém projektu. Nainstalujte balíček RAG toku výzvy:

   pip install promptflow-rag
   

3. Ve složce rag-tutorial vytvořte soubor build_index.py.

4. Zkopírujte a vložte následující kód do souboru build_index.py .

   import os
   from dotenv import load_dotenv
   
   load_dotenv()
   
   from azure.ai.ml import MLClient
   from azure.identity import DefaultAzureCredential
   from azure.ai.ml.entities import Index
   
   from promptflow.rag.config import (
       LocalSource,
       AzureAISearchConfig,
       EmbeddingsModelConfig,
       ConnectionConfig,
   )
   from promptflow.rag import build_index
   
   client = MLClient(
       DefaultAzureCredential(),
       os.getenv("AZURE_SUBSCRIPTION_ID"),
       os.getenv("AZURE_RESOURCE_GROUP"),
       os.getenv("AZUREAI_PROJECT_NAME"),
   )
   import os
   
   # append directory of the current script to data directory
   script_dir = os.path.dirname(os.path.abspath(__file__))
   data_directory = os.path.join(script_dir, "data/product-info/")
   
   # Check if the directory exists
   if os.path.exists(data_directory):
       files = os.listdir(data_directory)  # List all files in the directory
       if files:
           print(
               f"Data directory '{data_directory}' exists and contains {len(files)} files."
           )
       else:
           print(f"Data directory '{data_directory}' exists but is empty.")
           exit()
   else:
       print(f"Data directory '{data_directory}' does not exist.")
       exit()
   
   index_name = "tutorial-index"  # your desired index name
   index_path = build_index(
       name=index_name,  # name of your index
       vector_store="azure_ai_search",  # the type of vector store - in this case it is Azure AI Search. Users can also use "azure_cognitive search"
       embeddings_model_config=EmbeddingsModelConfig(
           model_name=os.getenv("AZURE_OPENAI_EMBEDDING_DEPLOYMENT"),
           deployment_name=os.getenv("AZURE_OPENAI_EMBEDDING_DEPLOYMENT"),
           connection_config=ConnectionConfig(
               subscription_id=client.subscription_id,
               resource_group_name=client.resource_group_name,
               workspace_name=client.workspace_name,
               connection_name=os.getenv("AZURE_OPENAI_CONNECTION_NAME"),
           ),
       ),
       input_source=LocalSource(input_data=data_directory),  # the location of your files
       index_config=AzureAISearchConfig(
           ai_search_index_name=index_name,  # the name of the index store inside the azure ai search service
           ai_search_connection_config=ConnectionConfig(
               subscription_id=client.subscription_id,
               resource_group_name=client.resource_group_name,
               workspace_name=client.workspace_name,
               connection_name=os.getenv("AZURE_SEARCH_CONNECTION_NAME"),
           ),
       ),
       tokens_per_chunk=800,  # Optional field - Maximum number of tokens per chunk
       token_overlap_across_chunks=0,  # Optional field - Number of tokens to overlap between chunks
   )
   
   # register the index so that it shows up in the cloud project
   client.indexes.create_or_update(Index(name=index_name, path=index_path))
   

   • Nastavte proměnnou index_name na název požadovaného indexu.
   • Podle potřeby můžete proměnnou path_to_data aktualizovat na cestu, do které se ukládají datové soubory.

   Důležité

   Ve výchozím nastavení vzorový kód očekává strukturu kódu aplikace, jak je popsáno výše v tomto kurzu. Složka data by měla být na stejné úrovni jako build_index.py a stahovaná složka se soubory product-info MD.

5. Z konzoly spusťte kód, který sestaví index místně a zaregistruje ho do cloudového projektu:

   python build_index.py
   

6. Po spuštění skriptu můžete nově vytvořený index zobrazit na stránce Indexy projektu Azure AI Studio. Další informace najdete v tématu Vytváření a využívání vektorových indexů v nástroji Azure AI Studio.

7. Pokud skript spustíte znovu se stejným názvem indexu, vytvoří se nová verze stejného indexu.

Nastavení proměnné prostředí indexu vyhledávání

Jakmile budete mít název indexu, který chcete použít (buď vytvořením nového, nebo odkazem na existující název), přidejte ho do souboru .env , například takto:

AZUREAI_SEARCH_INDEX_NAME=<index-name>

Vývoj vlastního kódu RAG

Dále vytvoříte vlastní kód pro přidání funkcí rozšířené generace (RAG) pro načtení do základní chatovací aplikace. V rychlém startu jste vytvořili soubory chat.py a chat.prompty . V této oblasti rozšíříte tento kód tak, aby zahrnoval funkce RAG.

Chatovací aplikace s RAG implementuje následující obecnou logiku:

1. Generování vyhledávacího dotazu na základě záměru uživatelského dotazu a jakékoli historie chatu
2. Vložení dotazu pomocí modelu vložení
3. Načtení relevantních dokumentů z indexu vyhledávání vzhledem k dotazu
4. Předání relevantního kontextu do modelu dokončení chatu Azure OpenAI
5. Vrácení odpovědi z modelu Azure OpenAI

Logika implementace chatovací aplikace

Logika implementace chatovací aplikace je v souboru copilot.py . Tento soubor obsahuje základní logiku chatovací aplikace založené na RAG.

1. Ve složce rag-tutorial vytvořte složku s názvem copilot_flow.

2. Potom ve složce copilot_flow vytvořte soubor s názvem copilot.py.

3. Do souboru copilot.py přidejte následující kód:

   import os
   from dotenv import load_dotenv
   
   load_dotenv()
   
   from promptflow.core import Prompty, AzureOpenAIModelConfiguration
   from promptflow.tracing import trace
   from openai import AzureOpenAI
   
   # <get_documents>
   @trace
   def get_documents(search_query: str, num_docs=3):
       from azure.identity import DefaultAzureCredential, get_bearer_token_provider
       from azure.search.documents import SearchClient
       from azure.search.documents.models import VectorizedQuery
   
       token_provider = get_bearer_token_provider(
           DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default"
       )
   
       index_name = os.getenv("AZUREAI_SEARCH_INDEX_NAME")
   
       #  retrieve documents relevant to the user's question from Cognitive Search
       search_client = SearchClient(
           endpoint=os.getenv("AZURE_SEARCH_ENDPOINT"),
           credential=DefaultAzureCredential(),
           index_name=index_name,
       )
   
       aoai_client = AzureOpenAI(
           azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
           azure_ad_token_provider=token_provider,
           api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
       )
   
       # generate a vector embedding of the user's question
       embedding = aoai_client.embeddings.create(
           input=search_query, model=os.getenv("AZURE_OPENAI_EMBEDDING_DEPLOYMENT")
       )
       embedding_to_query = embedding.data[0].embedding
   
       context = ""
       # use the vector embedding to do a vector search on the index
       vector_query = VectorizedQuery(
           vector=embedding_to_query, k_nearest_neighbors=num_docs, fields="contentVector"
       )
       results = trace(search_client.search)(
           search_text="", vector_queries=[vector_query], select=["id", "content"]
       )
   
       for result in results:
           context += f"\n>>> From: {result['id']}\n{result['content']}"
   
       return context
   
   
   # <get_documents>
   
   from promptflow.core import Prompty, AzureOpenAIModelConfiguration
   
   from pathlib import Path
   from typing import TypedDict
   
   
   class ChatResponse(TypedDict):
       context: dict
       reply: str
   
   
   def get_chat_response(chat_input: str, chat_history: list = []) -> ChatResponse:
       model_config = AzureOpenAIModelConfiguration(
           azure_deployment=os.getenv("AZURE_OPENAI_CHAT_DEPLOYMENT"),
           api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
           azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
       )
   
       searchQuery = chat_input
   
       # Only extract intent if there is chat_history
       if len(chat_history) > 0:
           # extract current query intent given chat_history
           path_to_prompty = f"{Path(__file__).parent.absolute().as_posix()}/queryIntent.prompty"  # pass absolute file path to prompty
           intentPrompty = Prompty.load(
               path_to_prompty,
               model={
                   "configuration": model_config,
                   "parameters": {
                       "max_tokens": 256,
                   },
               },
           )
           searchQuery = intentPrompty(query=chat_input, chat_history=chat_history)
   
       # retrieve relevant documents and context given chat_history and current user query (chat_input)
       documents = get_documents(searchQuery, 3)
   
       # send query + document context to chat completion for a response
       path_to_prompty = f"{Path(__file__).parent.absolute().as_posix()}/chat.prompty"
       chatPrompty = Prompty.load(
           path_to_prompty,
           model={
               "configuration": model_config,
               "parameters": {"max_tokens": 256, "temperature": 0.2},
           },
       )
       result = chatPrompty(
           chat_history=chat_history, chat_input=chat_input, documents=documents
       )
   
       return dict(reply=result, context=documents)
   

Soubor copilot.py obsahuje dvě klíčové funkce: get_documents() a get_chat_response().

Všimněte si, že tyto dvě funkce mají @trace dekorátor, který umožňuje zobrazit protokoly trasování toku výzvy pro jednotlivé vstupy a výstupy volání jednotlivých funkcí. @trace je alternativní a rozšířený přístup ke způsobu, jakým rychlý start ukázal možnosti trasování.

Funkce get_documents() je jádrem logiky RAG.

1. Vezme vyhledávací dotaz a počet dokumentů, které se mají načíst.
2. Vloží vyhledávací dotaz pomocí modelu pro vložení.
3. Dotazuje index služby Azure Search, aby načetl dokumenty relevantní pro dotaz.
4. Vrátí kontext dokumentů.

Funkce get_chat_response() se sestaví z předchozí logiky v souboru chat.py :

1. Vezme v a chat_input všechny chat_history.
2. Vytvoří vyhledávací dotaz na chat_input základě záměru a chat_history.
3. Volání get_documents() pro načtení relevantních dokumentů
4. Zavolá model dokončování chatu s kontextem, aby získal základní odpověď na dotaz.
5. Vrátí odpověď a kontext. Jako návratový objekt pro naši get_chat_response() funkci jsme nastavili zadaný slovník. Můžete zvolit, jak váš kód vrátí odpověď tak, aby odpovídala vašemu případu použití.

Funkce get_chat_response() používá dva Prompty soubory k provedení potřebných volání LLM (Large Language Model), které probereme dále.

Šablona výzvy k chatu

Soubor chat.prompty je jednoduchý a podobá se chat.prompty v rychlém startu. Systémová výzva se aktualizuje tak, aby odrážela náš produkt a šablony výzvy obsahují kontext dokumentu.

1. Do adresáře copilot_flow přidejte soubor chat.prompty. Soubor představuje volání modelu dokončení chatu s poskytnutým kontextem výzvy systému, historie chatu a kontextem dokumentu.

2. Přidejte tento kód do souboru chat.prompty :

   ---
   name: Chat Prompt
   description: A prompty that uses the chat API to respond to queries grounded in relevant documents
   model:
       api: chat
       configuration:
           type: azure_openai
   inputs:
       chat_input:
           type: string
       chat_history:
           type: list
           is_chat_history: true
           default: []
       documents:
           type: object
   
   ---
   system:
   You are an AI assistant helping users with queries related to outdoor outdooor/camping gear and clothing.
   If the question is not related to outdoor/camping gear and clothing, just say 'Sorry, I only can answer queries related to outdoor/camping gear and clothing. So, how can I help?'
   Don't try to make up any answers.
   If the question is related to outdoor/camping gear and clothing but vague, ask for clarifying questions instead of referencing documents. If the question is general, for example it uses "it" or "they", ask the user to specify what product they are asking about.
   Use the following pieces of context to answer the questions about outdoor/camping gear and clothing as completely, correctly, and concisely as possible.
   Do not add documentation reference in the response.
   
   # Documents
   {{documents}}
   
   {% for item in chat_history %}
   {{item.role}}
   {{item.content}}
   {% endfor %}
   
   user:
   {{chat_input}}
   

Šablona výzvy k historii chatu

Vzhledem k tomu, že implementujeme aplikaci založenou na RAG, je potřeba mít další logiku pro načítání relevantních dokumentů nejen pro aktuální uživatelský dotaz, ale také s ohledem na historii chatu. Bez této další logiky by volání LLM zohlednilo historii chatu. Pro tento kontext byste ale nenačetli správné dokumenty, takže byste nedostali očekávanou odpověď.

Pokud například uživatel položí otázku "je vodotěsný?", potřebujeme, aby systém podíval na historii chatu, aby určil, na co slovo "it" odkazuje, a zahrnout tento kontext do vyhledávacího dotazu, který se má vložit. Tímto způsobem načteme správné dokumenty pro "it" (možná Alpine Explorer Tent) a jeho "náklady".

Místo předání pouze dotazu uživatele, který se má vložit, musíme vygenerovat nový vyhledávací dotaz, který bere v úvahu jakoukoli historii chatu. Používáme další Prompty volání (což je další volání LLM) s konkrétní výzvou k interpretaci záměru dotazu uživatele v dané historii chatu a vytvoření vyhledávacího dotazu, který má nezbytný kontext.

1. Ve složce copilot_flow vytvořte soubor queryIntent.prompty.

2. Zadejte tento kód pro konkrétní podrobnosti o formátu výzvy a několika příkladech.

   ---
    name: Chat Prompt
    description: A prompty that extract users query intent based on the current_query and chat_history of the conversation
    model:
        api: chat
        configuration:
            type: azure_openai
    inputs:
        query:
          type: string
        chat_history:
            type: list
            is_chat_history: true
            default: []
    
    ---
    system:
    - You are an AI assistant reading a current user query and chat_history.
    - Given the chat_history, and current user's query, infer the user's intent expressed in the current user query.
    - Once you infer the intent, respond with a search query that can be used to retrieve relevant documents for the current user's query based on the intent
    - Be specific in what the user is asking about, but disregard parts of the chat history that are not relevant to the user's intent.
    
    Example 1:
    With a chat_history like below:
    \```
    chat_history: [    {
          "role": "user",
          "content": "are the trailwalker shoes waterproof?"
        },
        {
          "role": "assistant",
          "content": "Yes, the TrailWalker Hiking Shoes are waterproof. They are designed with a durable and waterproof construction to withstand various terrains and weather conditions."
        }
    ]
    \```
    User query: "how much do they cost?"
    
    Intent: "The user wants to know how much the Trailwalker Hiking Shoes cost."
    Search query: "price of Trailwalker Hiking Shoes"
    
    
    Example 2:
    With a chat_history like below:
    \```
    chat_history: [    {
          "role": "user",
          "content": "are the trailwalker shoes waterproof?"
        },
        {
          "role": "assistant",
          "content": "Yes, the TrailWalker Hiking Shoes are waterproof. They are designed with a durable and waterproof construction to withstand various terrains and weather conditions."
        },
        {
          "role": "user",
          "content": "how much do they cost?"
        },
        {
          "role": "assistant",
          "content": "The TrailWalker Hiking Shoes are priced at $110."
        },
        {
          "role": "user",
          "content": "do you have waterproof tents?"
        },
        {
          "role": "assistant",
          "content": "Yes, we have waterproof tents available. Can you please provide more information about the type or size of tent you are looking for?"
        },
        {
          "role": "user",
          "content": "which is your most waterproof tent?"
        },
        {
          "role": "assistant",
          "content": "Our most waterproof tent is the Alpine Explorer Tent. It is designed with a waterproof material and has a rainfly with a waterproof rating of 3000mm. This tent provides reliable protection against rain and moisture."
        }
    ]
    \```
    User query: "how much does it cost?"
    
    Intent: "the user would like to know how much the Alpine Explorer Tent costs"
    Search query: "price of Alpine Explorer Tent"
    
    {% for item in chat_history %}
    {{item.role}}
    {{item.content}}
    {% endfor %}
    
    Current user query:
    {{query}}
    
    Search query:
   

Jednoduchá systémová zpráva v souboru queryIntent.prompty dosahuje minimálního požadovaného pro řešení RAG pro práci s historií chatu.

Konfigurace požadovaných balíčků

Vytvořte soubor requirements.txt ve složce copilot_flow . Přidejte tento obsah:

openai
azure-identity
azure-search-documents==11.4.0
promptflow[azure]==1.11.0
promptflow-tracing==1.11.0
promptflow-tools==1.4.0
promptflow-evals==0.3.0
jinja2
aiohttp
python-dotenv

Tyto balíčky se vyžadují, aby tok běžel místně a v nasazeném prostředí.

Použití flex flow

Jak jsme už zmínili, tato implementace používá flexibilní tok toku výzvy, což je přístup založený na kódu při implementaci toků. Zadáte vstupní funkci (která je definována v copilot.py). Další informace najdete v části Vývoj flexibilního toku.

Tento yaml určuje vstupní funkci, což je funkce definovaná get_chat_response v copilot.py. Určuje také požadavky, které tok musí spustit.

Ve složce copilot_flow vytvořte soubor flow.flex.yaml. Přidejte tento obsah:

entry: copilot:get_chat_response
environment:
  python_requirements_txt: requirements.txt

Použití toku výzvy k otestování chatovací aplikace

Pomocí funkce testování toku výzvy můžete zjistit, jak vaše chatovací aplikace funguje podle očekávání u ukázkových vstupů. Pomocí souboru flow.flex.yaml můžete použít tok výzvy k otestování se zadanými vstupy.

Spusťte tok pomocí tohoto příkazu toku příkazového řádku:

pf flow test --flow ./copilot_flow --inputs chat_input="how much do the Trailwalker shoes cost?"

Případně můžete tok spustit interaktivně pomocí příznaku --ui .

pf flow test --flow ./copilot_flow --ui

Při použití --uise v interaktivním ukázkovém chatu otevře okno v místním prohlížeči.

• Při prvním spuštění s příznakem --ui musíte ručně vybrat vstupy chatu a výstupy z možností. Při prvním vytvoření této relace vyberte nastavení konfigurace vstupního a výstupního pole chatu a začněte chatovat.
• Při příštím spuštění s příznakem --ui si relace zapamatuje vaše nastavení.

Až budete s interaktivní relací hotovi, stisknutím kláves Ctrl + C v okně terminálu server zastavíte.

Testování pomocí historie chatu

Obecně platí, že tok výzvy a Prompty podporuje historii chatu. Pokud testujete s příznakem --ui v místně obsluhované front-endu, tok výzvy spravuje historii chatu. Pokud testujete bez , --uimůžete zadat vstupní soubor, který obsahuje historii chatu.

Vzhledem k tomu, že naše aplikace implementuje RAG, museli jsme přidat další logiku pro zpracování historie chatu v souboru queryIntent.prompty .

Pokud chcete otestovat historii chatu, vytvořte soubor s názvem input_with_chat_history.json ve složce copilot_flow a vložte tento obsah:

{
    "chat_input": "how much does it cost?",
    "chat_history": [
        {
        "role": "user",
        "content": "are the trailwalker shoes waterproof?"
        },
        {
        "role": "assistant",
        "content": "Yes, the TrailWalker Hiking Shoes are waterproof. They are designed with a durable and waterproof construction to withstand various terrains and weather conditions."
        },
        {
        "role": "user",
        "content": "how much do they cost?"
        },
        {
        "role": "assistant",
        "content": "The TrailWalker Hiking Shoes are priced at $110."
        },
        {
        "role": "user",
        "content": "do you have waterproof tents?"
        },
        {
        "role": "assistant",
        "content": "Yes, we have waterproof tents available. Can you please provide more information about the type or size of tent you are looking for?"
        },
        {
        "role": "user",
        "content": "which is your most waterproof tent?"
        },
        {
        "role": "assistant",
        "content": "Our most waterproof tent is the Alpine Explorer Tent. It is designed with a waterproof material and has a rainfly with a waterproof rating of 3000mm. This tent provides reliable protection against rain and moisture."
        }
    ]
    }

Pokud chcete testovat s tímto souborem, spusťte:

pf flow test --flow ./copilot_flow --inputs ./copilot_flow/input_with_chat_history.json

Očekávaný výstup je něco jako: "Alpine Explorer Tent je cena za 350 USD."

Tento systém dokáže interpretovat záměr dotazu "kolik stojí?" a vědět, že "it" odkazuje na stan Alpine Exploreru, což byl nejnovější kontext v historii chatu. Systém pak sestaví vyhledávací dotaz na cenu stanu Alpine Exploreru, aby načetl relevantní dokumenty pro náklady na stan Alpine Exploreru a získali jsme odpověď.

Pokud přejdete na trasování z tohoto toku, zobrazí se konverzace v akci. Odkaz na místní trasování se zobrazí ve výstupu konzoly před výsledkem běhu testu toku.

Vyčištění prostředků

Pokud se chcete vyhnout zbytečným nákladům na Azure, měli byste odstranit prostředky, které jste vytvořili v tomto kurzu, pokud už nejsou potřeba. Ke správě prostředků můžete použít Azure Portal.

Pokud ale chcete chatovací aplikaci nasadit do Azure v další části této série kurzů, ještě je neodstraňujte.

Další krok