Exempel på Fabric-dataagent med AdventureWorks-datasetet (förhandsversionen)

Den här artikeln visar hur du konfigurerar en dataagent i Microsoft Fabric med hjälp av ett lakehouse som exempeldatakälla. Först skapar och fyller vi i ett sjöhus, sedan skapar vi en Fabric-dataagent och lägger till lakehouse i den. Om du redan har en Power BI-semantisk modell (med nödvändiga läs-/skrivbehörigheter), ett lager eller en KQL-databas följer du samma steg och väljer den källan i stället. Även om den här genomgången använder ett sjöhus är mönstret detsamma för andra källor – endast valet av datakälla skiljer sig åt.

Förutsättningar

• En betald F2- eller högre Infrastrukturkapacitet, eller en Power BI Premium per kapacitet (P1 eller högre) kapacitet med Microsoft Fabric aktiverat
• Klientinställningarna för infrastrukturdataagenten är aktiverade.
• Cross-geo-bearbetning för AI är aktiverad.
• Lagring mellan geografiska områden för AI- är aktiverat.
• Minst en av dessa: ett lager, ett sjöhus, en eller flera Power BI-semantiska modeller eller en KQL-databas med data.
• Power BI-semantiska modeller via XMLA-slutpunktsklientväxeln är aktiverad för Power BI-semantiska modelldatakällor.

Skapa ett sjöhus med AdventureWorksLH

Först skapar du ett sjöhus och fyller det med nödvändiga data.

Om du redan har en instans av AdventureWorksLH i ett datahus (eller ett lager) kan du hoppa över det här steget. Annars kan du använda följande instruktioner från en Fabric-notebook för att fylla lakehouse med datan.

1. Skapa en ny notebook-fil på arbetsytan där du vill skapa din Fabric-dataagent.

2. Till vänster i fönstret Utforskaren väljer du + Datakällor. Med det här alternativet kan du lägga till ett befintligt sjöhus eller skapa ett nytt sjöhus. Skapa ett nytt sjöhus för tydlighetens skull och tilldela det ett namn.

3. Lägg till följande kodfragment i den översta cellen:

   import pandas as pd
   from tqdm.auto import tqdm
   base = "https://synapseaisolutionsa.z13.web.core.windows.net/data/AdventureWorks"
   
   # load list of tables
   df_tables = pd.read_csv(f"{base}/adventureworks.csv", names=["table"])
   
   for table in (pbar := tqdm(df_tables['table'].values)):
       pbar.set_description(f"Uploading {table} to lakehouse")
   
       # download
       df = pd.read_parquet(f"{base}/{table}.parquet")
   
       # save as lakehouse table
       spark.createDataFrame(df).write.mode('overwrite').saveAsTable(table)
   

4. Välj Kör alla.

Efter några minuter fylls sjöstugan med den nödvändiga datan.

Skapa en Fabric-dataagent

Om du vill skapa en ny Fabric-dataagent går du till din arbetsyta och väljer knappen + Nytt objekt , som du ser i den här skärmbilden:

På fliken Alla objekt söker du efter Fabric data agent för att hitta lämpligt alternativ. När du har gjort ditt val uppmanas du att ange ett namn för din Fabric-dataagent, vilket visas i denna skärmbild:

När du har angett namnet fortsätter du med följande steg för att justera Fabric-dataagenten efter dina specifika krav.

Välj datamängd

Välj det lakehouse som du skapade i föregående steg och välj sedan Lägg till, som visas i följande skärmbild:

När lakehouse har lagts till som datakälla, visar Explorer-fönstret till vänster på Fabric-dataagentens sida lakehouse-namnet. Välj lakehouse för att visa alla tillgängliga tabeller. Använd kryssrutorna för att markera de tabeller som du vill göra tillgängliga för AI:n. I det här scenariot väljer du följande tabeller:

• dimcustomer
• dimdate
• dimgeography
• dimproduct
• dimproductcategory
• dimpromotion
• dimreseller
• dimsalesterritory
• factinternetsales
• factresellersales

Ge instruktioner

Om du vill lägga till instruktioner väljer du knappen Dataagentinstruktioner för att öppna anvisningarna till höger. Du kan lägga till följande instruktioner.

Den AdventureWorksLH datakällan innehåller information från tre tabeller:

• dimcustomer, för detaljerad kunddemografi och kontaktinformation
• dimdate, för datumrelaterade data – till exempel kalender- och räkenskapsinformation
• dimgeographyför geografisk information, inklusive ortnamn och landsregionkoder.

Använd den här datakällan för frågor och analyser som omfattar kundinformation, tidsbaserade händelser och geografiska platser.

Ange exempel

Om du vill lägga till exempelfrågor väljer du knappen Exempelfrågor för att öppna fönstret exempelfrågor till höger. Det här fönstret innehåller alternativ för att lägga till eller redigera exempelfrågor för alla datakällor som stöds. För varje datakälla kan du välja Lägg till eller redigera exempelfrågor för att ange relevanta exempel, enligt följande skärmbild:

Här bör du lägga till Exempelfrågor för den lakehouse-datakälla som du skapade.

Question: Calculate the average percentage increase in sales amount for repeat purchases for every zipcode. Repeat purchase is a purchase subsequent to the first purchase (the average should always be computed relative to the first purchase)

SELECT AVG((s.SalesAmount - first_purchase.SalesAmount) / first_purchase.SalesAmount * 100) AS AvgPercentageIncrease
FROM factinternetsales s
INNER JOIN dimcustomer c ON s.CustomerKey = c.CustomerKey
INNER JOIN dimgeography g ON c.GeographyKey = g.GeographyKey
INNER JOIN (
    SELECT *
    FROM (
        SELECT
            CustomerKey,
            SalesAmount,
            OrderDate,
            ROW_NUMBER() OVER (PARTITION BY CustomerKey ORDER BY OrderDate) AS RowNumber
        FROM factinternetsales
    ) AS t
    WHERE RowNumber = 1
) first_purchase ON s.CustomerKey = first_purchase.CustomerKey
WHERE s.OrderDate > first_purchase.OrderDate
GROUP BY g.PostalCode;

Question: Show the monthly total and year-to-date total sales. Order by year and month.

SELECT
    Year,
    Month,
    MonthlySales,
    SUM(MonthlySales) OVER (PARTITION BY Year ORDER BY Year, Month ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS CumulativeTotal
FROM (
    SELECT
       YEAR(OrderDate) AS Year,
       MONTH(OrderDate) AS Month,
       SUM(SalesAmount) AS MonthlySales
    FROM factinternetsales
    GROUP BY YEAR(OrderDate), MONTH(OrderDate)
) AS t

Testa och revidera fabric-dataagenten

Nu när du har konfigurerat fabric-dataagenten, lagt till instruktioner för Fabric-dataagenten och tillhandahållit exempelfrågor för lakehouse kan du interagera med den genom att ställa frågor och få svar. När du fortsätter att testa kan du lägga till fler exempel och förfina instruktionerna för att ytterligare förbättra prestanda för Fabric-dataagenten. Samarbeta med dina kollegor för att samla in feedback och se till att de exempelfrågor och instruktioner som tillhandahålls överensstämmer med de typer av frågor som de vill ställa.

Publicera Fabric-dataagenten

När du har verifierat prestandan för Fabric-dataagenten kan du välja att publicera den, så att du sedan kan dela den med dina kollegor som vill göra frågor och svar kring data. I det här fallet väljer du Publicera, som du ser i den här skärmbilden:

Rutan Publicera dataagent öppnas, vilket visas i skärmbilden:

I den här rutan väljer du Publicera för att publicera Fabric-dataagenten. Den publicerade URL:en för fabric-dataagenten visas, som du ser i den här skärmbilden:

Använda Fabric-dataagenten i Copilot i Power BI

Du kan använda Copilot i Power BI för att interagera med fabric-dataagenten när du har publicerat den. Med Copilot i Power BI kan du direkt använda dataagenten och andra objekt (till exempel rapporter eller semantiska modeller) utan att behöva växla mellan dem.

Välj knappen Copilot i det vänstra navigeringsfönstret för att öppna Copilot i Power BI. Välj sedan Lägg till objekt för bättre resultat i textrutan längst ned för att lägga till dataagenten. Välj Dataagenter i fönstret som öppnas. Du kan bara se de dataagenter som du har behörighet att komma åt. Välj den dataagent som du vill använda och välj Bekräfta. Det här exemplet visar hur du arbetar med en enda dataagent, men du kan lägga till fler objekt – till exempel andra dataagenter, rapporter eller semantiska modeller. Följande skärmbild visar stegen med en enda dataagent:

Nu när du har lagt till dataagenten i Copilot i Power BI kan du ställa frågor som rör din Fabric-dataagent, enligt följande skärmbild:

Använda Fabric-dataagenten programmatiskt

Du kan använda dataagenten Fabric programmatiskt i en Fabric-notebook-fil. Om du vill avgöra om Fabric-dataagenten har ett publicerat URL-värde väljer du Inställningar, enligt följande skärmbild:

Innan du publicerar Fabric-dataagenten har den inget publicerat URL-värde, som du ser i följande skärmbild:

Skärmbild som visar att en dataagent för Fabric inte har ett publicerat URL-värde före publicering.

Om du inte har publicerat Fabric-dataagenten tidigare kan du publicera den enligt anvisningarna i föregående steg. Du kan sedan kopiera den publicerade URL:en och använda den i Fabric-anteckningsboken. På så sätt kan du fråga Fabric-dataagenten genom att göra anrop till FABRIC-dataagent-API:et i en Fabric-notebook-fil. Klistra in den kopierade URL:en i det här kodfragmentet. Ersätt sedan frågan med alla frågor som är relevanta för din Fabric-dataagent. Det här exemplet används \<generic published URL value\> som URL.

%pip install "openai==1.70.0"
%pip install "synapseml==1.0.5"  # Required for synapse.ml.mlflow (update version as needed)
%pip install pandas tqdm  # Skip if already available in the Fabric runtime

import typing as t
import time
import uuid

# OpenAI SDK internals
from openai import OpenAI
from openai._models import FinalRequestOptions
from openai._types import Omit
from openai._utils import is_given

# SynapseML helper for env config
from synapse.ml.mlflow import get_mlflow_env_config

# Removed unused imports: requests, json, pprint, APIStatusError, SynapseTokenProvider
 
base_url = "https://<generic published base URL value>"
question = "What data sources do you have access to?"

configs = get_mlflow_env_config()

# Create OpenAI Client
class FabricOpenAI(OpenAI):
    def __init__(
        self,
        api_version: str ="2024-05-01-preview",
        **kwargs: t.Any,
    ) -> None:
        self.api_version = api_version
        default_query = kwargs.pop("default_query", {})
        default_query["api-version"] = self.api_version
        super().__init__(
            api_key="",
            base_url=base_url,
            default_query=default_query,
            **kwargs,
        )
    
    def _prepare_options(self, options: FinalRequestOptions) -> None:
        headers: dict[str, str | Omit] = (
            {**options.headers} if is_given(options.headers) else {}
        )
        options.headers = headers
        headers["Authorization"] = f"Bearer {configs.driver_aad_token}"
        if "Accept" not in headers:
            headers["Accept"] = "application/json"
        if "ActivityId" not in headers:
            correlation_id = str(uuid.uuid4())
            headers["ActivityId"] = correlation_id

        return super()._prepare_options(options)

# Pretty printing helper
def pretty_print(messages):
    print("---Conversation---")
    for m in messages:
        print(f"{m.role}: {m.content[0].text.value}")
    print()

fabric_client = FabricOpenAI()
# Create assistant
assistant = fabric_client.beta.assistants.create(model="not used")
# Create thread
thread = fabric_client.beta.threads.create()
# Create message on thread
message = fabric_client.beta.threads.messages.create(thread_id=thread.id, role="user", content=question)
# Create run
run = fabric_client.beta.threads.runs.create(thread_id=thread.id, assistant_id=assistant.id)

# Wait for run to complete (avoid indefinite loop)
terminal_states = {"completed", "failed", "cancelled", "requires_action"}
poll_interval = 2
timeout_seconds = 300  # Adjust based on expected workload
start_time = time.time()

while run.status not in terminal_states:
    if time.time() - start_time > timeout_seconds:
        raise TimeoutError(f"Run polling exceeded {timeout_seconds} seconds (last status={run.status})")
    run = fabric_client.beta.threads.runs.retrieve(
        thread_id=thread.id,
        run_id=run.id,
    )
    print(run.status)
    time.sleep(poll_interval)

if run.status != "completed":
    print(f"Run finished with status: {run.status}")

# Print messages
response = fabric_client.beta.threads.messages.list(thread_id=thread.id, order="asc")
pretty_print(response)

# Delete thread
fabric_client.beta.threads.delete(thread_id=thread.id)

Relaterat innehåll

• Begrepp för dataagent i nätverksstruktur
• Skapa en Fabric-dataagent