Verbinden von Agents mit Microsoft 365 mit Work IQ (Vorschau)

Work IQ ist die Intelligenzschicht, die Microsoft 365 Copilot und Ihre Agenten in Echtzeit in einem gemeinsam genutzten Kontext in Ihrer Organisation verankert. Es erfasst Signale aus E-Mails, Besprechungen, Dateien, Chats und Geschäftssystemen und wendet semantisches Verständnis an, sodass Agenten über Arbeitsdaten grundieren und Maßnahmen ergreifen können. Alle Anforderungen werden im Kontext des angemeldeten Benutzers ausgeführt und berücksichtigen Microsoft 365 Berechtigungen.

Sie verbinden Ihren Foundry-Agent über das A2A-Protokoll (Agent-to-Agent) mit Work IQ. Ihr Agent delegiert Aufgaben in natürlicher Sprache an Work IQ als Peer-Agent – z. B. "Meine letzten E-Mails über Project Contoso zusammenfassen" – und Work IQ behandelt Abruf-, Begründungs- und Antwortsynthese für die Microsoft 365 Daten des Benutzers.

Informationen zur Optimierung der Toolverwendung finden Sie unter bewährten Methoden.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie folgendes haben:

• Die kommerzielle Anforderung für die Verbindung, die Sie verwenden:

  Verbindungspfad	Anforderungstyp	Anforderung
  Iq-API über A2A, REST oder MCP arbeiten	Nutzungsbasierte Abrechnung	Aktivieren Sie die Abrechnung mit Copilot Gutschriften. Dieser Pfad verwendet keine Connectorlizenzierung.
  Connector-gesicherte Microsoft 365-Tools	Connectorlizenzierung	Bestätigen Sie die Voraussetzungen des ausgewählten Connectors. Für jeden anrufden Benutzer kann ein Connector eine Microsoft 365 Copilot-Lizenz erfordern.

• Ein aktives Microsoft Foundry-Projekt mit einem bereitgestellten Modell.

• Azure RBAC-Rollen:

  • Rolle "Foundry User " im Foundry-Projekt für die Entwickleridentität, die Laufzeitidentität des Agents und alle Benutzeridentitäten, die an OAuth-Flüssen beteiligt sind.
  • Foundry Project Manager-Rolle im Foundry-Projekt zum Erstellen einer Foundry-Verbindung zum Work IQ-Endpunkt.

• Ein Microsoft Entra globaler Administrator, der das einmalige Mandantensetup abschließen kann, indem der Work IQ-Dienstprinzipal bereitgestellt und der Administratorzustimmung erteilt WorkIQAgent.Askwird. Aktivieren Sie diese Rolle nur rechtzeitig durch Microsoft Entra Privileged Identity Management (PIM), und deaktivieren Sie sie nach dem Setup. Tägliche Arbeit IQ-Benutzer benötigen diese Rolle nicht.

• Foundry Toolkit: Installieren Sie Visual Studio Code und Foundry Toolkit für Visual Studio Code.

• JavaScript-Entwicklung: Verwenden Sie Node.js 22 oder höher, und installieren Sie @azure/ai-projects 2.4.0 oder höher mit @azure/identity.

Für direkte A2A-Aufrufe unterstützt Work IQ die Protokollversionen 1.0 und 0.3. Senden A2A-Version: 1.0 , um v1-Methodennamen zu verwenden. Das Weglassen der Kopfzeile ist standardmäßig auf v0.3 festgelegt. Fügen Sie Standortmetadaten für zeitabhängige Anforderungen hinzu, und verwenden Sie die delegierte Benutzerauthentifizierung.

Folgen der Setupabhängigkeitszuordnung

Verwenden Sie diese Zuordnung, um den Agent-Verwendungsablauf von Abhängigkeiten zu trennen, die ein Administrator einmal für die Organisation abgeschlossen hat.

Führen Sie zuerst den Ablauf für die Agentverwendung aus, wenn Ihre Organisation bereits über eine Verbindung verfügt. Verwenden Sie das einmalige Mandantensetup nur, wenn ein Administrator die erste Verbindung erstellen muss.

Nutzungssupport

So funktioniert es

1. Ihr Agent gibt einen Toolaufruf aus — Wenn das Agentenmodell eine Aufgabe identifiziert, die Microsoft 365-Daten erfordert, gibt es einen Toolaufruf an das work_iq_preview-Tool aus.
2. Foundry leitet die Anforderung an Work IQ via A2A weiter – Foundry verwendet das Agent-to-Agent (A2A)-Protokoll, um die Natural-Language-Abfrage an Work IQ als Peer-Agent weiterzuleiten. Die Authentifizierung verwendet On-Behalf-Of (OBO), sodass die Anforderung im Kontext des angemeldeten Benutzers ausgeführt wird.
3. Work IQ ruft M365-Daten ab und analysiert sie — Work IQ greift auf die E-Mails, Besprechungen, Dateien, Chats und andere Signale aus Microsoft 365 des Benutzers zu. Es nutzt semantisches Verständnis, um eine Antwort zu formulieren, die auf dem tatsächlichen Arbeitskontext des Benutzers basiert, unter durchgehender Einhaltung der Microsoft 365-Berechtigungen und Vertraulichkeitsbezeichnungen.
4. Das Ergebnis wird an Ihren Agenten zurückgegeben – Work IQ gibt die synthetisierte Antwort auf Foundry über A2A zurück. Ihr Agent integriert sie in seine Antwort auf den Benutzer.

Verbindung mit Work IQ herstellen

Fügen Sie das Tool Work IQ Ihrem Agenten hinzu.

pip install "azure-ai-projects>=2.3.0"

import os
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import PromptAgentDefinition, WorkIQPreviewTool

endpoint = os.environ["FOUNDRY_PROJECT_ENDPOINT"]

with (
    DefaultAzureCredential() as credential,
    AIProjectClient(endpoint=endpoint, credential=credential) as project_client,
    project_client.get_openai_client() as openai_client,
):
    tool_payload = WorkIQPreviewTool(
        project_connection_id=os.environ["WORK_IQ_PROJECT_CONNECTION_ID"],
    )

    agent = project_client.agents.create_version(
        agent_name="MyAgent",
        definition=PromptAgentDefinition(
        model="gpt-5-mini",
            instructions="Use the available WorkIQ tools to answer questions and perform tasks.",
            tools=[tool_payload],
        ),
    )
    print(f"Agent created (id: {agent.id}, name: {agent.name}, version: {agent.version})")

    user_input = "Summarize my recent emails about Project Contoso."
    response = openai_client.responses.create(
        input=user_input,
        extra_body={"agent_reference": {"name": agent.name, "type": "agent_reference"}},
    )

    print(f"Agent response: {response.output_text}")

    # Clean up the agent version so unused versions don't accumulate in the project.
    project_client.agents.delete_version(agent_name=agent.name, agent_version=agent.version)
    print("Agent deleted")

import os

from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import WorkIQPreviewToolboxTool
from azure.identity import DefaultAzureCredential

project_endpoint = os.environ["FOUNDRY_PROJECT_ENDPOINT"]
work_iq_connection_id = os.environ["WORK_IQ_PROJECT_CONNECTION_ID"]

with (
    DefaultAzureCredential() as credential,
    AIProjectClient(
        endpoint=project_endpoint,
        credential=credential,
    ) as project,
):
    toolbox = project.toolboxes.create_version(
        name="work-iq-toolbox",
        description="Toolbox with the Work IQ tool",
        tools=[
            WorkIQPreviewToolboxTool(
                project_connection_id=work_iq_connection_id,
            )
        ],
    )
    print(f"Created toolbox: {toolbox.name}, version: {toolbox.version}")

Created toolbox: work-iq-toolbox, version: <version>

curl --request POST \
  --url "{project_endpoint}/toolboxes/work-iq-toolbox/versions?api-version=v1" \
  -H "Authorization: Bearer {token}" \
  -H "Content-Type: application/json" \
  --data '{
    "description": "Toolbox with the Work IQ tool",
    "tools": [
      {
        "type": "work_iq_preview",
        "project_connection_id": "/subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{account}/projects/{project}/connections/{connection-name}"
      }
    ]
  }'

azd ai connection create work-iq-toolbox-conn \
  --kind remote-tool \
  --target "{project_endpoint}/toolboxes/work-iq-toolbox/versions/<version>/mcp?api-version=v1" \
  --auth-type user-entra-token \
  --audience https://ai.azure.com

POST {project_endpoint}/agents/{agent_name}/versions?api-version=v1
Authorization: Bearer {token}
Content-Type: application/json

{
  "model": "gpt-4o-mini",
  "instructions": "You are a helpful assistant with access to the user's Microsoft 365 work context through Work IQ.",
  "tools": [
    {
      "type": "mcp",
      "server_label": "toolbox",
      "server_url": "{project_endpoint}/toolboxes/work-iq-toolbox/versions/<version>/mcp?api-version=v1",
      "require_approval": "never",
      "project_connection_id": "work-iq-toolbox-conn"
    }
  ]
}

POST {project_endpoint}/openai/v1/conversations
Authorization: Bearer {token}
Content-Type: application/json

{}

POST {project_endpoint}/openai/v1/responses
Authorization: Bearer {token}
Content-Type: application/json

{
  "conversation": "{conversation_id}",
  "input": "Summarize my recent emails about Project Contoso.",
  "agent_reference": {
    "type": "agent_reference",
    "name": "{agent_name}"
  }
}

using Azure.AI.Projects;
using Azure.Identity;

var projectEndpoint = Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT");
var workIQConnectionName = Environment.GetEnvironmentVariable("WORKIQ_CONNECTION_NAME");

AIProjectClient projectClient = new(endpoint: new Uri(projectEndpoint), tokenProvider: new DefaultAzureCredential());

AIProjectConnection workIQConnection = projectClient.Connections.GetConnection(workIQConnectionName);
DeclarativeAgentDefinition agentDefinition = new(model: "gpt-5-mini")
{
    Instructions = "You are a helpful assistant that can access Microsoft 365 data through Work IQ. "
                 + "Use the Work IQ tool to search and retrieve information from emails, calendar events, "
                 + "Teams messages, and other Microsoft 365 content.",
    Tools = { new WorkIQPreviewTool(workIQConnection.Id) }
};

ProjectsAgentVersion agentVersion = projectClient.AgentAdministrationClient.CreateAgentVersion(
    agentName: "myWorkIQAgent",
    options: new(agentDefinition));
Console.WriteLine($"Agent created (name: {agentVersion.Name}, version: {agentVersion.Version})");

ProjectResponsesClient responseClient =
    projectClient.ProjectOpenAIClient.GetProjectResponsesClientForAgent(agentVersion.Name);
CreateResponseOptions responseOptions = new()
{
    ToolChoice = ResponseToolChoice.CreateRequiredChoice(),
    InputItems = { ResponseItem.CreateUserMessageItem("What meetings do I have scheduled today?") },
};
ResponseResult response = responseClient.CreateResponse(responseOptions);
Console.WriteLine(response.GetOutputText());

// Clean up
projectClient.AgentAdministrationClient.DeleteAgentVersion(
    agentName: agentVersion.Name, agentVersion: agentVersion.Version);

using Azure.AI.Projects;
using Azure.AI.Projects.Agents;
using Azure.Identity;

string projectEndpoint = Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT")
    ?? throw new InvalidOperationException("FOUNDRY_PROJECT_ENDPOINT is not set.");
string workIQConnectionName = Environment.GetEnvironmentVariable("WORKIQ_CONNECTION_NAME")
    ?? throw new InvalidOperationException("WORKIQ_CONNECTION_NAME is not set.");

DefaultAzureCredential credential = new();
AIProjectClient projectClient = new(endpoint: new Uri(projectEndpoint), tokenProvider: credential);
AIProjectConnection workIQConnection = projectClient.Connections.GetConnection(workIQConnectionName);
ToolboxVersion toolboxVersion = projectClient.AgentAdministrationClient
    .GetAgentToolboxes().CreateVersion(
        name: "work-iq-toolbox",
        tools: [new WorkIQPreviewToolboxTool(workIQConnection.Id)],
        description: "Toolbox with the Work IQ tool");

Console.WriteLine(
    $"Created toolbox: {toolboxVersion.Name}, version: {toolboxVersion.Version}");

Created toolbox: work-iq-toolbox, version: <version>

const { DefaultAzureCredential } = require("@azure/identity");
const { AIProjectClient } = require("@azure/ai-projects");

const projectEndpoint = process.env["FOUNDRY_PROJECT_ENDPOINT"];
const workIqProjectConnectionId = process.env["WORKIQ_CONNECTION_ID"];

async function main() {
  const project = new AIProjectClient(projectEndpoint, new DefaultAzureCredential());
  const openai = project.getOpenAIClient();

  console.log("Creating a toolbox with the Work IQ tool...");

  // 1. Add the Work IQ tool to a toolbox. Using a toolbox is the recommended
  //    way to give agents tools. See /azure/foundry/agents/concepts/toolbox-overview
  const toolbox = await project.toolboxes.createVersion(
    "work-iq-toolbox",
    [
      {
        type: "work_iq_preview",
        project_connection_id: workIqProjectConnectionId,
      },
    ],
    { description: "Toolbox with the Work IQ tool" },
  );

  // 2. The toolbox exposes an MCP-compatible endpoint.
  const toolboxMcpUrl =
    `${projectEndpoint}/toolboxes/${toolbox.name}` +
    `/versions/${toolbox.version}/mcp?api-version=v1`;

  // 3. Create a remote-tool project connection that points at the toolbox endpoint.
  //    Use a user Entra token so the caller's identity is passed through
  //    (audience https://ai.azure.com). Create the connection once, for example
  //    with the Azure Developer CLI:
  //
  //    azd ai connection create work-iq-toolbox-conn \
  //      --kind remote-tool \
  //      --target "<toolboxMcpUrl>" \
  //      --auth-type user-entra-token \
  //      --audience https://ai.azure.com
  const toolboxConnectionName = "work-iq-toolbox-conn";

  // 4. Attach the toolbox to a prompt agent as an MCP tool.
  const agent = await project.agents.createVersion("MyWorkIQAgent", {
    kind: "prompt",
    model: "gpt-5-mini",
    instructions: "Use the available Work IQ tools to answer questions and perform tasks.",
    tools: [
      {
        type: "mcp",
        server_label: "toolbox",
        server_url: toolboxMcpUrl,
        require_approval: "never",
        project_connection_id: toolboxConnectionName,
      },
    ],
  });
  console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

  const userInput = "What meetings do I have scheduled today?";
  const response = await openai.responses.create(
    { input: userInput },
    { body: { agent_reference: { name: agent.name, version: agent.version, type: "agent_reference" } } },
  );
  console.log(`Agent response: ${response.output_text}`);

  // Clean up the agent version so unused versions don't accumulate in the project.
  await project.agents.deleteVersion(agent.name, agent.version);
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Hinzufügen von Work IQ zu einer Toolbox mit der Azure Developer CLI

Verwenden Sie die Azure Developer CLI, um die Work IQ A2A-Projektverbindung zu erstellen, und verweisen Sie dann aus einer minimalen Toolbox-YAML darauf.

# Step 1. Create the Work IQ connection
azd ai connection create my-workiq-conn \
  --kind remote-a2a \
  --target https://workiq.svc.cloud.microsoft/a2a/ \
  --auth-type oauth2 \
  --authorization-url https://login.microsoftonline.com/<tenant-id>/oauth2/v2.0/authorize \
  --token-url https://login.microsoftonline.com/<tenant-id>/oauth2/v2.0/token \
  --client-id <oauth-client-id> \
  --client-secret <oauth-client-secret> \
  --scopes "api://workiq.svc.cloud.microsoft/WorkIQAgent.Ask offline_access"

# Step 2. Define the toolbox (my-toolbox.yaml)
description: Work IQ toolbox
tools:
  - type: work_iq_preview
    project_connection_id: my-workiq-conn

# Step 3. Create the toolbox
azd ai toolbox create my-toolbox --from-file my-toolbox.yaml

Verwenden von Work IQ mit einem gehosteten Agent

Folgen Sie nach dem Erstellen work-iq-toolboxeiner Toolbox mit einem gehosteten Agent, um sie mit Agent Framework zu verbinden, lokal auszuführen und im Foundry Agent Service bereitzustellen. Die gehostete Integration behält den Kontext pro Anforderung bei, den Work IQ im Namen jedes angemeldeten Benutzers handeln muss.

Verwenden Sie für End-to-End-Implementierungen das verwaltete Python Teams-Aktivitätsbeispiel oder .NET Teams-Aktivitätsbeispiel.

Authentifizierung und Sicherheit

Work IQ verwendet Microsoft Entra ID delegierte Authentifizierung. Alle Anforderungen werden im Kontext des angemeldeten Benutzers ausgeführt. Die Nur-App-Authentifizierung (nur App) wird nicht unterstützt. Microsoft 365-Berechtigungen werden automatisch durchgesetzt — Work IQ-Agenten können niemals auf Daten zugreifen, die der angemeldete Benutzer nicht bereits sehen darf.

Für Work IQ-Verbindungen wird ausschließlich die eigene Entra-App (On-Behalf-Of-Authentifizierung) unterstützt. Dadurch erhält Ihr Entra-Administrator explizite Kontrolle darüber, welche Anwendungen Microsoft-365-Daten über Work IQ abrufen können: Der Administrator überprüft die Berechtigung WorkIQAgent.Ask und erteilt sie speziell für Ihre registrierte App.

Einrichten Ihrer Entra-App (einmal pro Organisation)

Ein Entra-Administrator muss den folgenden einmaligen Mandantenvorgang ausführen, bevor Sie eine Work IQ-Verbindung in Foundry erstellen können. Verwenden Sie für Schritte, die die Rolle "Globaler Administrator" erfordern, Microsoft Entra PIM, um die Rolle rechtzeitig zu aktivieren und nach Abschluss des Setups zu deaktivieren. Tägliche Arbeit IQ-Benutzer benötigen diese Rolle nicht.

Bereitstellen des Work IQ-Dienstprinzipals (einmalig)

Bevor Sie die App-Registrierung erstellen, muss ein globaler Administrator den Work IQ-Dienstprinzipal als Teil dieses einmaligen Mandantenvorgangs bereitstellen. Wenn Sie diesen Schritt überspringen, wird die Option "Work IQ " nicht angezeigt, wenn Sie API-Berechtigungen durchsuchen.

Folgen Sie Schritt 1: Erstellen des Work IQ-Dienstprinzipals im Schnellstart der Work IQ-API. Eine Antwort mit dem Statuscode 201 (Created) aus Graph Explorer bestätigt den Erfolg. Ein Konfliktfehler bedeutet, dass der Prinzipal bereits vorhanden ist – fahren Sie mit dem nächsten Schritt fort.

Erstellen der App-Registrierung

1. Navigieren Sie zum Microsoft Entra Admin Center. Wählen Sie im linken Navigationsbereich Entra ID>App-Registrierungen aus.

2. Wählen Sie Neue Registrierung aus. Weisen Sie der App einen aussagekräftigen Namen zu, und legen Sie Unterstützte Kontotypen auf Konten nur in diesem Organisationsverzeichnis fest. Wählen Sie Registrieren aus.

3. Kopieren Sie die Anwendungs- (Client-)ID. Sie benötigen diesen Wert beim Erstellen der Foundry-Verbindung.

4. Wählen Sie API-Berechtigungen>Berechtigung hinzufügen>Von meiner Organisation verwendete APIs aus. Suchen Sie nach Work IQ (Anwendungs-ID fdcc1f02-fc51-4226-8753-f668596af7f7), wählen Sie delegierte Berechtigungen aus, wählen Sie WorkIQAgent.Ask und dann "Berechtigungen hinzufügen" aus.

5. Wählen Sie Administratoreinwilligung für [Ihren Mandanten] aus. Überprüfen Sie das Bestätigungsdialogfeld, und wählen Sie Ja aus.

   Important

Das Erteilen der mandantenweiten Administratorzustimmung ist ein einmaliger Mandantenvorgang, der die Rolle "Globaler Administrator" in Microsoft Entra ID erfordert. Aktivieren Sie die Rolle nur rechtzeitig durch Microsoft Entra PIM, und deaktivieren Sie sie nach der Erteilung der Zustimmung. Tägliche Arbeit IQ-Benutzer benötigen diese Rolle nicht. Wenn Sie diese Rolle nicht haben, bitten Sie den globalen Administrator Ihrer Organisation, diesen Schritt abzuschließen.

1. Wählen Sie Zertifikate und Geheimnisse>Neuer geheimer Clientschlüssel aus. Fügen Sie eine Beschreibung und eine Ablauffrist hinzu. Wählen Sie "Hinzufügen" aus, und kopieren Sie dann sofort den geheimen Wert – es wird nur einmal angezeigt. Speichern Sie den geheimen Schlüssel in Azure Key Vault oder einem anderen genehmigten geheimen Speicher. Übernehmen Sie niemals den Geheimschlüssel für die Quellcodeverwaltung, drucken oder protokollieren Sie ihn. Drehen Sie das Geheimnis, bevor es abläuft.
2. Kopieren Sie Ihre Verzeichnis-ID (Mandanten-ID) von der Übersichtsseite Microsoft Entra ID.

Füllen Sie die Werte für die Foundry-Verbindung aus.

In Microsoft Foundry öffnen Sie Ihr Projekt, und wechseln Sie zu Settings>Connections>Neue Verbindung>Work IQ. Füllen Sie die folgenden Felder aus:

Ersetzen Sie {tenant-id} durch Ihre Verzeichnis-ID (Mandant) aus Schritt 7. Wählen Sie "Speichern" aus, um die Verbindung zu erstellen.

Fügen Sie die Umleitungs-URI Ihrer App-Registrierung hinzu.

Nachdem Foundry die Verbindung erstellt hat, wird eine OAuth-Umleitungs-URL angezeigt. Fügen Sie diese URL zur App-Registrierung hinzu:

1. Wechseln Sie im Microsoft Entra Admin Center zu Entra ID>App-Registrierungen und wählen Sie Ihre App aus.
2. Wählen Sie Authentifizierung>Plattform hinzufügen>Web aus.
3. Fügen Sie unter Umleitungs-URIs die OAuth-Umleitungs-URL aus Foundry ein.
4. Wählen Sie "Konfigurieren" aus.

Erstellen der Verbindung mit der REST-API

Verwenden Sie als Alternative zum Foundry-Portal die Azure Resource Manager-API, um die Work IQ-Verbindung programmgesteuert zu erstellen.

Schritt 1: Abrufen eines Tokens

ARM_TOKEN=$(az account get-access-token \
  --resource https://management.azure.com \
  --query accessToken -o tsv)

Schritt 2: Erstellen der Verbindung

SUBSCRIPTION_ID=<your-subscription-id>
RESOURCE_GROUP=<your-resource-group>
ACCOUNT_NAME=<your-foundry-account-name>
PROJECT_NAME=<your-project-name>
CONNECTION_NAME=<name-for-this-connection>
TENANT_ID=<your-tenant-id>
CLIENT_ID=<your-client-id>
CLIENT_SECRET=<your-client-secret>

curl --request PUT \
  --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.CognitiveServices/accounts/$ACCOUNT_NAME/projects/$PROJECT_NAME/connections/$CONNECTION_NAME?api-version=2025-04-01-preview" \
  --header "Authorization: Bearer $ARM_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "tags": null,
    "location": null,
    "name": "'"$CONNECTION_NAME"'",
    "type": "Microsoft.MachineLearningServices/workspaces/connections",
    "properties": {
      "authType": "OAuth2",
      "group": "ServicesAndApps",
      "category": "RemoteA2A",
      "expiryTime": null,
      "target": "https://workiq.svc.cloud.microsoft/a2a/",
      "isSharedToAll": true,
      "sharedUserList": [],
      "TokenUrl": "https://login.microsoftonline.com/'"$TENANT_ID"'/oauth2/v2.0/token",
      "AuthorizationUrl": "https://login.microsoftonline.com/'"$TENANT_ID"'/oauth2/v2.0/authorize",
      "RefreshUrl": "https://login.microsoftonline.com/'"$TENANT_ID"'/oauth2/v2.0/token",
      "Scopes": [
        "api://workiq.svc.cloud.microsoft/WorkIQAgent.Ask",
        "offline_access"
      ],
      "Credentials": {
        "ClientId": "'"$CLIENT_ID"'",
        "ClientSecret": "'"$CLIENT_SECRET"'"
      },
      "metadata": {
        "ApiType": "Azure"
      }
    }
  }'

Eine erfolgreiche Antwort gibt HTTP 200 oder 201 zurück. Der Antworttext enthält ein properties.oauthRedirectUrl Feld – verwenden Sie diesen Wert als Umleitungs-URI in Ihrer Entra-App-Registrierung (siehe Hinzufügen des Umleitungs-URI zur App-Registrierung).

Datenverwaltung und Compliance

Der Abruf von Arbeits-IQ-Berechtigungen wird gegen Microsoft 365 gekürzt. Ein Foundry-Workflow kann auch Eingabeaufforderungen und abgerufene Ergebnisse an nachgeschaltete Copilot- und Foundry-Verarbeitung senden. Überprüfen Sie daher die Grenzen und die regionale Konfiguration jedes Diensts im Anforderungspfad.

Datenresidenz

Microsoft 365 Abruf folgt den Berechtigungen und der Residency-Konfiguration Ihres Mandanten. Die End-to-End-Verarbeitung hängt auch von Ihrer Copilot Abrechnungskonfiguration und der Projektregion Gießerei ab. Ausführliche Informationen finden Sie unter Microsoft 365 Copilot Datenschutz- und Datenverarbeitungsrichtlinien.

Datenschutz und Datenverarbeitung

Überprüfen Sie die Microsoft 365 Copilot Datenschutz- und Datenverarbeitungsrichtlinien sowie die Anforderungen für die Gießereidatenverarbeitung, die für Ihre Bereitstellung gelten. Bestätigen Sie den vollständigen Anforderungspfad mit Ihren Datenschutz- und Complianceteams.

Zugriffssteuerung und -berechtigungen

Entwerfen Sie die Verbindung so, dass der Abruf die Microsoft 365 Berechtigungen des angemeldeten Benutzers verwendet. Testen Sie die Berechtigungskürzung mit repräsentativen Benutzern und eingeschränkten Inhalten vor der Bereitstellung:

• Rollenbasierte Zugriffssteuerung, Vertraulichkeitsbezeichnungen und Informationsbarrieren, die in Microsoft 365 definiert sind, werden beachtet.

Compliance-Prüfung

Verwenden Sie die Microsoft Complianceressourcen Ihrer Organisation, um zu bestätigen, welche Zertifizierungen und Kontrollen für die vollständige Work IQ- und Foundry-Bereitstellung gelten.

Administrationsverwaltung

Als Entra-Administrator steuern Sie, welche Anwendungen in Ihrem Mandanten im Auftrag von Benutzern auf Work IQ-Daten zugreifen können. In den folgenden Abschnitten werden die für Sie verfügbaren Tastensteuerelemente beschrieben.

Erteilen oder Widerrufen der Administratorzustimmung

Die Administratorgenehmigung für WorkIQAgent.Ask ist erforderlich, bevor sich ein Benutzer in Ihrer Organisation über die App authentifizieren kann. Sie können die Zustimmung jederzeit verwalten:

• Zustimmung erteilen: Wechseln Sie im Microsoft Entra Admin Center zu Entra ID>App-Registrierungen> und wählen Sie die App >API-Berechtigungen aus. Wählen Sie Administratoreinwilligung für [Ihren Mandanten] aus.
• Widerrufen der Zustimmung: Wählen Sie auf derselben SEITE mit DEN API-Berechtigungen die WorkIQAgent.Ask Berechtigung aus, und wählen Sie " Administratorzustimmung widerrufen" aus. Vorhandene Token bleiben gültig, bis sie ablaufen; Nach dem Widerruf können keine neuen Token ausgegeben werden.

Troubleshooting

Verwandte Inhalte

• Übersicht über die Arbeits-IQ-API (Vorschau)
• Arbeits-IQ-API – Schnellstart (Vorschau)
• Herstellen einer Verbindung mit einem A2A-Agent-Endpunkt vom Foundry Agent Service