Uziemienie za pomocą wyszukiwania Bing

Artykuł
02/25/2025

Obsługa funkcji wyszukiwania Bing umożliwia agentom usługi Azure AI dołączanie publicznych danych internetowych w czasie rzeczywistym podczas generowania odpowiedzi. Musisz utworzyć zasób Grounding za pomocą usługi wyszukiwania Bing, a następnie połączyć ten zasób z agentami usługi Azure AI. Gdy użytkownik wysyła zapytanie, agenci usługi Azure AI decydują, czy należy korzystać z funkcji wyszukiwania Bing przy użyciu funkcji groundingu. Jeśli tak, usługa Bing będzie używać usługi Bing do przeszukiwania publicznych danych internetowych i zwracania odpowiednich fragmentów. Na koniec agenci usługi Azure AI będą używać zwróconych fragmentów w celu wygenerowania odpowiedzi.

Możesz zadawać pytania, takie jak "jakie są najważniejsze wiadomości dzisiaj" lub "jaka jest najnowsza aktualizacja w branży detalicznej w USA?", które wymagają danych publicznych w czasie rzeczywistym.

Deweloperzy i użytkownicy końcowi nie mają dostępu do nieprzetworzonej zawartości zwracanej z funkcji Wyszukiwania Bing w warstwie Grounding. Odpowiedź zawiera jednak cytaty z linkami do witryn internetowych używanych do generowania odpowiedzi oraz link do zapytania Bing używanego do wyszukiwania. Te dwa odwołania muszą być zachowywane i wyświetlane w dokładnym formularzu dostarczonym przez firmę Microsoft zgodnie z wymaganiami dotyczącymi używania i wyświetlania wyszukiwania Bing. Aby uzyskać szczegółowe informacje, zobacz sekcję Jak wyświetlić sekcję Grounding with Bing Search results (Podstawy za pomocą wyników wyszukiwania Bing).

Ważne

Użycie funkcji Grounding with Bing Search może wiązać się z kosztami. Zobacz stronę cen, aby zapoznać się ze szczegółowymi informacjami.
Tworząc zasób grounding z wyszukiwaniem Bing i używając go za pomocą środowiska opartego na kodzie, takiego jak interfejs wiersza polecenia platformy Azure lub wdrażając za pośrednictwem szablonu wdrożenia, zgadzasz się na powiązanie z warunkami dostępnymi w witrynie i zgodność z warunkami dostępnymi od https://www.microsoft.com/en-us/bing/apis/grounding-legalczasu do czasu.
W przypadku korzystania z funkcji Grounding with Bing Search dane klientów są przesyłane poza granicą zgodności platformy Azure do rozwiązania Grounding with Bing usługa wyszukiwania. Podstawy wyszukiwania Bing nie podlegają tym samym warunkom przetwarzania danych (w tym lokalizacji przetwarzania) i nie mają tych samych standardów zgodności i certyfikatów co usługa agenta sztucznej inteligencji platformy Azure, zgodnie z opisem w artykule Uziemienie warunków użytkowania wyszukiwania Bing. Twoim zadaniem jest sprawdzenie, czy użycie funkcji Grounding z wyszukiwaniem Bing w agencie spełnia Twoje wymagania i wymagania.

Jak działa funkcja uziemienia za pomocą wyszukiwania Bing

Zapytanie użytkownika to komunikat, który użytkownik końcowy wysyła do agenta, na przykład "czy dziś powinienem wziąć ze sobą parasol? Jestem w Seattle." Instrukcje to komunikat systemowy, który deweloper może udostępnić kontekst i przekazać instrukcje dotyczące modelu sztucznej inteligencji dotyczące używania różnych narzędzi lub zachowania.

Gdy użytkownik wysyła zapytanie, wdrożenie modelu sztucznej inteligencji klienta najpierw przetwarza je (korzystając z podanych instrukcji), aby później wykonać zapytanie wyszukiwania Bing (które jest widoczne dla deweloperów). Uziemienie za pomocą usługi Bing zwraca odpowiednie wyniki wyszukiwania do wdrożenia modelu klienta, co spowoduje wygenerowanie końcowych danych wyjściowych. W przypadku korzystania z funkcji Grounding with Bing Search tylko zapytanie wyszukiwania Bing i klucz zasobu są wysyłane do usługi Bing, a żadne informacje specyficzne dla użytkownika końcowego nie są uwzględniane. Klucz zasobu jest wysyłany do usługi Bing wyłącznie na potrzeby rozliczeń i ograniczania szybkości. Wszystkie zapytania wyszukiwania Bing, które są generowane i wysyłane do usługi Bing na potrzeby uziemienia, są przenoszone wraz z kluczem zasobu poza granicą zgodności platformy Azure do rozwiązania Grounding with Bing usługa wyszukiwania. Podstawy wyszukiwania Bing podlegają warunkom usługi Bing i nie mają takich samych standardów zgodności i certyfikatów, jak usługa Azure AI Agent Service, zgodnie z opisem w artykule Uziemienie warunków użytkowania wyszukiwania Bing. Twoim zadaniem jest sprawdzenie, czy użycie funkcji Grounding with Bing Search w agencie spełnia Twoje wymagania i wymagania.

Obsługa użycia

Pomoc techniczna dotycząca znajdowania sztucznej inteligencji platformy Azure	Zestaw SDK dla języka Python	Zestaw SDK języka C#	Zestaw SDK dla języka JavaScript	Interfejs API REST	Konfiguracja agenta podstawowego	Konfiguracja agenta standardowego
✔️	✔️	✔️	✔️	✔️	✔️	✔️

Ustawienia

Uwaga

Uziemienie za pomocą funkcji wyszukiwania Bing działa tylko z następującymi modelami usługi Azure OpenAI: gpt-3.5-turbo-0125, , gpt-4-0125-preview, , gpt-4-turbo-2024-04-09gpt-4o-0513

Utwórz agenta usługi Azure AI, wykonując kroki opisane w przewodniku Szybki start.
Utwórz zasób uziemienia za pomocą usługi wyszukiwania Bing. Aby ją utworzyć, musisz mieć owner rolę lub contributor w subskrypcji lub grupie zasobów.
1. Możesz utworzyć je w witrynie Azure Portal i wybrać różne pola w formularzu tworzenia. Upewnij się, że utworzysz ten zasób Grounding z wyszukiwaniem Bing w tej samej grupie zasobów co agent usługi Azure AI, projekt sztucznej inteligencji i inne zasoby.
1. Możesz również utworzyć jedną za pomocą środowiska code-first. Jeśli tak, musisz ręcznie zarejestrować wyszukiwanie Bing jako dostawcę zasobów platformy Azure. Musisz mieć uprawnienie do wykonania operacji /register/action dla dostawcy zasobów. Uprawnienie jest uwzględniane w rolach Współautor i Właściciel .
```
    az provider register --namespace 'Microsoft.Bing'
```
Po utworzeniu zasobu Grounding with Bing Search można go znaleźć w witrynie Azure Portal. Przejdź do grupy zasobów, w której utworzono zasób, wyszukaj utworzony zasób Grounding za pomocą wyszukiwania Bing.
Narzędzie Grounding with Bing Search można dodać do agenta programowo przy użyciu przykładów kodu wymienionych w górnej części tego artykułu lub portalu usługi Azure AI Foundry. Jeśli chcesz użyć portalu, na ekranie Tworzenie i debugowanie agenta przewiń w dół okienko Konfiguracja po prawej stronie. Następnie wybierz pozycję Dodaj.
Wybierz pozycję Uziemienie za pomocą wyszukiwania Bing i postępuj zgodnie z monitami, aby dodać narzędzie. Uwaga: można dodać tylko jeden agent.
Kliknij, aby dodać nowe połączenia. Po dodaniu połączenia możesz bezpośrednio wybrać z istniejącej listy.
Wybierz zasób Grounding with Bing Search , którego chcesz użyć, a następnie kliknij, aby dodać połączenie.

Jak wyświetlić uziemienie za pomocą wyników wyszukiwania Bing

Zgodnie z warunkami użytkowania i wyświetlania usługi Bing należy wyświetlić zarówno adresy URL witryny internetowej, jak i adresy URL zapytań wyszukiwania Bing w interfejsie niestandardowym. Adresy URL witryn internetowych można znaleźć za pomocą annotations parametru w odpowiedzi interfejsu API i adresach URL zapytań wyszukiwania Bing za pomocą runstep szczegółów. Aby renderować stronę internetową, zalecamy zastąpienie punktu końcowego adresów URL kwerend wyszukiwania Bing ciągiem www.bing.com , a adres URL zapytania wyszukiwania Bing będzie wyglądać następująco: "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}")

Inne zagadnienia prawne

Firma Microsoft będzie używać danych wysyłanych do platformy Grounding z usługą Bing w celu ulepszania produktów i usług firmy Microsoft. W przypadku wysyłania danych osobowych do tej usługi użytkownik jest odpowiedzialny za uzyskanie wystarczającej zgody podmiotów danych. Warunki ochrony danych w warunkach usług online nie mają zastosowania do uziemienia w usłudze Bing.

Korzystanie z platformy Grounding z usługą wyszukiwania Bing podlega warunkom użytkowania. Korzystając z funkcji Grounding with Bing Search, użytkownik zgadza się być powiązany i przestrzegać niniejszych warunków użytkowania.

Krok 1. Tworzenie klienta projektu

Utwórz obiekt klienta, który będzie zawierać parametry połączenia na potrzeby nawiązywania połączenia z projektem sztucznej inteligencji i innymi zasobami.

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(),
);

Krok 2. Tworzenie agenta z włączonym narzędziem wyszukiwania Uziemienie za pomocą usługi Bing

Aby udostępnić agentowi narzędzie wyszukiwania Grounding with Bing, użyj połączenia w celu zainicjowania narzędzia i dołącz go do agenta. Połączenie można znaleźć w sekcji połączonych zasobów projektu w portalu usługi Azure AI Foundry.

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>"
                    }
                ]
            }
          }
        ]
      }'

Krok 3. Tworzenie wątku

# 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?",
});

Tworzenie wątku

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 ''

Dodawanie pytania użytkownika do wątku

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?"
    }'

Krok 4. Tworzenie przebiegu i sprawdzanie danych wyjściowych

Utwórz przebieg i zwróć uwagę, że model używa narzędzia Grounding with Bing Search w celu udzielenia odpowiedzi na pytanie użytkownika.

# 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(`---------------------------------`);
    }
  }

Uruchamianie wątku

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",
  }'

Pobieranie stanu przebiegu

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

Pobieranie odpowiedzi agenta

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

Następne kroki

Zobacz pełną próbkę funkcji Grounding with Bing Search (Uziemięcie za pomocą wyszukiwania Bing).

Udostępnij za pośrednictwem