Erdung von Agenten mit Bing-Suchwerkzeugen

Die folgenden Beispiele zeigen, wie Sie einen Agent mit Grounding mit Bing Search-Tools erstellen und wie der Agent zum Beantworten von Benutzerabfragen verwendet wird.

Grundlagen mit Bing-Suche

from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
    PromptAgentDefinition,
    BingGroundingTool,
    BingGroundingSearchToolParameters,
    BingGroundingSearchConfiguration,
)

# Format: "https://resource_name.ai.azure.com/api/projects/project_name"
PROJECT_ENDPOINT = "your_project_endpoint"
BING_CONNECTION_NAME = "my-bing-connection"

# Create clients to call Foundry API
project = AIProjectClient(
    endpoint=PROJECT_ENDPOINT,
    credential=DefaultAzureCredential(),
)
openai = project.get_openai_client()

# Get connection ID from connection name
bing_connection = project.connections.get(BING_CONNECTION_NAME)

agent = project.agents.create_version(
    agent_name="MyAgent",
    definition=PromptAgentDefinition(
        model="gpt-4.1-mini",
        instructions="You are a helpful assistant.",
        tools=[
            BingGroundingTool(
                bing_grounding=BingGroundingSearchToolParameters(
                    search_configurations=[
                        BingGroundingSearchConfiguration(
                            project_connection_id=bing_connection.id
                        )
                    ]
                )
            )
        ],
    ),
    description="You are a helpful agent.",
)
print(f"Agent created (id: {agent.id}, name: {agent.name}, version: {agent.version})")

stream_response = openai.responses.create(
    stream=True,
    tool_choice="required",
    input="What is today's date and weather in Seattle?",
    extra_body={"agent_reference": {"name": agent.name, "type": "agent_reference"}},
)

for event in stream_response:
    if event.type == "response.created":
        print(f"Follow-up response created with ID: {event.response.id}")
    elif event.type == "response.output_text.delta":
        print(f"Delta: {event.delta}")
    elif event.type == "response.text.done":
        print(f"\nFollow-up response done!")
    elif event.type == "response.output_item.done":
        if event.item.type == "message":
            item = event.item
            if item.content[-1].type == "output_text":
                text_content = item.content[-1]
                for annotation in text_content.annotations:
                    if annotation.type == "url_citation":
                        print(f"URL Citation: {annotation.url}")
    elif event.type == "response.completed":
        print(f"\nFollow-up completed!")
        print(f"Full response: {event.response.output_text}")

Funktionsweise dieses Codes

In diesem Beispiel wird mit dem Bing Search-Tool ein Agent mit Grounding erstellt, der Echtzeitinformationen aus dem Web abrufen kann. Wenn Sie den Code ausführen:

1. Sie erstellt eine AIProjectClient und authentifiziert sich mithilfe Ihrer Azure Anmeldeinformationen.
2. Erstellt einen Agenten mit dem Bing-Grounding-Tool, das mithilfe Ihrer Bing-Verbindung konfiguriert wird.
3. Sendet eine Abfrage mit der Frage nach aktuellem Datum und Wetter in Seattle.
4. Der Agent verwendet das Bing-Erdungstool, um das Web zu durchsuchen und die Antwort zu streamen.
5. Extrahiert und zeigt URL-Zitate aus den Suchergebnissen an.

Erforderliche Eingaben

• Aktualisieren Sie die PROJECT_ENDPOINT Und BING_CONNECTION_NAME Konstanten im Code mit Ihren Werten.
• Azure Anmeldeinformationen, die für DefaultAzureCredential konfiguriert sind.

Erwartete Ausgabe

Agent created (id: asst_abc123, name: MyAgent, version: 1)
Follow-up response created with ID: resp_xyz789
Delta: Today
Delta: 's date
Delta:  is December 12, 2025...
Follow-up response done!
URL Citation: https://www.weather.gov/seattle/
Follow-up completed!
Full response: Today's date is December 12, 2025, and the weather in Seattle is...

Einführung in die benutzerdefinierte Bing-Suche (Vorschau)

from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
    PromptAgentDefinition,
    BingCustomSearchPreviewTool,
    BingCustomSearchToolParameters,
    BingCustomSearchConfiguration,
)

# Format: "https://resource_name.ai.azure.com/api/projects/project_name"
PROJECT_ENDPOINT = "your_project_endpoint"
CUSTOM_SEARCH_CONNECTION_NAME = "my-custom-search-connection"
CUSTOM_SEARCH_INSTANCE_NAME = "my-custom-search-instance"

# Create clients to call Foundry API
project = AIProjectClient(
    endpoint=PROJECT_ENDPOINT,
    credential=DefaultAzureCredential(),
)
openai = project.get_openai_client()

# Get connection ID from connection name
bing_custom_connection = project.connections.get(CUSTOM_SEARCH_CONNECTION_NAME)

bing_custom_search_tool = BingCustomSearchPreviewTool(
    bing_custom_search_preview=BingCustomSearchToolParameters(
        search_configurations=[
            BingCustomSearchConfiguration(
                project_connection_id=bing_custom_connection.id,
                instance_name=CUSTOM_SEARCH_INSTANCE_NAME,
            )
        ]
    )
)

agent = project.agents.create_version(
    agent_name="MyAgent",
    definition=PromptAgentDefinition(
        model="gpt-4.1-mini",
        instructions="""You are a helpful agent that can use Bing Custom Search tools to assist users. 
        Use the available Bing Custom Search tools to answer questions and perform tasks.""",
        tools=[bing_custom_search_tool],
    ),
)
print(f"Agent created (id: {agent.id}, name: {agent.name}, version: {agent.version})")

user_input = input(
    "Enter your question for the Bing Custom Search agent " "(e.g., 'Tell me more about foundry agent service'): \n"
)

# Send initial request that will trigger the Bing Custom Search tool
stream_response = openai.responses.create(
    stream=True,
    input=user_input,
    extra_body={"agent_reference": {"name": agent.name, "type": "agent_reference"}},
)

for event in stream_response:
    if event.type == "response.created":
        print(f"Follow-up response created with ID: {event.response.id}")
    elif event.type == "response.output_text.delta":
        print(f"Delta: {event.delta}")
    elif event.type == "response.text.done":
        print(f"\nFollow-up response done!")
    elif event.type == "response.output_item.done":
        if event.item.type == "message":
            item = event.item
            if item.content[-1].type == "output_text":
                text_content = item.content[-1]
                for annotation in text_content.annotations:
                    if annotation.type == "url_citation":
                        print(
                            f"URL Citation: {annotation.url}, "
                            f"Start index: {annotation.start_index}, "
                            f"End index: {annotation.end_index}"
                        )
    elif event.type == "response.completed":
        print(f"\nFollow-up completed!")
        print(f"Full response: {event.response.output_text}")

Funktionsweise dieses Codes

Dies ist ein Beispiel für die Erstellung eines Agenten mit dem Bing Custom Search Tool, der in einer konfigurierbaren Menge öffentlicher Web-Domains sucht. Wenn Sie den Code ausführen:

1. Sie erstellt eine AIProjectClient und authentifiziert sich mithilfe Ihrer Azure Anmeldeinformationen.
2. Erstellt einen Agent mit dem Bing Custom Search-Tool, das mithilfe Ihrer benutzerdefinierten Suchinstanz konfiguriert ist.
3. Aufforderungen an den Benutzer, die nach bestimmten Themen innerhalb Ihrer konfigurierten Bereiche fragen.
4. Der Agent verwendet das Bing Custom Search-Tool, um nur Ihre angegebenen Domänen zu durchsuchen und die Antwort zu streamen.
5. Extrahiert und zeigt URL-Zitate mit Start- und Endpositionen aus den benutzerdefinierten Suchergebnissen an.

Erforderliche Eingaben

• Aktualisieren Sie die PROJECT_ENDPOINT, CUSTOM_SEARCH_CONNECTION_NAMEund CUSTOM_SEARCH_INSTANCE_NAME Konstanten im Code mit Ihren Werten.
• Azure Anmeldeinformationen, die für DefaultAzureCredential konfiguriert sind.
• Benutzereingabe zur Laufzeit.

Erwartete Ausgabe

Agent created (id: asst_abc123, name: MyAgent, version: 1)
Enter your question for the Bing Custom Search agent (e.g., 'Tell me more about foundry agent service'):
Tell me more about foundry agent service
Follow-up response created with ID: resp_xyz789
Delta: Microsoft
Delta:  Foundry
Delta:  Agent Service...
Follow-up response done!
URL Citation: https://learn.microsoft.com/azure/ai-foundry/agents, Start index: 45, End index: 120
Follow-up completed!
Full response: Microsoft Foundry Agent Service enables you to build...

Die folgenden C#-Beispiele veranschaulichen, wie Sie einen Agenten mit dem Grounding-Tool für Bing-Suche erstellen und wie der Agent verwendet wird, um Benutzeranfragen zu beantworten. In diesen Beispielen werden synchrone Aufrufe zur Vereinfachung verwendet. Asynchrone Beispiele finden Sie in den C#-Beispielen agenttools.

Um Ihrem Agent die Verwendung der Bing-Such-API zu ermöglichen, verwenden Sie BingGroundingTool.

Grundlagen mit Bing-Suche

// Format: "https://resource_name.ai.azure.com/api/projects/project_name"
var projectEndpoint = "your_project_endpoint";
var bingConnectionName = "my-bing-connection";

// Create project client to call Foundry API
AIProjectClient projectClient = new(
    endpoint: new Uri(projectEndpoint),
    tokenProvider: new DefaultAzureCredential());

// Get connection ID from connection name
AIProjectConnection bingConnection = projectClient.Connections.GetConnection(connectionName: bingConnectionName);

// Create the agent version with Bing grounding tool
BingGroundingTool bingGroundingAgentTool = new(new BingGroundingSearchToolOptions(
  searchConfigurations: [new BingGroundingSearchConfiguration(projectConnectionId: bingConnection.Id)]
    )
);
DeclarativeAgentDefinition agentDefinition = new(model: "gpt-4.1-mini")
{
    Instructions = "You are a helpful agent.",
    Tools = { bingGroundingAgentTool, }
};
AgentVersion agentVersion = projectClient.AgentAdministrationClient.CreateAgentVersion(
    agentName: "myAgent",
    options: new(agentDefinition));

// Output the agent version info
ProjectResponsesClient responseClient = projectClient.ProjectOpenAIClient.GetProjectResponsesClientForAgent(agentVersion.Name);

ResponseResult response = responseClient.CreateResponse("How does wikipedia explain Euler's Identity?");

// Extract and format URL citation annotations
string citation = "";
foreach (ResponseItem item in response.OutputItems)
{
    if (item is MessageResponseItem messageItem)
    {
        foreach (ResponseContentPart content in messageItem.Content)
        {
            foreach (ResponseMessageAnnotation annotation in content.OutputTextAnnotations)
            {
                if (annotation is UriCitationMessageAnnotation uriAnnotation)
                {
                    citation = $" [{uriAnnotation.Title}]({uriAnnotation.Uri})";
                }
            }
        }
    }
}

// Validate and print the response
Assert.That(response.Status, Is.EqualTo(ResponseStatus.Completed));
Console.WriteLine($"{response.GetOutputText()}{citation}");

// Clean up resources by deleting the agent version
projectClient.AgentAdministrationClient.DeleteAgentVersion(agentName: agentVersion.Name, agentVersion: agentVersion.Version);

Funktionsweise dieses Codes

In diesem Beispiel wird ein Agent erstellt, der das Grounding mit Bing Search-Tool verwendet und die synchrone Reaktionsbehandlung veranschaulicht. Wenn Sie den Code ausführen:

1. Er erstellt einen AIProjectClient mithilfe Ihres Projektendpunkts.
2. Ruft die Bing-Verbindungskonfiguration aus Ihrem Projekt ab.
3. Erstellt einen Agenten mit dem konfigurierten Bing-Grundlagentool.
4. Sendet eine Abfrage, die fragt, wie Wikipedia Eulers Identität erklärt.
5. Der Agent verwendet das Bing-Suchwerkzeug, um im Internet zu suchen und liefert formatierte Ergebnisse mit URL-Zitaten zurück.
6. Bereinigt durch Löschen der Agentversion.

Erforderliche Eingaben

• Aktualisieren Sie die projectEndpoint Und bingConnectionName Konstanten im Code mit Ihren Werten.
• Azure Anmeldeinformationen, die für DefaultAzureCredential konfiguriert sind.

Erwartete Ausgabe

Euler's identity is considered one of the most elegant equations in mathematics... [Euler's identity - Wikipedia](https://en.wikipedia.org/wiki/Euler%27s_identity)

Verwendung von Bing in Streamingszenarien

// Format: "https://resource_name.ai.azure.com/api/projects/project_name"
var projectEndpoint = "your_project_endpoint";
var bingConnectionName = "my-bing-connection";

// Create project client to call Foundry API
AIProjectClient projectClient = new(
    endpoint: new Uri(projectEndpoint),
    tokenProvider: new DefaultAzureCredential());

// Get connection ID from connection name
AIProjectConnection bingConnection = projectClient.Connections.GetConnection(connectionName: bingConnectionName);

// Create the agent version with Bing grounding tool
BingGroundingTool bingGroundingAgentTool = new(new BingGroundingSearchToolOptions(
  searchConfigurations: [new BingGroundingSearchConfiguration(projectConnectionId: bingConnection.Id)]
    )
);
DeclarativeAgentDefinition agentDefinition = new(model: "gpt-4.1-mini")
{
    Instructions = "You are a helpful agent.",
    Tools = { bingGroundingAgentTool }
};
AgentVersion agentVersion = projectClient.AgentAdministrationClient.CreateAgentVersion(
    agentName: "myAgent",
    options: new(agentDefinition));

// Stream the response from the agent version
ProjectResponsesClient responseClient = projectClient.ProjectOpenAIClient.GetProjectResponsesClientForAgent(agentVersion.Name);

string annotation = "";
string text = "";

// Parse the streaming response and output the results
foreach (StreamingResponseUpdate streamResponse in responseClient.CreateResponseStreaming("How does wikipedia explain Euler's Identity?"))
{
    if (streamResponse is StreamingResponseCreatedUpdate createUpdate)
    {
        Console.WriteLine($"Stream response created with ID: {createUpdate.Response.Id}");
    }
    else if (streamResponse is StreamingResponseOutputTextDeltaUpdate textDelta)
    {
        Console.WriteLine($"Delta: {textDelta.Delta}");
    }
    else if (streamResponse is StreamingResponseOutputTextDoneUpdate textDoneUpdate)
    {
        text = textDoneUpdate.Text;
    }
    else if (streamResponse is StreamingResponseOutputItemDoneUpdate itemDoneUpdate)
    {
        if (annotation.Length == 0)
        {
            // Extract and format URL citation annotations
            if (itemDoneUpdate.Item is MessageResponseItem messageItem)
            {
                foreach (ResponseContentPart content in messageItem.Content)
                {
                    foreach (ResponseMessageAnnotation messageAnnotation in content.OutputTextAnnotations)
                    {
                        if (messageAnnotation is UriCitationMessageAnnotation uriAnnotation)
                        {
                            annotation = $" [{uriAnnotation.Title}]({uriAnnotation.Uri})";
                        }
                    }
                }
            }
        }
    }
    else if (streamResponse is StreamingResponseErrorUpdate errorUpdate)
    {
        throw new InvalidOperationException($"The stream has failed: {errorUpdate.Message}");
    }
}
Console.WriteLine($"{text}{annotation}");

// Clean up resources by deleting the agent version
projectClient.AgentAdministrationClient.DeleteAgentVersion(agentName: agentVersion.Name, agentVersion: agentVersion.Version);

Funktionsweise dieses Codes

In diesem Beispiel wird ein Agent mit Grounding mithilfe des Bing-Suchtools erstellt und die Handhabung von Streaming-Antworten veranschaulicht. Wenn Sie den Code ausführen:

1. Er erstellt einen AIProjectClient mithilfe Ihres Projektendpunkts.
2. Ruft die Bing-Verbindungskonfiguration aus Ihrem Projekt ab.
3. Erstellt einen Agenten mit dem konfigurierten Bing-Grundlagentool.
4. Sendet eine Abfrage, die fragt, wie Wikipedia Eulers Identität erklärt.
5. Der Agent verwendet das Bing-Erdungstool und streamt die Antwort in Echtzeit.
6. Verarbeitet Streamingereignisse, einschließlich Delta-Textaktualisierungen und Zitatextraktion.
7. Bereinigt durch Löschen der Agentversion.

Erforderliche Eingaben

• Aktualisieren Sie die projectEndpoint Und bingConnectionName Konstanten im Code mit Ihren Werten.
• Azure Anmeldeinformationen, die für DefaultAzureCredential konfiguriert sind.

Erwartete Ausgabe

Stream response created with ID: resp_xyz789
Delta: Euler
Delta: 's
Delta:  Identity
Delta:  is one of the most...
Euler's Identity is one of the most elegant equations in mathematics... [Euler's identity - Wikipedia](https://en.wikipedia.org/wiki/Euler%27s_identity)

Die folgenden REST-API-Beispiele zeigen, wie Sie die Grounding-Funktion zusammen mit Bing Search und Bing Custom Search (Vorschau) verwenden können, um Benutzeranfragen zu beantworten.

Grundlagen mit Bing-Suche

Authentifizierungseinrichtung

Konfigurieren Sie vor dem Ausführen von REST-API-Aufrufen die Authentifizierung:

1. Festlegen von Umgebungsvariablen:

   • FOUNDRY_PROJECT_ENDPOINT: Die URL des Projekt-Endpunkts von Foundry.
   • FOUNDRY_MODEL_DEPLOYMENT_NAME: Der Name des bereitgestellten Modells.
   • BING_PROJECT_CONNECTION_ID: Ihr Grounding mit Bing Search-Projektverbindungs-ID.

2. Erhalt eines Bearer Tokens

   export AGENT_TOKEN=$(az account get-access-token --scope "https://ai.azure.com/.default" --query accessToken -o tsv)
   

   curl --request POST \
     --url "$FOUNDRY_PROJECT_ENDPOINT/openai/v1/responses" \
     -H "Authorization: Bearer $AGENT_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
     "model": "'$FOUNDRY_MODEL_DEPLOYMENT_NAME'",
     "input": "How does Wikipedia explain Euler\u0027s identity?",
     "tool_choice": "required",
     "tools": [
       {
         "type": "bing_grounding",
         "bing_grounding": {
           "search_configurations": [
             {
               "project_connection_id": "'$BING_PROJECT_CONNECTION_ID'",
               "count": 7,
               "market": "en-US",
               "set_lang": "en",
               "freshness": "7d"
             }
           ]
         }
       }
     ]
   }'
   

Funktionsweise dieses Codes

Diese REST-API-Anforderung erstellt eine Antwort mithilfe von Grounding mit Bing Search. Die Anforderung:

1. Sendet eine POST-Anforderung an den Endpunkt für Foundry-Antworten.
2. Enthält die Modellbereitstellung und Benutzereingabe im Anforderungstext.
3. Konfiguriert das Bing-Grundlagen-Tool mit Suchparametern (Anzahl, Markt, Sprache, Aktualität).
4. Gibt eine Antwort mit Websuchergebnissen und Zitaten zurück.

Erforderliche Eingaben

• Umgebungsvariablen: FOUNDRY_PROJECT_ENDPOINT, AGENT_TOKEN, FOUNDRY_MODEL_DEPLOYMENT_NAME, BING_PROJECT_CONNECTION_ID.
• Gültiges Bearertoken mit entsprechenden Berechtigungen.

Erwartete Ausgabe

JSON-Antwort mit:

• id: Antwort-ID
• output_text: Generierter Text mit fundierten Informationen
• citations: Array von URL-Zitaten, die zum Generieren der Antwort verwendet werden

Einführung in die benutzerdefinierte Bing-Suche (Vorschau)

curl --request POST \
  --url "$FOUNDRY_PROJECT_ENDPOINT/openai/v1/responses" \
  -H "Authorization: Bearer $AGENT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "'$FOUNDRY_MODEL_DEPLOYMENT_NAME'",
  "input": "How does Wikipedia explain Euler\u0027s identity?",
  "tool_choice": "required",
  "tools": [
    {
      "type": "bing_custom_search_preview",
      "bing_custom_search_preview": {
        "search_configurations": [
          {
            "project_connection_id": "'$BING_CUSTOM_SEARCH_PROJECT_CONNECTION_ID'",
            "instance_name": "'$BING_CUSTOM_SEARCH_INSTANCE_NAME'",
            "count": 7,
            "market": "en-US",
            "set_lang": "en",
            "freshness": "7d"
          }
        ]
      }
    }
  ]
}'

Funktionsweise dieses Codes

Diese REST-API-Anforderung generiert eine Antwort unter Verwendung von Grounding mit der Benutzerdefinierten Bing-Suche. Die Anforderung:

1. Sendet eine POST-Anforderung an den Endpunkt für Foundry-Antworten.
2. Enthält die Modellbereitstellung und Benutzereingabe im Anforderungstext.
3. Konfiguriert das Bing Custom Search-Tool mit Ihrem Instanznamen und Suchparametern.
4. Gibt eine Antwort mit benutzerdefinierten Suchergebnissen zurück, die auf Ihre konfigurierten Domänen beschränkt sind.

Erforderliche Eingaben

• Umgebungsvariablen: FOUNDRY_PROJECT_ENDPOINT, AGENT_TOKEN, FOUNDRY_MODEL_DEPLOYMENT_NAME, BING_CUSTOM_SEARCH_PROJECT_CONNECTION_IDBING_CUSTOM_SEARCH_INSTANCE_NAME
• Gültiges Bearertoken mit entsprechenden Berechtigungen.
• Bing Custom Search-Instanz, die bereits mit Zieldomänen konfiguriert ist

Erwartete Ausgabe

JSON-Antwort mit:

• id: Antwort-ID
• output_text: Generierter Text mit Informationen aus Ihrem benutzerdefinierten Domänensatz
• citations: Array von URL-Zitaten aus Ihren konfigurierten Domänen

Die folgenden TypeScript-Beispiele veranschaulichen, wie Sie einen Agenten mit Grounding und Bing Search sowie Grounding und Bing Custom Search (Vorschau)-Tools erstellen und wie dieser Agent zum Beantworten von Benutzeranfragen verwendet werden kann. JavaScript-Beispiele finden Sie in den JavaScript-Beispielen agent-Tools im Azure SDK für JavaScript-Repository auf GitHub.

Grundlagen mit Bing-Suche

import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";

// Format: "https://resource_name.ai.azure.com/api/projects/project_name"
const PROJECT_ENDPOINT = "your_project_endpoint";
const BING_CONNECTION_NAME = "my-bing-connection";

export async function main(): Promise<void> {
  // Create clients to call Foundry API
  const project = new AIProjectClient(PROJECT_ENDPOINT, new DefaultAzureCredential());
  const openai = project.getOpenAIClient();

  // Get connection ID from connection name
  const bingConnection = await project.connections.get(BING_CONNECTION_NAME);

  const agent = await project.agents.createVersion("MyBingGroundingAgent", {
    kind: "prompt",
    model: "gpt-4.1-mini",
    instructions: "You are a helpful assistant.",
    tools: [
      {
        type: "bing_grounding",
        bing_grounding: {
          search_configurations: [
            {
              project_connection_id: bingConnection.id,
            },
          ],
        },
      },
    ],
  });
  console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

  // Send request that requires current information from the web
  const streamResponse = await openai.responses.create(
    {
      input: "What is today's date and weather in Seattle?",
      stream: true,
    },
    {
      body: {
        agent: { name: agent.name, type: "agent_reference" },
        tool_choice: "required",
      },
    },
  );

  // Process the streaming response
  for await (const event of streamResponse) {
    if (event.type === "response.created") {
      console.log(`Follow-up response created with ID: ${event.response.id}`);
    } else if (event.type === "response.output_text.delta") {
      process.stdout.write(event.delta);
    } else if (event.type === "response.output_text.done") {
      console.log("\n\nFollow-up response done!");
    } else if (event.type === "response.output_item.done") {
      if (event.item.type === "message") {
        const item = event.item;
        if (item.content && item.content.length > 0) {
          const lastContent = item.content[item.content.length - 1];
          if (lastContent.type === "output_text" && lastContent.annotations) {
            for (const annotation of lastContent.annotations) {
              if (annotation.type === "url_citation") {
                console.log(
                  `URL Citation: ${annotation.url}, Start index: ${annotation.start_index}, End index: ${annotation.end_index}`,
                );
              }
            }
          }
        }
      }
    } else if (event.type === "response.completed") {
      console.log("\nFollow-up completed!");
    }
  }

  // Clean up resources by deleting the agent version
  // This prevents accumulation of unused resources in your project
  console.log("\nCleaning up resources...");
  await project.agents.deleteVersion(agent.name, agent.version);
  console.log("Agent deleted");

  console.log("\nBing grounding agent sample completed!");
}

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

Funktionsweise dieses Codes

In diesem Beispiel wird mit dem Bing Search-Tool ein Agent mit Grounding erstellt, der Echtzeitinformationen aus dem Web abrufen kann. Wenn Sie den Code ausführen:

1. Sie erstellt eine AIProjectClient und authentifiziert sich mithilfe Ihrer Azure Anmeldeinformationen.
2. Erstellt einen Agenten mit dem Bing-Grounding-Tool, das mithilfe Ihrer Bing-Verbindung konfiguriert wird.
3. Sendet eine Abfrage, die nach dem aktuellen Datum und wetter in Seattle fragt, wobei die Toolauswahl auf "erforderlich" festgelegt ist.
4. Der Agent verwendet das Bing-Erdungstool, um das Web zu durchsuchen und die Antwort zu streamen.
5. Verarbeitet Streamingereignisse und extrahiert URL-Zitate mit ihren Positionen im Text.
6. Bereinigt durch Löschen der Agentversion.

Erforderliche Eingaben

• Aktualisieren Sie die PROJECT_ENDPOINT Und BING_CONNECTION_NAME Konstanten im Code mit Ihren Werten.
• Azure Anmeldeinformationen, die für DefaultAzureCredential konfiguriert sind.

Erwartete Ausgabe

Agent created (id: asst_abc123, name: MyBingGroundingAgent, version: 1)
Follow-up response created with ID: resp_xyz789
Today's date is December 12, 2025, and the weather in Seattle...

Follow-up response done!
URL Citation: https://www.weather.gov/seattle/, Start index: 45, End index: 120

Follow-up completed!

Cleaning up resources...
Agent deleted

Bing grounding agent sample completed!

Einführung in die benutzerdefinierte Bing-Suche (Vorschau)

import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";
import * as readline from "readline";

// Format: "https://resource_name.ai.azure.com/api/projects/project_name"
const PROJECT_ENDPOINT = "your_project_endpoint";
const CUSTOM_SEARCH_CONNECTION_NAME = "my-custom-search-connection";
const CUSTOM_SEARCH_INSTANCE_NAME = "my-custom-search-instance";

export async function main(): Promise<void> {
  // Create clients to call Foundry API
  const project = new AIProjectClient(PROJECT_ENDPOINT, new DefaultAzureCredential());
  const openai = project.getOpenAIClient();

  // Get connection ID from connection name
  const bingCustomConnection = await project.connections.get(CUSTOM_SEARCH_CONNECTION_NAME);

  const agent = await project.agents.createVersion("MyAgent", {
    kind: "prompt",
    model: "gpt-4.1-mini",
    instructions:
      "You are a helpful agent that can use Bing Custom Search tools to assist users. Use the available Bing Custom Search tools to answer questions and perform tasks.",
    tools: [
      {
        type: "bing_custom_search_preview",
        bing_custom_search_preview: {
          search_configurations: [
            {
              project_connection_id: bingCustomConnection.id,
              instance_name: CUSTOM_SEARCH_INSTANCE_NAME,
            },
          ],
        },
      },
    ],
  });
  console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);

  // Prompt user for input
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  const userInput = await new Promise<string>((resolve) => {
    rl.question(
      "Enter your question for the Bing Custom Search agent (e.g., 'Tell me more about foundry agent service'): \n",
      (answer) => {
        rl.close();
        resolve(answer);
      },
    );
  });

  // Send initial request that will trigger the Bing Custom Search tool
  const streamResponse = await openai.responses.create(
    {
      input: userInput,
      stream: true,
    },
    {
      body: {
        agent: { name: agent.name, type: "agent_reference" },
      },
    },
  );

  // Process the streaming response
  for await (const event of streamResponse) {
    if (event.type === "response.created") {
      console.log(`Follow-up response created with ID: ${event.response.id}`);
    } else if (event.type === "response.output_text.delta") {
      process.stdout.write(event.delta);
    } else if (event.type === "response.output_text.done") {
      console.log("\n\nFollow-up response done!");
    } else if (event.type === "response.output_item.done") {
      if (event.item.type === "message") {
        const item = event.item;
        if (item.content && item.content.length > 0) {
          const lastContent = item.content[item.content.length - 1];
          if (lastContent.type === "output_text" && lastContent.annotations) {
            for (const annotation of lastContent.annotations) {
              if (annotation.type === "url_citation") {
                console.log(
                  `URL Citation: ${annotation.url}, Start index: ${annotation.start_index}, End index: ${annotation.end_index}`,
                );
              }
            }
          }
        }
      }
    } else if (event.type === "response.completed") {
      console.log("\nFollow-up completed!");
    }
  }

  // Clean up resources by deleting the agent version
  // This prevents accumulation of unused resources in your project
  console.log("\nCleaning up resources...");
  await project.agents.deleteVersion(agent.name, agent.version);
  console.log("Agent deleted");

  console.log("\nBing Custom Search agent sample completed!");
}

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

Funktionsweise dieses Codes

In diesem Beispiel wird ein Agent mit "Grounding" für die benutzerdefinierte Bing-Suche erstellt, der innerhalb Ihrer konfigurierten Domains durchsucht. Wenn Sie den Code ausführen:

1. Sie erstellt eine AIProjectClient und authentifiziert sich mithilfe Ihrer Azure Anmeldeinformationen.
2. Erstellt einen Agent mit dem Bing Custom Search-Tool, das mithilfe Ihrer benutzerdefinierten Suchinstanz konfiguriert ist.
3. Fordert die Benutzereingabe zur Laufzeit über die Befehlszeile auf.
4. Der Agent verwendet das Bing Custom Search-Tool, um nur Ihre angegebenen Domänen zu durchsuchen und die Antwort zu streamen.
5. Verarbeitet Streamingereignisse und extrahiert URL-Zitate mit ihren Positionen im Text.
6. Bereinigt durch Löschen der Agentversion.

Erforderliche Eingaben

• Aktualisieren Sie die PROJECT_ENDPOINT, CUSTOM_SEARCH_CONNECTION_NAMEund CUSTOM_SEARCH_INSTANCE_NAME Konstanten im Code mit Ihren Werten.
• Azure Anmeldeinformationen, die für DefaultAzureCredential konfiguriert sind.
• Benutzereingaben, die zur Laufzeit über die Konsole bereitgestellt werden.

Erwartete Ausgabe

Agent created (id: asst_abc123, name: MyAgent, version: 1)
Enter your question for the Bing Custom Search agent (e.g., 'Tell me more about foundry agent service'):
Tell me more about foundry agent service
Follow-up response created with ID: resp_xyz789
Microsoft Foundry Agent Service enables you to build...

Follow-up response done!
URL Citation: https://learn.microsoft.com/azure/ai-foundry/agents, Start index: 0, End index: 89

Follow-up completed!

Cleaning up resources...
Agent deleted

Bing Custom Search agent sample completed!

Verwenden Sie Bing Grounding in einem Java-Agenten

Fügen Sie die Abhängigkeit zu Ihrem pom.xml hinzu:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-agents</artifactId>
    <version>2.0.0</version>
</dependency>

Erstellen eines Agents mit Bing-Verbindung

import com.azure.ai.agents.AgentsClient;
import com.azure.ai.agents.AgentsClientBuilder;
import com.azure.ai.agents.ResponsesClient;
import com.azure.ai.agents.models.*;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;

import java.util.Arrays;
import java.util.Collections;

public class BingGroundingExample {
    public static void main(String[] args) {
        // Format: "https://resource_name.ai.azure.com/api/projects/project_name"
        String projectEndpoint = "your_project_endpoint";
        String bingConnectionId = "my-bing-connection-id";

        AgentsClientBuilder builder = new AgentsClientBuilder()
            .credential(new DefaultAzureCredentialBuilder().build())
            .endpoint(projectEndpoint);

        AgentsClient agentsClient = builder.buildAgentsClient();
        ResponsesClient responsesClient = builder.buildResponsesClient();

        // Create Bing grounding tool with connection configuration
        BingGroundingTool bingTool = new BingGroundingTool(
            new BingGroundingSearchToolParameters(Arrays.asList(
                new BingGroundingSearchConfiguration(bingConnectionId)
            ))
        );

        // Create agent with Bing grounding tool
        PromptAgentDefinition agentDefinition = new PromptAgentDefinition("gpt-4.1-mini")
            .setInstructions("You are a helpful assistant. Use Bing to find up-to-date information.")
            .setTools(Collections.singletonList(bingTool));

        AgentVersionDetails agent = agentsClient.createAgentVersion("bing-grounding-agent", agentDefinition);
        System.out.printf("Agent created: %s (version %s)%n", agent.getName(), agent.getVersion());

        // Create a response
        AgentReference agentReference = new AgentReference(agent.getName())
            .setVersion(agent.getVersion());

        Response response = responsesClient.createAzureResponse(
            new AzureCreateResponseOptions().setAgentReference(agentReference),
            ResponseCreateParams.builder()
                .input("What are the latest developments in AI?"));

        System.out.println("Response: " + response.output());

        // Clean up
        agentsClient.deleteAgentVersion(agent.getName(), agent.getVersion());
    }
}