Grounding von Agenten mit den Bing-Suchtools

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. Wählen Sie Prompt Agents aus, um das AZURE AI Projects SDK zum Erstellen eines serverseitigen Eingabeaufforderungs-Agents oder Hosted Agents zu verwenden, um das Agent Framework FoundryChatClient zum Erstellen eines ephemeralen, in-Process-Agents zu verwenden.

Prompt-Agenten

Antworten mit Bing Search fundieren

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.output_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 ein Agent mit Grounding erstellt, der mithilfe der Bing-Suche Echtzeitinformationen aus dem Internet 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 über Ihre Bing-Verbindung konfiguriert wurde.
3. Sendet eine Abfrage mit der Frage nach aktuellem Datum und Wetter in Seattle.
4. Der Agent durchsucht mit dem Bing-Grounding-Tool das Internet und streamt die Antwort.
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...

Gehostete Agents

Dieses Beispiel verwendet FoundryChatClient aus dem Microsoft Agent Framework und ruft get_bing_grounding_tool() auf, um Bing-Grounding über eine Projektverbindung hinzuzufügen. Installieren Sie das Paket mit pip install agent-framework-foundry aiohttp, legen Sie die FOUNDRY_PROJECT_ENDPOINT Variablen und FOUNDRY_MODEL Umgebung fest, und melden Sie sich mit az login.

import asyncio
import os

from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
from azure.ai.projects import AIProjectClient
from azure.identity import AzureCliCredential

BING_CONNECTION_NAME = "my-bing-connection"


async def main() -> None:
    credential = AzureCliCredential()

    # Resolve the project connection ID from the connection name
    # (same pattern as the Prompt Agents tab).
    project = AIProjectClient(
        endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
        credential=credential,
    )
    connection_id = project.connections.get(BING_CONNECTION_NAME).id

    agent = Agent(
        # Reads FOUNDRY_PROJECT_ENDPOINT and FOUNDRY_MODEL from the environment.
        client=FoundryChatClient(credential=credential),
        instructions="You are a helpful assistant that can search the web with Bing.",
        tools=[
            FoundryChatClient.get_bing_grounding_tool(
                connection_id=connection_id,
                market="en-US",
                count=10,
                freshness="Day",
            )
        ],
    )

    result = await agent.run("What is today's date and weather in Seattle?")
    print(f"Agent: {result.text}")

    # Print URL citation annotations from the response.
    for message in result.messages:
        for content in message.contents:
            for annotation in getattr(content, "annotations", None) or []:
                url = getattr(annotation, "url", None)
                if url:
                    print(f"URL Citation: {url}")


if __name__ == "__main__":
    asyncio.run(main())

Erwartete Ausgabe

Der Agent verwendet Bing-Bodenung, um das Web nach aktuellem Datum und Seattle Wetter zu durchsuchen, und druckt dann den endgültigen Antworttext gefolgt von URL-Zitaten, die aus den Antwortanmerkungen analysiert werden.

Agent: Today's date is December 12, 2025, and the weather in Seattle is...
URL Citation: https://www.weather.gov/seattle/

Verwenden Sie für die benutzerdefinierte Bing-Suche FoundryChatClient.get_bing_custom_search_tool(connection_id=..., instance_name=..., market=..., count=...) mit demselben Agentmuster. Weitere Informationen finden Sie in den Beispielen des Foundry-Anbieters.

Grounding mit der benutzerdefinierten Bing-Suche beschränken (Vorschauversion)

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.output_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

Dieses Beispiel erstellt einen Agenten mit Grounding mit dem Bing Custom Search-Tool, das innerhalb einer konfigurierbaren Menge von öffentlichen Webdomains sucht. Wenn Sie den Code ausführen:

1. Sie erstellt eine AIProjectClient und authentifiziert sich mithilfe Ihrer Azure Anmeldeinformationen.
2. Erstellt einen Agenten mit der benutzerdefinierten Bing-Suche, die unter Verwendung Ihrer benutzerdefinierten Suchinstanz konfiguriert wurde.
3. Fordert Benutzer auf, Eingaben zu spezifischen Themen innerhalb Ihrer konfigurierten Domänen zu machen.
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 von Bing Search erstellen und wie der Agent zur Beantwortung von Benutzeranfragen verwendet wird. 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. Wählen Sie Prompt Agents aus, um das AZURE AI Projects SDK zum Erstellen eines serverseitigen Eingabeaufforderungs-Agents oder Hosted Agents zu verwenden, um das Microsoft Agent Framework zum Erstellen eines ephemeren, in-Process-Agents zu verwenden.

Prompt-Agenten

Antworten mit Bing Search fundieren

// 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
if (response.Status != ResponseStatus.Completed)
{
  throw new InvalidOperationException($"Response failed with status {response.Status}.");
}
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-Tool mit der Bing-Suche verwendet und synchrones Antworten demonstriert. 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-Grounding-Tool.
4. Sendet eine Abfrage, die fragt, wie Wikipedia Eulers Identität erklärt.
5. Der Agent verwendet das Bing-Grounding-Tool für die Suche und liefert formatierte Ergebnisse mit URL-Zitaten.
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)

Gehostete Agents

In diesem Beispiel wird das Microsoft Agent Framework verwendet, und AsAIAgent(...) wird bei AIProjectClient zusammen mit FoundryAITool.CreateBingGroundingTool(...) aus Microsoft.Agents.AI.Foundry aufgerufen. Installieren Sie die Pakete Microsoft.Agents.AI.Foundry und Azure.AI.Projects, legen Sie die Variablen AZURE_AI_PROJECT_ENDPOINT und AZURE_AI_MODEL_DEPLOYMENT_NAME Umgebung fest, und melden Sie sich mit az login an.

using Azure.AI.Projects;
using Azure.AI.Projects.Agents;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Foundry;
using Microsoft.Extensions.AI;

string endpoint = Environment.GetEnvironmentVariable("AZURE_AI_PROJECT_ENDPOINT")
    ?? throw new InvalidOperationException("AZURE_AI_PROJECT_ENDPOINT is not set.");
string deploymentName = Environment.GetEnvironmentVariable("AZURE_AI_MODEL_DEPLOYMENT_NAME") ?? "gpt-5-mini";
string bingConnectionName = "my-bing-connection";

const string AgentInstructions = "You are a helpful agent that can use Bing search to answer questions.";

AIProjectClient aiProjectClient = new(new Uri(endpoint), new DefaultAzureCredential());

// Resolve the project connection ID from the connection name
// (same pattern as the Prompt Agents tab).
AIProjectConnection bingConnection = aiProjectClient.Connections.GetConnection(connectionName: bingConnectionName);

BingGroundingSearchToolOptions bingGroundingOptions = new(
    searchConfigurations: [new BingGroundingSearchConfiguration(projectConnectionId: bingConnection.Id)]);

AIAgent agent = aiProjectClient.AsAIAgent(deploymentName,
    instructions: AgentInstructions,
    name: "BingGroundingAgent",
    tools: [FoundryAITool.CreateBingGroundingTool(bingGroundingOptions)]);

AgentResponse response = await agent.RunAsync("How does wikipedia explain Euler's Identity?");

Console.WriteLine($"Response: {response.Text}");

// Print URL citation annotations from the response.
foreach (AIAnnotation annotation in response.Messages.SelectMany(m => m.Contents).SelectMany(c => c.Annotations ?? []))
{
    if (annotation.RawRepresentation is UriCitationMessageAnnotation uriAnnotation)
    {
        Console.WriteLine($"URL Citation: [{uriAnnotation.Title}]({uriAnnotation.Uri})");
    }
}

Erwartete Ausgabe

Der Agent verwendet Grounding mit Bing, um das Web zu durchsuchen und die Frage zu beantworten, und gibt dann den endgültigen Antworttext aus, gefolgt von URL-Verweisen, die aus den Antwortanmerkungen extrahiert wurden.

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

Verwenden Sie FoundryAITool.CreateBingCustomSearchTool(...) für die benutzerdefinierte Bing-Suche mit einer BingCustomSearchToolOptions Instanz. Das vollständige Beispiel finden Sie unter Agent_Step18_BingCustomSearch.

Streaming einer fundierten Bing-Antwort

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

Dieses Beispiel erstellt einen Agenten mit Grounding unter Verwendung des Bing-Suche-Tools und demonstriert gestreamtes Antworten. 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-Grounding-Tool.
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 Grounding mit Bing-Suche und Grounding mit benutzerdefinierter Bing-Suche (Vorschau) verwenden, um auf Benutzeranfragen zu reagieren.

Antworten mit Bing Search fundieren

Authentifizierungseinstellungen

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

1. Festlegen von Umgebungsvariablen:

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

2. Abrufen 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": "week"
             }
           ]
         }
       }
     ]
   }'
   

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. Nimmt die Modellbereitstellung und die Benutzereingabe in den Anforderungstext auf.
3. Konfiguriert das Bing-Grounding-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

Die Antwort enthält ein output Array. URL-Zitate sind Anmerkungen zu einem output_text Inhaltselement:

{
  "id": "resp_<id>",
  "status": "completed",
  "output": [
    {
      "type": "message",
      "role": "assistant",
      "content": [
        {
          "type": "output_text",
          "text": "<grounded response>",
          "annotations": [
            { "type": "url_citation", "url": "https://example.com/source" }
          ]
        }
      ]
    }
  ]
}

Grounding mit der benutzerdefinierten Bing-Suche beschränken (Vorschauversion)

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

Funktionsweise dieses Codes

Diese REST-API-Anforderung erstellt eine Antwort unter Verwendung von Grounding mit der Bing Custom Search. Die Anforderung:

1. Sendet eine POST-Anforderung an den Endpunkt für Foundry-Antworten.
2. Nimmt die Modellbereitstellung und die Benutzereingabe in den Anforderungstext auf.
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

Die Antwort verwendet das gleiche output Array-Shape, das im vorherigen REST-Beispiel gezeigt wird. Zitatanmerkungen enthalten URLs aus Ihren konfigurierten Domänen.

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

Antworten mit Bing Search fundieren

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_reference: { 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 ein Agent mit Grounding erstellt, der mithilfe der Bing-Suche Echtzeitinformationen aus dem Internet 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 über Ihre Bing-Verbindung konfiguriert wurde.
3. Sendet eine Abfrage, die nach dem aktuellen Datum und wetter in Seattle fragt, wobei die Toolauswahl auf "erforderlich" festgelegt ist.
4. Der Agent durchsucht mit dem Bing-Grounding-Tool das Internet und streamt die Antwort.
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!

Grounding mit der benutzerdefinierten Bing-Suche beschränken (Vorschauversion)

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_reference: { 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 dem Tool „Grounding mit der benutzerdefinierten Bing-Suche“ erstellt, das innerhalb Ihrer konfigurierten Domänen sucht. Wenn Sie den Code ausführen:

1. Sie erstellt eine AIProjectClient und authentifiziert sich mithilfe Ihrer Azure Anmeldeinformationen.
2. Erstellt einen Agenten mit der benutzerdefinierten Bing-Suche, die unter Verwendung Ihrer benutzerdefinierten Suchinstanz konfiguriert wurde.
3. Fordert bei Laufzeit Benutzereingaben über die Befehlszeile an.
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 von Bing-Grounding in einem Java-Agent

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

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

Erstellen eines Agents mit Bing-Grounding

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