Puesta en tierra de agentes con herramientas de Bing Search

En los ejemplos siguientes se muestra cómo crear un agente con herramientas de Grounding con Bing Search y cómo usar el agente para responder a las consultas de usuario.

Fundamento con Bing Search

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}")

Qué hace este código

En este ejemplo se crea un agente con conexión a tierra mediante la herramienta Bing Search que puede recuperar información en tiempo real de la web. Al ejecutar el código:

1. Crea una AIProjectClient y se autentica mediante las credenciales de Azure.
2. Crea un agente con la herramienta de integración de Bing configurada a través de tu conexión de Bing.
3. Envía una consulta que pregunta sobre la fecha actual y el tiempo en Seattle.
4. El agente usa la herramienta de puesta a tierra de Bing para buscar en la web y transmite la respuesta.
5. Extrae y muestra las citas url de los resultados de la búsqueda.

Entradas necesarias

• Actualice las PROJECT_ENDPOINT constantes y BING_CONNECTION_NAME en el código con sus valores.
• Credenciales Azure configuradas para DefaultAzureCredential.

Salida esperada

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

Fundamentación con Bing Custom Search (versión preliminar)

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}")

Qué hace este código

En este ejemplo se crea un agente con la herramienta Grounding with Bing Custom Search que busca dentro de un conjunto configurable de dominios web públicos. Al ejecutar el código:

1. Crea una AIProjectClient y se autentica mediante las credenciales de Azure.
2. Crea un agente con la herramienta Bing Custom Search utilizando tu instancia de búsqueda personalizada.
3. Solicita al usuario que proporcione información sobre temas específicos dentro de los dominios configurados.
4. El agente usa la herramienta Bing Custom Search para buscar solo los dominios especificados y transmite la respuesta.
5. Extrae y muestra citas url con posiciones iniciales y finales de los resultados de búsqueda personalizados.

Entradas necesarias

• Actualice las constantes PROJECT_ENDPOINT, CUSTOM_SEARCH_CONNECTION_NAME y CUSTOM_SEARCH_INSTANCE_NAME en el código con sus valores.
• Credenciales Azure configuradas para DefaultAzureCredential.
• Entrada del usuario en tiempo de ejecución.

Salida esperada

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

En los siguientes ejemplos de C# se muestra cómo crear un agente con la herramienta Grounding with Bing Search y cómo usar el agente para responder a las consultas de usuario. Estos ejemplos usan llamadas sincrónicas para simplificar. Para obtener ejemplos asincrónicos, consulte los ejemplos de C# de agent tools.

Para permitir que su Agente use la API de búsqueda de Bing, use BingGroundingTool.

Fundamento con Bing Search

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

Qué hace este código

En este ejemplo se crea un agente que usa la herramienta Grounding con Bing Search y se muestra el control de respuesta sincrónica. Al ejecutar el código:

1. Crea un AIProjectClient mediante el punto de conexión del proyecto.
2. Recupera la configuración de conexión de Bing del proyecto.
3. Crea un agente con la herramienta de integración de Bing ya configurada.
4. Envía una consulta que pregunta cómo Wikipedia explica la identidad de Euler.
5. El agente utiliza la herramienta de referencia de Bing para buscar y devolver resultados formateados con citas URL.
6. Limpia eliminando la versión del agente.

Entradas necesarias

• Actualice las projectEndpoint constantes y bingConnectionName en el código con sus valores.
• Credenciales Azure configuradas para DefaultAzureCredential.

Salida esperada

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)

Fundamento con Bing en escenarios de streaming

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

Qué hace este código

En este ejemplo se crea un agente con base mediante la herramienta Bing Search y se muestra la gestión de respuestas en streaming. Al ejecutar el código:

1. Crea un AIProjectClient mediante el punto de conexión del proyecto.
2. Recupera la configuración de conexión de Bing del proyecto.
3. Crea un agente con la herramienta de integración de Bing ya configurada.
4. Envía una consulta que pregunta cómo Wikipedia explica la identidad de Euler.
5. El agente usa la herramienta de puesta a tierra de Bing y transmite la respuesta en tiempo real.
6. Procesa eventos de streaming, incluidas las actualizaciones de texto delta y la extracción de citas.
7. Limpia eliminando la versión del agente.

Entradas necesarias

• Actualice las projectEndpoint constantes y bingConnectionName en el código con sus valores.
• Credenciales Azure configuradas para DefaultAzureCredential.

Salida esperada

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)

Los siguientes ejemplos de API REST muestran cómo usar Grounding con Bing Search y Grounding con herramientas de Bing Custom Search (versión preliminar) para responder a las consultas de los usuarios.

Fundamento con Bing Search

Configuración de autenticación

Antes de ejecutar llamadas a la API REST, configure la autenticación:

1. Establecer variables de entorno:

   • FOUNDRY_PROJECT_ENDPOINT: la dirección URL del punto de conexión del proyecto Foundry.
   • FOUNDRY_MODEL_DEPLOYMENT_NAME: nombre del modelo implementado.
   • BING_PROJECT_CONNECTION_ID: Su ID de conexión del proyecto de Grounding con Bing Search.

2. Obtenga un token de portador:

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

Qué hace este código

Esta solicitud de API REST crea una respuesta mediante Grounding con Bing Search. La solicitud:

1. Envía una solicitud POST al endpoint de respuestas de Foundry.
2. Incluye la implementación del modelo y la entrada del usuario en el cuerpo de la solicitud.
3. Configura la herramienta de puesta a tierra de Bing con parámetros de búsqueda (recuento, mercado, idioma, actualización).
4. Devuelve una respuesta con resultados y citas de búsqueda web.

Entradas necesarias

• Variables de entorno: FOUNDRY_PROJECT_ENDPOINT, AGENT_TOKEN, FOUNDRY_MODEL_DEPLOYMENT_NAME, BING_PROJECT_CONNECTION_ID.
• Token de portador (bearer token) válido con los permisos adecuados.

Salida esperada

Respuesta JSON con:

• id: identificador de respuesta
• output_text: texto generado con información fundamentada
• citations: matriz de citas URL usadas para generar la respuesta.

Fundamentación con Bing Custom Search (versión preliminar)

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

Qué hace este código

Esta solicitud de API REST crea una respuesta mediante Grounding con Bing Custom Search. La solicitud:

1. Envía una solicitud POST al endpoint de respuestas de Foundry.
2. Incluye la implementación del modelo y la entrada del usuario en el cuerpo de la solicitud.
3. Configura la herramienta Bing Custom Search con el nombre de la instancia y los parámetros de búsqueda.
4. Devuelve una respuesta con resultados de búsqueda personalizados limitados a los dominios configurados.

Entradas necesarias

• Variables de entorno: FOUNDRY_PROJECT_ENDPOINT, AGENT_TOKEN, FOUNDRY_MODEL_DEPLOYMENT_NAME, , BING_CUSTOM_SEARCH_PROJECT_CONNECTION_IDBING_CUSTOM_SEARCH_INSTANCE_NAME
• Token de portador (bearer token) válido con los permisos adecuados.
• Instancia de Bing Custom Search ya configurada con dominios de destino

Salida esperada

Respuesta JSON con:

• id: identificador de respuesta
• output_text: texto generado con información del conjunto de dominios personalizado
• citations: matriz de citas url de los dominios configurados

En los siguientes ejemplos de TypeScript se muestra cómo crear un agente con Grounding con las herramientas de Bing Search y Bing Custom Search (versión preliminar) y cómo usar el agente para responder a las consultas de los usuarios. Para obtener ejemplos de JavaScript, consulte los ejemplos de JavaScript de las herramientas agent tools en el repositorio de SDK de Azure para JavaScript en GitHub.

Fundamento con Bing Search

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

Qué hace este código

En este ejemplo se crea un agente con conexión a tierra mediante la herramienta Bing Search que puede recuperar información en tiempo real de la web. Al ejecutar el código:

1. Crea una AIProjectClient y se autentica mediante las credenciales de Azure.
2. Crea un agente con la herramienta de integración de Bing configurada a través de tu conexión de Bing.
3. Envía una consulta que pregunta sobre la fecha actual y el tiempo en Seattle con la opción de herramienta establecida en "obligatorio".
4. El agente usa la herramienta de puesta a tierra de Bing para buscar en la web y transmite la respuesta.
5. Procesa eventos de streaming y extrae citas de dirección URL con sus posiciones en el texto.
6. Limpia eliminando la versión del agente.

Entradas necesarias

• Actualice las PROJECT_ENDPOINT constantes y BING_CONNECTION_NAME en el código con sus valores.
• Credenciales Azure configuradas para DefaultAzureCredential.

Salida esperada

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!

Fundamentación con Bing Custom Search (versión preliminar)

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

Qué hace este código

En este ejemplo se crea un agente con la herramienta Grounding with Bing Custom Search que busca en los dominios configurados. Al ejecutar el código:

1. Crea una AIProjectClient y se autentica mediante las credenciales de Azure.
2. Crea un agente con la herramienta Bing Custom Search utilizando tu instancia de búsqueda personalizada.
3. Solicita la entrada del usuario en tiempo de ejecución a través de la línea de comandos.
4. El agente usa la herramienta Bing Custom Search para buscar solo los dominios especificados y transmite la respuesta.
5. Procesa eventos de streaming y extrae citas de dirección URL con sus posiciones en el texto.
6. Limpia eliminando la versión del agente.

Entradas necesarias

• Actualice las constantes PROJECT_ENDPOINT, CUSTOM_SEARCH_CONNECTION_NAME y CUSTOM_SEARCH_INSTANCE_NAME en el código con sus valores.
• Credenciales Azure configuradas para DefaultAzureCredential.
• Entrada del usuario proporcionada en tiempo de ejecución a través de la consola.

Salida esperada

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!

Uso de Bing grounding en un agente de Java

Agregue la dependencia a pom.xml:

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

Creación de un agente con 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());
    }
}