{"id":16600,"date":"2026-03-26T00:00:00","date_gmt":"2026-03-26T07:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/ise\/?p=16600"},"modified":"2026-03-26T05:21:57","modified_gmt":"2026-03-26T12:21:57","slug":"building-bing-search-enabled-agent-with-microsoft-foundry-and-semantic-kernel","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/ise\/building-bing-search-enabled-agent-with-microsoft-foundry-and-semantic-kernel\/","title":{"rendered":"Building Search-Enabled Agents with Azure AI Foundry and Semantic Kernel and A2A"},"content":{"rendered":"

The landscape of AI development has evolved dramatically. Modern intelligent agents require real-time web access to provide accurate, grounded responses. With the retirement of direct Bing Search API access<\/a>, developers must transition from direct API integration to agent-based architectures.<\/p>\n

This article explores how to implement a robust search solution by orchestrating a communication channel between a Semantic Kernel agent and an Azure AI Foundry agent using the Agent-to-Agent (A2A) protocol.<\/p>\n

The Challenge<\/h2>\n

The deprecation of raw Bing Search API endpoints necessitates a new integration pattern. Currently, Bing Grounding<\/a> capabilities are encapsulated within Azure AI Foundry agents. This creates a service boundary where external agents\u2014such as those built with Semantic Kernel or LangChain\u2014cannot directly invoke Bing search capabilities as a standalone tool.<\/p>\n

Instead of a direct API call, search functionality must be consumed through an intermediary agent hosted within the Azure AI Foundry ecosystem. This requires a reliable protocol for inter-agent communication.<\/p>\n

Solution Architecture: Multi-Agent Orchestration<\/h2>\n

To address this constraint, we implemented a multi-agent pattern that separates concerns between orchestration and information retrieval:<\/p>\n

    \n
  1. Search Specialist (Azure AI Foundry):<\/strong> A hosted agent configured with the Bing Grounding tool. This agent handles query formulation, execution, and result parsing.<\/li>\n
  2. Orchestrator (Semantic Kernel):<\/strong> A primary agent that manages user interaction, maintains conversation context, and delegates search tasks to the specialist agent when external information is required.<\/li>\n<\/ol>\n

    \"Architecture<\/p>\n

    By using the A2A (Agent-to-Agent) communication protocol<\/strong>, we establish a standardized interface for the Orchestrator to dispatch requests to the Search Specialist, effectively treating the remote agent as a native tool.<\/p>\n

    Setting Up Bing Grounding in Azure<\/h2>\n

    Establishing the connection between your AI Foundry environment and Bing Search requires careful configuration through the Azure portal.<\/p>\n

    Step-by-Step Configuration<\/a> Process:<\/p>\n

      \n
    1. Access Azure AI Studio: Navigate to the Azure AI Studio through your Azure portal account<\/li>\n
    2. Project Selection: Either create a new AI project or select an existing project from your workspace<\/li>\n
    3. Connection Management: Locate the “Connections” section in the project’s navigation panel<\/li>\n
    4. Service Integration: Select “New connection” and choose “Bing Search” from the available service catalog<\/li>\n
    5. Authentication Setup: Input your Bing Search API key (obtained from your Azure Bing Search resource)<\/li>\n
    6. Retrieve Connection Identifier: After successful creation, the system assigns a unique Connection ID\u2014this identifier becomes the critical link between your code and the Bing Search service. Store this value securely in your environment configuration (typically as BING_CONNECTION_ID<\/code>)<\/li>\n<\/ol>\n

      Deep-Dive: A2A Protocol for Foundry Agent Communication with Bing Grounding<\/h2>\n

      Once Bing Grounding is available inside Azure AI Foundry, the remaining challenge is enabling an external agent to use it. This is solved using the Agent-to-Agent (A2A) protocol. Google’s Agent-to-Agent (A2A) protocol represents a foundational advancement in inter-agent communication standards. This protocol establishes a universal language that enables AI agents built on different platforms and technologies to collaborate seamlessly.<\/p>\n

      A2A Protocol Components<\/h3>\n

      The A2A protocol implementation in our system involves several key components:<\/p>\n

      Agent Discovery and Capability Advertisement<\/strong><\/p>\n

      The A2A protocol begins with agent discovery, where agents advertise their capabilities through standardized “agent cards”:<\/p>\n

      #Client-side discovery process\r\nresolver = A2ACardResolver(httpx_client=httpx_client, base_url=base_url)\r\nagent_card = await resolver.get_agent_card()<\/code><\/pre>\n
      The agent card contains metadata about the agent’s capabilities, supported message formats, and communication endpoints. This allows agents to understand what services are available before attempting communication.<\/p>\n
      Message Structure and Communication Patterns<\/h3>\n
      A2A messages follow a standardized structure that ensures compatibility across different agent implementations:<\/p>\n
      #A2A message construction\r\nrequest = SendMessageRequest(\r\n    id=str(uuid4()),                    # Unique request identifier\r\n    params=MessageSendParams(\r\n        message={\r\n            \"messageId\": uuid4().hex,    # Message tracking ID\r\n            \"role\": \"user\",              # Message sender role\r\n            \"parts\": [{\"text\": user_input}],  # Message content parts\r\n            \"contextId\": str(uuid4()),   # Conversation context\r\n        }\r\n    )\r\n)<\/code><\/pre>\n
      This structure provides:<\/p>\n