Foundry IQ, MCP, and the OpenAI Agents SDK solve different parts of an agent architecture: Foundry IQ organizes and retrieves knowledge, MCP exposes tools and context through a standard interface, and the Agents SDK runs an agent workflow. They can work together, but none is a substitute for the others. The key decisions are where retrieval happens, where MCP calls execute, which component owns the agent loop, and how identity and permissions are enforced.
What each layer does
Foundry IQ: knowledge organization and retrieval
Foundry IQ is built on Azure AI Search agentic retrieval, and a knowledge base requires Azure AI Search. A knowledge base groups one or more knowledge sources and configures how retrieval works, including source selection, retrieval instructions, reasoning effort, output mode, and answer instructions. Depending on its configuration, agentic retrieval can plan queries across sources, retrieve and rerank results, and synthesize an answer with source references.
As an Amazon Associate I earn from qualifying purchases.
That makes Foundry IQ the knowledge and retrieval layer. It does not, by itself, define the whole application’s agent loop, tool-approval policy, or deployment architecture.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →MCP: a tool-and-context interface
The Model Context Protocol (MCP) standardizes how an application makes tools and context available to an AI system. It is an interface, not an agent runtime or a knowledge store. An MCP server can expose a capability—such as retrieval from a knowledge base—without requiring the client to use a particular agent framework.
#1 Best Overall
OpenAI Agents SDK: an agent workflow runtime
The Agents SDK is a Python-first runtime with agents, tool execution, handoffs, guardrails, sessions, human-in-the-loop support, and tracing. It can call MCP tools and manage workflow around those calls. It uses the Responses API by default for OpenAI models, but adds a higher-level way to manage agent turns and related behavior.
How the three layers fit together
A common design is to keep the knowledge base responsible for retrieval, expose its retrieval capability through MCP, and let an agent runtime decide when to invoke that capability and how to use the result. In Microsoft’s documented Foundry Agent Service integration, Azure AI Search knowledge bases expose an MCP tool named knowledge_base_retrieve. Foundry Agent Service connects to the endpoint through a RemoteTool project connection.
At a conceptual level, the request path is:
- The agent decides whether retrieval is needed. The runtime manages the turn and chooses an available tool according to the application’s instructions and controls.
- The MCP client calls the retrieval tool. The client sends a request to the server that exposes the knowledge-base capability.
- The knowledge base retrieves from its configured sources. Its retrieval settings determine source selection and whether query planning or answer synthesis is used.
- The tool result returns to the agent. The runtime can use the result in the current turn, subject to the tool’s output format and the application’s handling rules.
This separation is useful because retrieval configuration, protocol connectivity, and agent workflow can change independently. It also means the boundaries need to be explicit: the knowledge base does not automatically decide which tools an agent may call, and an MCP connection does not automatically secure access to the underlying documents.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Can Foundry IQ work without Foundry Agent Service?
Yes. Foundry Agent Service is a convenient integration and managed-hosting path, not a hard requirement for using a Foundry IQ knowledge base. Microsoft documents supported Azure AI Search knowledge-base APIs for use from Microsoft Agent Framework or a custom application as well.
| Approach | What it gives you | What your team owns |
|---|---|---|
| Foundry Agent Service with the documented MCP connection | A Foundry-managed agent integration path and a knowledge-base tool exposed over MCP. | Agent design, tool access policy, identity configuration, and validation of the current preview and production terms. |
| Another agent framework or custom application using knowledge-base APIs | Direct use of supported Azure AI Search knowledge-base APIs without requiring Foundry Agent Service. | The application’s agent loop and integration details, including API usage, identity, error handling, and operational controls. |
Choose the managed path when its hosting and integration reduce work without conflicting with your deployment or governance needs. Choose API access from another application when you need a different runtime or want to own more of the integration. The connection guide describes the Foundry Agent Service RemoteTool connection as a preview feature; its guide also marks query planning and answer synthesis as preview. The documentation reviewed on October 7, 2026 warns that preview features can change and are not covered by an SLA. Verify current availability and applicable production terms before relying on them.
How agentic retrieval changes the knowledge-base design
Agentic retrieval can use a language model to plan queries across sources. The Foundry IQ FAQ describes that planning as optional: without an LLM, minimal reasoning effort can merge results from multiple queries, while low and medium reasoning efforts use LLM planning for more thorough retrieval. The FAQ lists GPT-4o, GPT-4.1, and GPT-5 series models from Azure OpenAI in Foundry Models as supported query-planning model families. Supported deployments and regions can change, so confirm compatibility against current documentation when selecting a model.
Plan the knowledge base around the answer the application needs, rather than assuming every retrieval call should produce a finished response. Configure source selection and retrieval instructions to guide evidence gathering; choose an output mode that fits the agent’s next step. If answer synthesis is enabled, decide how the application will present the answer and its source references, and test whether the result is appropriate for the end user. Query planning and answer synthesis being preview features in the cited connection guide should factor into production readiness.
Free tools Windows power users keep installed
One-click scans. No signup required.
Choosing an MCP connection in the Agents SDK
The Agents SDK documents several MCP connection patterns. The right choice depends primarily on where the call executes, what network path is available, and whether the application needs to inspect or control the connection locally.
| SDK option | Where the call is managed | Use it when | Important constraint |
|---|---|---|---|
Hosted MCP (HostedMCPTool) |
The Responses API performs the remote MCP round-trip. | You want the hosted path and your model supports hosted MCP in the Responses API. | The server must be reachable as required for the hosted connection. Do not assume local server-object guardrails apply to hosted tool execution. |
Streamable HTTP (MCPServerStreamableHttp) |
The application manages the connection to a local or remote server. | Your application controls the server or you want MCP execution on local infrastructure. | Plan the network route, credentials, and connection behavior in the application. |
SSE (MCPServerSse) |
The application connects to a server using HTTP with Server-Sent Events. | The MCP server offers this transport and it fits your network and runtime requirements. | Confirm transport compatibility with the server and installed SDK dependencies. |
stdio (MCPServerStdio) |
The application starts a local process and communicates over standard input and output. | The server is a local process that the application can launch. | Process lifecycle, environment, and local credential handling belong in the application’s operating model. |
For any connection type, decide whether the application needs static or dynamic tool filtering, approval for all or selected tools, local inspection of results, tracing, caching, or custom error handling. The SDK can filter tools, configure approval globally or per tool, and map MCP text and image content into tool outputs. These choices are not interchangeable: for example, hosted execution does not follow the same local server-object path, so do not presume local guardrail behavior covers hosted tools.
Should you use the Agents SDK or call the Responses API directly?
Use the Agents SDK when its workflow features reduce complexity you would otherwise implement: managed turns, tool execution, guardrails, handoffs, sessions, human-in-the-loop support, or tracing. Call the Responses API directly when the application should own the tool loop and state handling. The SDK uses the Responses API by default for OpenAI models, so this is mainly a choice about runtime responsibilities rather than an either-or choice between unrelated model interfaces.
| Decision area | Agents SDK | Direct Responses API |
|---|---|---|
| Turn loop and tool dispatch | Useful when you want a higher-level runtime to manage turns and tool execution. | Useful when your application should implement and control the loop. |
| State and workflow | Provides workflow primitives such as sessions, handoffs, and human-in-the-loop support. | Your application owns state handling and any workflow logic it needs. |
| Guardrails and tool controls | Provides SDK-level guardrail and tool configuration capabilities; server-side authorization remains necessary. | Your application chooses and implements its own control structure around requests and tools. |
Do not select the SDK merely because MCP is involved: direct API use may still fit if your application deliberately owns orchestration. Conversely, do not rebuild turn management, approval flows, or handoff behavior by default if the SDK’s runtime matches your requirements.
Make authorization and permissions explicit
MCP tools may perform sensitive actions, and the presence of an MCP interface is not an authorization strategy. OpenAI’s MCP guidance recommends connecting only to trusted servers, using least-privilege credentials, placing access tokens in authorization fields or headers rather than URLs, and requiring approval for sensitive operations. Combine those controls with server-side authorization and monitoring; filtering the tools visible to a model reduces exposure but does not replace authorization.
Foundry IQ has a separate document-permission concern. According to Microsoft’s Foundry IQ FAQ, user-level access controls are enforced only when the knowledge source supports document-level permissions and those permissions have been explicitly configured for synchronization. Do not infer that permissions from a source system automatically carry over to retrieval.
- Establish which identity the MCP server and knowledge-base request use, and which credentials are permitted to access each source.
- Expose only the tools the agent needs, and require approval for operations with meaningful consequences.
- Test retrieval with identities and documents that should be allowed, as well as cases that should be denied.
- Monitor server-side access and tool use so that an agent-level filter is not the only record or enforcement point.
Operational checks before deployment
Confirm feature and model availability
Recheck whether the RemoteTool connection, query planning, and answer synthesis are still preview, and verify the service terms that apply to your deployment. Confirm that the chosen query-planning model is supported for your region and deployment.
Pin and validate MCP dependencies
The Agents SDK MCP documentation specifies the Python dependency range mcp>=1.19.0,<3 and describes support for both major versions. Pin a compatible dependency set, use HTTP customization appropriate to the installed MCP package major version, and check SDK release notes when upgrading.
Exercise failures and output handling
Test unreachable servers, denied authorization, tool errors, empty or partial retrieval results, and unexpected text or image content. Decide how retries, timeouts, tool-output conversion, and user-facing failure messages work in your application; do not assume a transport or runtime will make these application decisions for you.
A practical decision sequence
- Establish the retrieval requirement. If you need a Foundry IQ knowledge base, provision Azure AI Search and define the sources and retrieval behavior it should cover.
- Choose who hosts and orchestrates the agent. Evaluate Foundry Agent Service against another framework or a custom application, including the consequences of preview dependencies.
- Choose how the agent reaches retrieval. Use the documented MCP path where it fits, or call supported knowledge-base APIs from the chosen application.
- Choose the runtime and transport. Select the Agents SDK if its workflow features help; select direct Responses API use if the application should own the loop. For SDK MCP, pick hosted MCP, Streamable HTTP, SSE, or stdio based on execution location and reachability.
- Design authorization and failure behavior. Configure least privilege, tool filtering and approvals, synchronize document-level permissions when supported, and test allowed and denied identities along with operational failures.
The Microsoft Learn Foundry IQ FAQ and connection guide, and the OpenAI Agents SDK overview and MCP guide, were checked on October 7, 2026. Because preview status, APIs, model support, dependency compatibility, and regional availability can change, confirm the current official documentation during implementation.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
