Grounding mit Bing-Suche

Artikel
03/03/2025

Grounding mit Bing-Suche ermöglicht es Ihren Azure KI Agenten, öffentliche Webdaten in Echtzeit zu integrieren, wenn Antworten generiert werden. Sie müssen Grounding mit einer Bing-Suchressource verschaffen und diese Ressource dann mit Ihren Azure KI-Agenten verbinden. Wenn eine benutzende Person eine Anfrage sendet, entscheiden Azure KI-Agenten, ob Grounding mit der Bing-Suche genutzt werden sollte oder nicht. Wenn ja, wird Bing genutzt, um öffentliche Webdaten zu durchsuchen und relevante Teile zurückzugeben. Schließlich werden Azure KI-Agenten die zurückgegebenen Blöcke verwenden, um eine Antwort zu generieren.

Sie können Fragen stellen wie Was sind die wichtigsten Nachrichten von heute? oder Was gibt es Neues aus dem Einzelhandel in den USA?, für die öffentliche Echtzeitdaten erforderlich sind.

Fachkräfte in der Entwicklung und benutzende Personen haben keinen Zugriff auf die Rohdaten, die durch die Grounding-Funktion mit Bing-Suche zurückgegeben werden. Die Antwort enthält jedoch Zitate mit Links zu den Websites, die zur Generierung der Antwort verwendet wurden, sowie einen Link zur Bing-Abfrage, die für die Suche verwendet wurde. Diese beiden Verweise müssen in der von Microsoft bereitgestellten Form beibehalten und angezeigt werden, wie in den Nutzungs- und Darstellungsanforderungen der Bing-Suche festgelegt. Ausführliche Informationen finden Sie im Abschnitt Grounding mit Bing-Suchergebnissen anzeigen.

Wichtig

Die Verwendung von Grounding mit Bing-Suche kann Kosten verursachen. Weitere Details finden Sie auf der Preisseite.
Durch die Erstellung und Nutzung einer Ressource für Grounding mit der Bing-Suche durch einen Code-First-Ansatz, wie z. B. Azure CLI, oder die Bereitstellung über eine Bereitstellungsvorlage erklären Sie sich damit einverstanden, an die unter https://www.microsoft.com/en-us/bing/apis/grounding-legal verfügbaren Bedingungen gebunden zu sein und diese einzuhalten, die von Zeit zu Zeit aktualisiert werden können.
Wenn Sie Grounding mit Bing-Suche verwenden, werden Ihre Kundendaten nach außerhalb der Azure-Compliancegrenze an den Dienst „Grounding mit Bing-Suche“ übertragen. Grounding mit Bing-Suche unterliegt nicht den gleichen Datenverarbeitungsbestimmungen (einschließlich des Speicherorts der Verarbeitung) und hat nicht dieselben Compliancestandards und Zertifizierungen wie der Azure KI Agent-Dienst, wie in Nutzungsbedingungen für „Grounding mit Bing-Suche“ beschrieben. Es liegt in Ihrer Verantwortung, zu beurteilen, ob die Verwendung von Grounding mit Bing-Suche in Ihrem Agent Ihren Bedürfnissen und Anforderungen entspricht.

Funktionsweise von Grounding mit Bing-Suche

Die Benutzerabfrage ist die Nachricht, die ein Endbenutzer an einen Agent sendet, z. B. „Sollte ich heute einen Regenschirm mit mir nehmen? Ich befinde mich in Seattle.“ Anweisungen sind die Systemnachricht, die ein Entwickler bereitstellen kann, um Kontext zu teilen und dem KI-Modell Anweisungen zu geben, wie es verschiedene Tools verwenden oder sich verhalten soll.

Wenn ein Benutzer eine Abfrage sendet, verarbeitet die KI-Modellimplementierung des Kunden diese zuerst (mithilfe der bereitgestellten Anweisungen), um später eine Bing-Suchabfrage auszuführen (die für Entwickler sichtbar ist). Grounding mit Bing gibt relevante Suchergebnisse an die Modellimplementierung des Kunden zurück, die dann die endgültige Ausgabe generiert. Bei Verwendung von Grounding mit Bing-Suche werden nur die Bing-Suchabfrage und Ihr Ressourcenschlüssel an Bing gesendet, und es werden keine endbenutzerspezifischen Informationen eingeschlossen. Ihr Ressourcenschlüssel wird ausschließlich für Abrechnungs- und Ratenbegrenzungszwecke an Bing gesendet. Jede Bing-Suchabfrage, die für die Zwecke des Groundings generiert und an Bing übertragen wird, wird zusammen mit dem Ressourcenschlüssel außerhalb der Azure-Compliancegrenze an den Dienst „Grounding mit Bing-Suche“ übertragen. Grounding mit Bing-Suche unterliegt den Bestimmungen von Bing und hat nicht die gleichen Compliancestandards und Zertifizierungen wie der Azure KI Agent-Dienst, wie in der Nutzungsbedingungen für Grounding mit Bing-Suche beschrieben. Es liegt in Ihrer Verantwortung, zu beurteilen, ob die Verwendung von Grounding mit Bing-Suche in Ihrem Agent Ihren Bedürfnissen und Anforderungen entspricht.

Verbrauchssupport

Azure KI Foundry-Support	Python SDK	C# SDK	JavaScript SDK	REST-API	Basic Agent-Setup	Standard-Agent-Setup
✔️	✔️	✔️	✔️	✔️	✔️	✔️

Setup

Hinweis

Grounding mit der Bing-Suche funktioniert nur mit den folgenden Azure OpenAI-Modellen: gpt-3.5-turbo-0125, gpt-4-0125-preview, gpt-4-turbo-2024-04-09, gpt-4o-0513

Erstellen Sie einen Azure KI-Agenten, indem Sie die Schritte im Schnellstart ausführen.
Erstellen Sie eine „Grounding mit Bing-Suche“-Ressource. Sie müssen in Ihrem Abonnement oder ihrer Ressourcengruppe über eine Rolle owner oder contributor verfügen, um sie zu erstellen.
1. Sie können im Azure-Portal eine erstellen und die verschiedenen Felder im Erstellungsformular auswählen. Stellen Sie sicher, dass Sie diese Ressource für das Grounding mit der Bing-Suche in derselben Ressourcengruppe wie Ihren Azure KI-Agenten, Ihr KI-Projekt und andere Ressourcen erstellen.
1. Sie können auch über die Code-First-Erfahrung eine erstellen. Wenn Sie dies tun, müssen Sie Bing-Suche manuell als Azure-Ressourcenanbieter registrieren. Sie benötigen die Berechtigung zum Ausführen des /register/action-Vorgangs für den Ressourcenanbieter. Die Berechtigung ist in den Rollen Mitwirkender und Besitzer enthalten.
```
    az provider register --namespace 'Microsoft.Bing'
```
Nachdem Sie eine Ressource für Grounding mit der Bing-Suche erstellt haben, können Sie sie im Azure-Portal finden. Navigieren Sie zu der Ressourcengruppe, in der Sie die Ressource erstellt haben, und suchen Sie nach der Ressource für Grounding mit der Bing-Suche, die Sie erstellt haben.
Sie können das „Grounding mit Bing-Suche“-Tool programmgesteuert einem Agent hinzufügen, indem Sie die Codebeispiele verwenden, die oben in diesem Artikel oder im Azure KI Foundry-Portal aufgeführt sind. Wenn Sie das Portal verwenden möchten, scrollen Sie im Bildschirm Erstellen und Debuggen für Ihren Agent Bereich Setup auf der rechten Seite nach unten zu Wissen. Wählen Sie dann Hinzufügen aus.
Wählen Sie Grounding mit Bing-Suche aus, und folgen Sie den Eingabeanweisungen, um das Tool hinzuzufügen. Beachten Sie, dass Sie pro Agent nur eine hinzufügen können.
Klicken Sie hier, um neue Verbindungen hinzuzufügen. Nachdem Sie eine Verbindung hinzugefügt haben, können Sie direkt aus der vorhandenen Liste auswählen.
Wählen Sie die Ressource „Grounding mit Bing-Suche“ aus, die Sie verwenden möchten, und klicken Sie, um eine Verbindung hinzuzufügen.

So werden Ergebnisse mit Grounding mit in der Bing-Suche angezeigt

Gemäß den Nutzungsbedingungen und den Anforderungen für die Nutzung und Anzeige von Grounding mit der Bing-Suche müssen Sie sowohl Website-URLs als auch URLs von Bing-Suchanfragen in Ihrer benutzerdefinierten Oberfläche anzeigen. Sie können Website-URLs über den annotations-Parameter in der API-Antwort und Bing-Suchanfragen-URLs über die runstep-Details finden. Um die Webseite darzustellen, empfehlen wir Ihnen, den Endpunkt der Bing-Suchanfrage-URLs durch www.bing.com zu ersetzen, sodass Ihre Bing-Suchanfrage-URL wie folgt aussehen würde: „https://www.bing.com/search?q={search-Abfrage}“

run_steps = project_client.agents.list_run_steps(run_id=run.id, thread_id=thread.id)
run_steps_data = run_steps['data']
print(f"Last run step detail: {run_steps_data}")

Weitere rechtliche Überlegungen

Microsoft verwendet die Daten, die Sie bei Grounding mit Bing senden, um Microsoft-Produkte und -Dienste zu verbessern. Wenn Sie personenbezogene Daten an diesen Dienst senden, sind Sie dafür verantwortlich, eine ausreichende Zustimmung der betroffenen Personen einzuholen. Die Datenschutzbestimmungen in den Nutzungsbedingungen für Onlinedienste gelten nicht für Grounding with Bing.

Ihre Nutzung von Grounding mit der Bing-Suche unterliegt den Nutzungsbedingungen. Durch die Nutzung von Grounding mit der Bing-Suche erklären Sie sich mit diesen Nutzungsbedingungen einverstanden und verpflichten sich zu deren Einhaltung.

Schritt 1: Erstellen eines Projektclients

Erstellen Sie ein Clientobjekt, das die Verbindungszeichenfolge zum Herstellen einer Verbindung mit Ihrem KI-Projekt und anderen Ressourcen enthält.

import os
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from azure.ai.projects.models import BingGroundingTool


# Create an Azure AI Client from a connection string, copied from your Azure AI Foundry project.
# At the moment, it should be in the format "<HostName>;<AzureSubscriptionId>;<ResourceGroup>;<HubName>"
# Customer needs to login to Azure subscription via Azure CLI and set the environment variables

project_client = AIProjectClient.from_connection_string(
    credential=DefaultAzureCredential(),
    conn_str=os.environ["PROJECT_CONNECTION_STRING"],
)

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Core.TestFramework;
using NUnit.Framework;

var connectionString = TestEnvironment.AzureAICONNECTIONSTRING;

var clientOptions = new AIProjectClientOptions();

// Adding the custom headers policy
clientOptions.AddPolicy(new CustomHeadersPolicy(), HttpPipelinePosition.PerCall);
var projectClient = new AIProjectClient(connectionString, new DefaultAzureCredential(), clientOptions);

const connectionString =
  process.env["AZURE_AI_PROJECTS_CONNECTION_STRING"] || "<project connection string>";

if (!connectionString) {
  throw new Error("AZURE_AI_PROJECTS_CONNECTION_STRING must be set.");
}
const client = AIProjectsClient.fromConnectionString(
    connectionString || "",
    new DefaultAzureCredential(),
);

Schritt 2: Erstellen eines Agents mit aktiviertem Tool „Grounding mit Bing-Suche“

Um Ihrem Agenten das Tool „Grounding mit der Bing-Suche“ zur Verfügung zu stellen, verwenden Sie eine Verbindung, um das Tool zu initialisieren und es dem Agenten zuzuweisen. Sie finden Ihre Verbindung im Abschnitt Verbundene Ressourcen Ihres Projekts im Azure KI Foundry-Portal.

bing_connection = project_client.connections.get(
    connection_name=os.environ["BING_CONNECTION_NAME"]
)
conn_id = bing_connection.id

print(conn_id)

# Initialize agent bing tool and add the connection id
bing = BingGroundingTool(connection_id=conn_id)

# Create agent with the bing tool and process assistant run
with project_client:
    agent = project_client.agents.create_agent(
        model="gpt-4o",
        name="my-assistant",
        instructions="You are a helpful assistant",
        tools=bing.definitions,
        headers={"x-ms-enable-preview": "true"}
    )
    print(f"Created agent, ID: {agent.id}")

GetConnectionResponse bingConnection = await projectClient.GetConnectionsClient().GetConnectionAsync(TestEnvironment.BINGCONNECTIONNAME);
var connectionId = bingConnection.Id;

AgentsClient agentClient = projectClient.GetAgentsClient();

ToolConnectionList connectionList = new ToolConnectionList
{
    ConnectionList = { new ToolConnection(connectionId) }
};
BingGroundingToolDefinition bingGroundingTool = new BingGroundingToolDefinition(connectionList);

Response<Agent> agentResponse = await agentClient.CreateAgentAsync(
    model: "gpt-4o",
    name: "my-assistant",
    instructions: "You are a helpful assistant.",
    tools: new List<ToolDefinition> { bingGroundingTool });
Agent agent = agentResponse.Value;

const bingGroundingConnectionId = "<bingGroundingConnectionId>";
const bingTool = ToolUtility.createConnectionTool(connectionToolType.BingGrounding, [
  bingGroundingConnectionId,
]);

const agent = await client.agents.createAgent("gpt-4o", {
  name: "my-agent",
  instructions: "You are a helpful agent",
  tools: [bingTool.definition],
});
console.log(`Created agent, agent ID : ${agent.id}`);

curl $AZURE_AI_AGENTS_ENDPOINT/assistants?api-version=2024-12-01-preview \
  -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
        "instructions": "You are a helpful agent.",
        "name": "my-agent",
        "model": "gpt-4o",
        "tools": [
          {
            "type": "bing_grounding",
            "bing_grounding": {
                "connections": [
                    {
                        "connection_id": "/subscriptions/<your-subscription-id>/resourceGroups/<your-resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<your-project-name>/connections/<your-bing-connection-name>"
                    }
                ]
            }
          }
        ]
      }'

Schritt 3: Erstellen eines Threads

# Create thread for communication
thread = project_client.agents.create_thread()
print(f"Created thread, ID: {thread.id}")

# Create message to thread
message = project_client.agents.create_message(
    thread_id=thread.id,
    role="user",
    content="What is the top news today",
)
print(f"Created message, ID: {message.id}")

// Create thread for communication
Response<AgentThread> threadResponse = await agentClient.CreateThreadAsync();
AgentThread thread = threadResponse.Value;

// Create message to thread
Response<ThreadMessage> messageResponse = await agentClient.CreateMessageAsync(
    thread.Id,
    MessageRole.User,
    "How does wikipedia explain Euler's Identity?");
ThreadMessage message = messageResponse.Value;

// create a thread
const thread = await client.agents.createThread();

// add a message to thread
await client.agents.createMessage(
    thread.id, {
    role: "user",
    content: "What is the weather in Seattle?",
});

Erstellen eines Threads

curl $AZURE_AI_AGENTS_ENDPOINT/threads?api-version=2024-12-01-preview \
  -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN" \
  -H "Content-Type: application/json" \
  -d ''

Hinzufügen einer Benutzerfrage zum Thread

curl $AZURE_AI_AGENTS_ENDPOINT/threads/thread_abc123/messages?api-version=2024-12-01-preview \
  -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
      "role": "user",
      "content": "What is the weather in Seattle?"
    }'

Schritt 4: Erstellen einer Ausführung und Überprüfen der Ausgabe

Wenn Sie eine Ausführung erstellen, können Sie beobachten, dass das Modell Grounding mit der Bing-Suche verwendet, um eine Antwort auf die Frage des Benutzers bereitzustellen.

# Create and process agent run in thread with tools
run = project_client.agents.create_and_process_run(thread_id=thread.id, assistant_id=agent.id)
print(f"Run finished with status: {run.status}")

# Retrieve run step details to get Bing Search query link
# To render the webpage, we recommend you replace the endpoint of Bing search query URLs with `www.bing.com` and your Bing search query URL would look like "https://www.bing.com/search?q={search query}"
run_steps = project_client.agents.list_run_steps(run_id=run.id, thread_id=thread.id)
run_steps_data = run_steps['data']
print(f"Last run step detail: {run_steps_data}")

if run.status == "failed":
    print(f"Run failed: {run.last_error}")

# Delete the assistant when done
project_client.agents.delete_agent(agent.id)
print("Deleted agent")

# Fetch and log all messages
messages = project_client.agents.list_messages(thread_id=thread.id)
print(f"Messages: {messages}")

// Run the agent
Response<ThreadRun> runResponse = await agentClient.CreateRunAsync(thread, agent);

do
{
    await Task.Delay(TimeSpan.FromMilliseconds(500));
    runResponse = await agentClient.GetRunAsync(thread.Id, runResponse.Value.Id);
}
while (runResponse.Value.Status == RunStatus.Queued
    || runResponse.Value.Status == RunStatus.InProgress);

Response<PageableList<ThreadMessage>> afterRunMessagesResponse
    = await agentClient.GetMessagesAsync(thread.Id);
IReadOnlyList<ThreadMessage> messages = afterRunMessagesResponse.Value.Data;

// Note: messages iterate from newest to oldest, with the messages[0] being the most recent
foreach (ThreadMessage threadMessage in messages)
{
    Console.Write($"{threadMessage.CreatedAt:yyyy-MM-dd HH:mm:ss} - {threadMessage.Role,10}: ");
    foreach (MessageContent contentItem in threadMessage.ContentItems)
    {
        if (contentItem is MessageTextContent textItem)
        {
            Console.Write(textItem.Text);
        }
        else if (contentItem is MessageImageFileContent imageFileItem)
        {
            Console.Write($"<image from ID: {imageFileItem.FileId}");
        }
        Console.WriteLine();
    }
}


  // create a run
  const streamEventMessages = await client.agents.createRun(thread.id, agent.id).stream();

  for await (const eventMessage of streamEventMessages) {
    switch (eventMessage.event) {
      case RunStreamEvent.ThreadRunCreated:
        break;
      case MessageStreamEvent.ThreadMessageDelta:
        {
          const messageDelta = eventMessage.data;
          messageDelta.delta.content.forEach((contentPart) => {
            if (contentPart.type === "text") {
              const textContent = contentPart;
              const textValue = textContent.text?.value || "No text";
            }
          });
        }
        break;

      case RunStreamEvent.ThreadRunCompleted:
        break;
      case ErrorEvent.Error:
        console.log(`An error occurred. Data ${eventMessage.data}`);
        break;
      case DoneEvent.Done:
        break;
    }
  }

  // Print the messages from the agent
  const messages = await client.agents.listMessages(thread.id);

  // Messages iterate from oldest to newest
  // messages[0] is the most recent
  for (let i = messages.data.length - 1; i >= 0; i--) {
    const m = messages.data[i];
    if (isOutputOfType<MessageTextContentOutput>(m.content[0], "text")) {
      const textContent = m.content[0];
      console.log(`${textContent.text.value}`);
      console.log(`---------------------------------`);
    }
  }

Ausführen des Threads

curl $AZURE_AI_AGENTS_ENDPOINT/threads/thread_abc123/runs?api-version=2024-12-01-preview \
  -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "assistant_id": "asst_abc123",
  }'

Abrufen des Ausführungsstatus

curl $AZURE_AI_AGENTS_ENDPOINT/threads/thread_abc123/runs/run_abc123?api-version=2024-12-01-preview \
  -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN"

Abrufen der Agentantwort

curl $AZURE_AI_AGENTS_ENDPOINT/threads/thread_abc123/messages?api-version=2024-12-01-preview \
  -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN"

Nächste Schritte

Sehen Sie sich das vollständige Beispiel für Grounding mit der Bing-Suche an.

Freigeben über