How To Integrate Semantic Kernel With Azure OpenAI And MCP To Discover Tools, Register Them As Functions, And Enable AI Agents To Invoke Them Dynamically

|

In modern AI development, enabling language models to interact seamlessly with external tools or APIs is a cornerstone capability. Microsoft’s Semantic Kernel delivers this by serving as an orchestration layer that integrates large language models (LLMs) with external plugins, tools, memory, and planning capabilities. When combined with Azure OpenAI, the Kernel gains powerful LLM endpoints for chat completions and more. The Model Context Protocol (MCP), meanwhile, introduces a standardized interface that unifies how LLMs call tools—bridging the gap between agents and tool servers. This article walks through how to integrate Semantic Kernel with Azure OpenAI and MCP, enabling dynamic tool discovery, function registration, and runtime invocation by AI agents.

Prerequisites and SDK Setup

Before diving into the integration, ensure you have:

  • A Semantic Kernel project (in C#, .NET)

  • Access to an Azure OpenAI resource (e.g., GPT-4 deployment)

  • An MCP Server exposing tools

  • Relevant SDKs installed via NuGet:

    dotnet add package Microsoft.SemanticKernel
    dotnet add package Microsoft.SemanticKernel.Connectors.AI.OpenAI
    dotnet add package ModelContextProtocol
    dotnet add package Microsoft.Extensions.Logging.Console

    Pravin ChandankhedeThe Developer’s Cantina

Building the Semantic Kernel and Connecting to Azure OpenAI

First, construct a Semantic Kernel instance with Azure OpenAI configured as the LLM service backend:

var builder = Kernel.CreateBuilder();
builder.AddAzureOpenAIChatCompletion(
AppSettings.DeploymentName,
AppSettings.Endpoint,
AppSettings.Key
);
builder.Services.AddLogging(loggingBuilder =>
{
loggingBuilder.AddConsole();
loggingBuilder.SetMinimumLevel(LogLevel.Information);
});
Kernel kernel = builder.Build();

This configures Azure OpenAI for chat completion and adds logging—forming the foundation of your agent orchestration.Pravin ChandankhedeMicrosoft Learn

Discovering MCP Tools Using the MCP Client

Next, establish a connection to your MCP server and retrieve its toolset dynamically:

using var mcpClient = await McpClientFactory.CreateAsync(
new SseClientTransport(new() {
Name = "MyMcpClient",
Endpoint = "http://localhost:5248"
})
);
var tools = await mcpClient.ListToolsAsync();
foreach (var tool in tools)
{
Console.WriteLine($"Tool: {tool.Name} - {tool.Description}");
}

This connects via HTTP/SSE to your MCP server, retrieves all available tools, and prints them to the console.The Developer’s CantinaMicrosoft for Developers

Registering MCP Tools as Kernel Functions

Once tools are discovered, convert them to KernelFunction objects and register them into the Semantic Kernel:

var aiFunctions = tools.Select(tool => tool.AsKernelFunction());
kernel.Plugins.AddFromFunctions("McpTools", aiFunctions);

This wraps each MCP tool as a function the Kernel recognizes—allowing agents to call them dynamically.Microsoft for Developers

Invoking Tools via the Semantic Kernel Agent

With functions registered, agents can leverage LLM-driven function calling. Enable automatic function calling via execution settings, then invoke a prompt:

var execSettings = new OpenAIPromptExecutionSettings
{
Temperature = 0,
FunctionChoiceBehavior = FunctionChoiceBehavior.Auto(options: new() { RetainArgumentTypes = true })
};string prompt = “Show me the last four commits to the microsoft/semantic-kernel repo.”;
var result = await kernel.InvokePromptAsync(prompt, new(execSettings));
Console.WriteLine(result);

Semantic Kernel handles selecting and invoking the appropriate function, returning the tool’s output.Microsoft for Developers

Semantic Kernel, MCP, and Agents: Putting It All Together

Above we’ve covered the foundational elements:

  1. Kernel with Azure OpenAI: Provides the LLM backend and orchestration context.

  2. MCP Client: Discovers tool definitions dynamically from the MCP server.

  3. Plugins Registration: Wraps MCP tools as callable kernel functions.

  4. Function Calling: Lets agents dynamically execute tools based on natural language prompts.

This creates a modular, dynamic AI agent architecture—agents are no longer hardcoded with specific APIs but can adapt to tools available via MCP servers.

Agent-Centric Architecture with Semantic Kernel + MCP

To take this further, you can build agents using Semantic Kernel’s agent frameworks that encapsulate tool-calling logic and conversation flows. Semantic Kernel supports several agent types—for example, the AzureAIAgent, designed for advanced conversational scenarios with built-in tool integration.Microsoft Learn

A typical flow:

  1. Build the Kernel and register tools.

  2. Create an agent wrapping the Kernel.

  3. Give the agent prompts or use prebuilt agent frameworks (e.g., AzureAIAgent or OpenAIResponsesAgent).

  4. The agent leverages function calling to operate on-demand with external tools—this includes invoking MCP tools.

Real-World Example: NL→Database Query via MCP + Semantic Kernel

Consider a use case: converting natural language requests into safe database queries. One can expose a Cosmos DB query tool via MCP and integrate it:

  • The LLM generates parameterized SQL.

  • The app validates and executes the query via Cosmos SDK.

  • The tool is exposed via MCP, registered as a Kernel Function.

  • Agents invoke it via natural-language prompts.

This end-to-end integration enables secure, dynamic tool use, embodying true agentic capability.Medium

Extended Scenarios and Advanced Patterns

  • Workshops and Demos: There is a Semantic Kernel workshop repository demonstrating SK + MCP workflows and agent-to-agent (A2A) communication patterns—great hands-on learning.GitHub

  • Pro-Code Agents with MCP: Several blog posts walk through building robust agents in C# using MCP and Semantic Kernel—often tailored to real-world domains.The Developer’s CantinaPravin Chandankhede

  • Protocol Adoption and Ecosystem: MCP is rapidly gaining traction. Wikipedia reports that MCP was launched in November 2024 by Anthropic, and by March–April 2025, Microsoft, OpenAI, Google DeepMind, and others had adopted it as a standard for LLM tool connectivity.Wikipedia

Summary Table

Step Description
1. Setup Kernel Configure Semantic Kernel with Azure OpenAI and logging.
2. Discover Tools Connect to MCP server and list its tools via MCP client.
3. Register Functions Convert tools into KernelFunctions and add to Kernel.
4. Agent Invocation Use LLM prompts; kernel with function-calling dispatches tool.
5. Agent Architectures Wrap Kernel in agents such as AzureAIAgent or OpenAIResponsesAgent.
6. Extendable Pattern Enables dynamic, tool-agnostic agents in real use cases.

Conclusion

Integrating Semantic Kernel with Azure OpenAI and MCP embodies a dynamic, scalable architecture for AI agents. By combining:

  • The orchestration power of Semantic Kernel,

  • The LLM prowess of Azure OpenAI, and

  • The interoperable tool-access framework of Model Context Protocol,

you enable agents that can discover, register, and invoke tools dynamically—without hardcoding APIs. This approach supports modularity, cross-language compatibility, and simplifies maintenance.

Function calling through the Kernel allows LLMs to orchestrate tool execution fluidly. Agents can be as lightweight or complex as required—spanning from simple prompt-based utilities to advanced multi-agent systems where agents talk to other agents using MCP-mediated tools.

Practically, this architecture shines in scenarios like database querying via natural language, system automation, analytics, or any domain where tool access needs to adapt and evolve. The broader MCP ecosystem adoption ensures tools and agents remain interoperable across platforms and tools.

In essence, this integration defines a future-facing paradigm for agentic AI—dynamic, modular, and driven by interoperability standards. Whether you’re developing prototypes or enterprise-grade systems, combining Semantic Kernel, Azure OpenAI, and MCP offers a flexible, robust blueprint for modern AI agents.