Building Intelligent Agents with Semantic Kernel: A Comprehensive Guide
Developers are constantly seeking efficient ways to integrate large language models (LLMs) into their applications. Microsoft’s Semantic Kernel provides a powerful framework for building AI agents that can collaborate to solve complex problems. In this comprehensive guide, we’ll explore how to build intelligent multi-agent systems using Semantic Kernel, with a focus on the Creative Writing Assistant example.
What is Semantic Kernel?
Semantic Kernel is a lightweight, open-source development kit that lets you easily build AI agents and integrate the latest AI models into your codebase. It serves as efficient middleware that enables rapid delivery of enterprise-grade solutions.
One of the key advantages of using Semantic Kernel is that it allows you to:
- Easily integrate with different LLM providers (Azure OpenAI, OpenAI, etc.)
- Develop modular AI capabilities through plugins
- Create autonomous and collaborative agents
- Orchestrate complex workflows between multiple agents
Understanding AI Agents
Before diving into the implementation details, let’s clarify what we mean by “AI agents” in this context:
An AI agent is a software entity designed to perform tasks autonomously or semi-autonomously by receiving input, processing information, and taking actions to achieve specific goals. Unlike simple LLM-powered chatbots, agents can:
- Make decisions based on context and goals
- Use tools and functions to interact with external systems
- Work collaboratively with other agents
- Adapt to changing conditions and requirements
Agent Architecture in Semantic Kernel
Semantic Kernel’s agent framework is built on several key principles:
The Agent Framework was developed with key priorities in mind: The Semantic Kernel framework serves as the core foundation for implementing agent functionalities. Multiple agents can collaborate within a single conversation, while integrating human input.
Let’s visualize the high-level architecture of a multi-agent system built with Semantic Kernel:
graph TD
User[User] --> |Prompt/Request| Orchestrator[Orchestrator Agent]
Orchestrator --> |Delegate Task 1| Agent1[Specialized Agent 1]
Orchestrator --> |Delegate Task 2| Agent2[Specialized Agent 2]
Orchestrator --> |Delegate Task 3| Agent3[Specialized Agent 3]
Agent1 --> |Result| Orchestrator
Agent2 --> |Result| Orchestrator
Agent3 --> |Result| Orchestrator
Orchestrator --> |Final Response| User
subgraph "Semantic Kernel Infrastructure"
Orchestrator
Agent1
Agent2
Agent3
end
subgraph "External Resources"
Agent1 --> |Use| Tool1[Tool/Plugin 1]
Agent2 --> |Use| Tool2[Tool/Plugin 2]
Agent3 --> |Use| Tool3[Tool/Plugin 3]
end
Case Study: Creative Writing Assistant
To illustrate how multi-agent systems work in practice, let’s examine the Creative Writing Assistant example from the aspire-semantic-kernel-creative-writer repository. This project demonstrates a collaborative writing system where multiple agents work together to create polished content.
System Overview
The Creative Writing Assistant is built using:
- .NET Aspire - For cloud-native application development
- Semantic Kernel - For agent orchestration and LLM integration
- Microsoft AI Chat Protocol - For handling chat interactions
The application consists of a WebAPI backend and a React frontend, with the backend handling the complex agent interactions.
Multi-Agent Architecture
Let’s visualize the specific architecture of the Creative Writing Assistant:
graph TD
User[User] --> |Writing Request| Manager[Writing Manager]
Manager --> |Research Task| Researcher[Research Agent]
Manager --> |Writing Task| Writer[Writer Agent]
Manager --> |Review Task| Reviewer[Review Agent]
Researcher --> |Research Results| Manager
Writer --> |Draft Content| Manager
Reviewer --> |Feedback| Manager
Manager --> |Final Article| User
Researcher --> |Query| VectorDB[Vector Database]
VectorDB --> |Results| Researcher
subgraph "Agent System"
Manager
Researcher
Writer
Reviewer
end
subgraph "External Services"
VectorDB
AzureOpenAI[Azure OpenAI Service]
end
Manager -.-> AzureOpenAI
Researcher -.-> AzureOpenAI
Writer -.-> AzureOpenAI
Reviewer -.-> AzureOpenAI
Agent Roles and Responsibilities
In the Creative Writing Assistant, each agent has a specific role:
- Writing Manager: Coordinates the overall process, delegates tasks, and ensures the final output meets requirements
- Research Agent: Gathers relevant information about the topic from various sources, including vector databases
- Writer Agent: Creates the initial draft based on research and requirements
- Review Agent: Provides feedback and suggests improvements to the draft
Building Your Own Multi-Agent System
Now, let’s walk through the process of building your own multi-agent system using Semantic Kernel:
Step 1: Setting Up the Environment
First, ensure you have the necessary prerequisites:
- .NET SDK (version 8.0 or newer)
- Azure subscription (for Azure OpenAI Service)
- Azure OpenAI Service instance
Step 2: Creating the Project Structure
Set up a new .NET project with the required packages:
dotnet new webapi -n YourAgentApp
cd YourAgentApp
dotnet add package Microsoft.SemanticKernel
dotnet add package Microsoft.SemanticKernel.Agents
Step 3: Defining Agent Roles
Each agent needs clear instructions about its role and responsibilities. These instructions shape the agent’s behavior and decision-making process.
// Define agent instructions
var managerInstructions = @"
You are the Writing Manager, responsible for coordinating the writing process.
Your job is to understand the user's requirements, delegate tasks to specialized agents,
and ensure the final output meets the user's expectations.
";
var researcherInstructions = @"
You are the Research Agent, responsible for gathering relevant information.
Your job is to search for information about the topic and provide factual, accurate data
that will be used to create the content.
";
var writerInstructions = @"
You are the Writer Agent, responsible for creating engaging content.
Your job is to take the research results and requirements to craft a well-structured,
engaging piece of content that meets the user's needs.
";
var reviewerInstructions = @"
You are the Review Agent, responsible for quality control.
Your job is to review the content, provide feedback, and suggest improvements
to ensure the final output is polished and meets all requirements.
";
Step 4: Creating the Agents
Use Semantic Kernel to create each agent based on their instructions:
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;
// Create kernel and configure AI service
var builder = Kernel.CreateBuilder()
.AddAzureOpenAIChatCompletion(
deploymentName: "gpt-4o",
endpoint: "https://your-endpoint.openai.azure.com/",
apiKey: "your-api-key");
var kernel = builder.Build();
// Create the agents
var manager = new ChatCompletionAgent(
kernel,
"WritingManager",
managerInstructions
);
var researcher = new ChatCompletionAgent(
kernel,
"ResearchAgent",
researcherInstructions
);
var writer = new ChatCompletionAgent(
kernel,
"WriterAgent",
writerInstructions
);
var reviewer = new ChatCompletionAgent(
kernel,
"ReviewerAgent",
reviewerInstructions
);
Step 5: Setting Up Plugins
Plugins extend agent capabilities by providing tools they can use:
// Create a vector search plugin
var vectorSearchPlugin = kernel.CreatePluginFromFunctions(
"VectorSearch",
new List<KernelFunction>
{
kernel.CreateFunctionFromMethod(
(string query) =>
{
// Implement vector search logic here
return "Search results for: " + query;
},
"SearchVector",
"Search for information in the vector database")
}
);
// Add the plugin to the researcher agent
researcher.AddPlugin(vectorSearchPlugin);
Step 6: Implementing Agent Communication
The next step is to implement the communication flow between agents:
sequenceDiagram
participant User
participant Manager
participant Researcher
participant Writer
participant Reviewer
User->>Manager: Request article on topic
Manager->>Researcher: Request research on topic
Researcher-->>Manager: Provide research findings
Manager->>Writer: Request draft with research
Writer-->>Manager: Provide initial draft
Manager->>Reviewer: Request review of draft
Reviewer-->>Manager: Provide feedback
Manager->>Writer: Request revisions based on feedback
Writer-->>Manager: Provide revised draft
Manager-->>User: Deliver final article
Step 7: Orchestrating the Multi-Agent Workflow
The final piece is orchestrating the workflow between agents:
public async Task<string> CreateContentAsync(string userRequest)
{
// Start with the manager
var managerChat = manager.NewChat();
await managerChat.AddUserMessageAsync(userRequest);
var managerResponse = await managerChat.GetChatCompletionsAsync();
// Manager delegates to researcher
var researchChat = researcher.NewChat();
await researchChat.AddUserMessageAsync($"Research this topic: {userRequest}");
var researchResults = await researchChat.GetChatCompletionsAsync();
// Manager sends research to writer
await managerChat.AddUserMessageAsync($"Research results: {researchResults}");
await managerChat.GetChatCompletionsAsync();
// Manager delegates to writer
var writerChat = writer.NewChat();
await writerChat.AddUserMessageAsync($"Write content about {userRequest} based on this research: {researchResults}");
var initialDraft = await writerChat.GetChatCompletionsAsync();
// Manager sends draft to reviewer
var reviewerChat = reviewer.NewChat();
await reviewerChat.AddUserMessageAsync($"Review this draft: {initialDraft}");
var reviewFeedback = await reviewerChat.GetChatCompletionsAsync();
// Manager sends feedback to writer for revision
await writerChat.AddUserMessageAsync($"Revise the draft based on this feedback: {reviewFeedback}");
var finalDraft = await writerChat.GetChatCompletionsAsync();
// Manager delivers final result
await managerChat.AddUserMessageAsync($"Final draft completed: {finalDraft}");
var finalResponse = await managerChat.GetChatCompletionsAsync();
return finalDraft;
}
Advanced Multi-Agent Patterns
When building a multi-agent scenario, you need to define a termination logic. This logic determines when the conversation is completed and the chat between the agents must end. Semantic Kernel provides several termination strategies, including:
- Fixed rounds termination: Ends after a specific number of interactions
- Function-based termination: Uses a function to determine when to stop
- KeyWord termination: Ends when a specific keyword appears
Here’s how you can implement a function-based termination strategy:
// Create termination logic using a kernel function
var terminationFunction = kernel.CreateFunctionFromPrompt(@"
Analyze the conversation history:
Determine if the final content meets all requirements and is ready for delivery.
If the content is ready, respond with 'DONE'.
Otherwise, respond with 'CONTINUE'.
");
// Create the termination strategy
var terminationStrategy = new KernelFunctionTerminationStrategy(
terminationFunction,
"DONE"
);
// Configure group chat with termination strategy
var groupChat = new GroupChat(
new List<IChatAgent> { manager, researcher, writer, reviewer },
manager, // Coordinator agent
terminationStrategy
);
Evaluating Agent Performance
To ensure your multi-agent system delivers high-quality results, it’s essential to implement evaluation metrics. The Creative Writing Assistant example uses four key metrics:
- Coherence: How well the content flows and maintains consistency
- Fluency: The quality of language and readability
- Relevance: How well the content addresses the requested topic
- Groundedness: Whether the content is factually accurate and well-supported
These evaluations can be automated using Semantic Kernel’s evaluation framework:
// Create an evaluator agent
var evaluatorInstructions = @"
You are an Evaluation Agent responsible for assessing content quality.
Rate the content on a scale of 1-10 for each of these criteria:
- Coherence: How well the content flows and maintains consistency
- Fluency: The quality of language and readability
- Relevance: How well the content addresses the requested topic
- Groundedness: Whether the content is factually accurate and well-supported
";
var evaluator = new ChatCompletionAgent(
kernel,
"EvaluatorAgent",
evaluatorInstructions
);
// Evaluate content
public async Task<string> EvaluateContentAsync(string content, string originalRequest)
{
var evaluatorChat = evaluator.NewChat();
await evaluatorChat.AddUserMessageAsync($@"
Original request: {originalRequest}
Content to evaluate: {content}
Provide ratings and justification for each criterion.
");
return await evaluatorChat.GetChatCompletionsAsync();
}
Deploying Multi-Agent Systems
When you’re ready to deploy your multi-agent system, there are several options available:
1. Azure Deployment
The Creative Writing Assistant example uses Azure for deployment:
graph TD
Client[Client Browser] --> |HTTP| APIM[Azure API Management]
APIM --> |HTTP| ACR[Azure Container Apps]
ACR --> |Fetch| AzCR[Azure Container Registry]
ACR --> |Query| AOAI[Azure OpenAI Service]
ACR --> |Search| AIS[Azure AI Search]
subgraph "Azure Resources"
APIM
ACR
AzCR
AOAI
AIS
KV[Azure Key Vault]
end
ACR --> |Secrets| KV
2. Local Development with Aspire
For local development, the project uses .NET Aspire to simplify the experience:
# Navigate to AppHost directory
cd ChatApp.AppHost
# Run the application
dotnet run
Best Practices for Building Multi-Agent Systems
Based on the Creative Writing Assistant example and other best practices, here are some recommendations for building effective multi-agent systems:
-
Clear Agent Instructions: Each agent should have clear, specific instructions about its role and responsibilities.
-
Modular Design: Design your agents with specific focuses rather than creating “do everything” agents.
-
Effective Communication Flow: Design a clear communication pattern between agents to avoid confusion.
-
Termination Logic: Implement robust termination strategies to avoid infinite loops.
-
Error Handling: Implement fallback mechanisms for when agents fail to complete their tasks.
-
Evaluation Metrics: Establish clear metrics to evaluate agent performance.
-
Resource Management: Monitor and optimize resource usage, especially token consumption.
Conclusion
Building intelligent multi-agent systems with Semantic Kernel opens up new possibilities for creating sophisticated AI applications. By leveraging the framework’s capabilities, developers can create collaborative agent systems that tackle complex tasks through division of labor and specialization.
The Creative Writing Assistant is just one example of what’s possible. The same patterns can be applied to various domains such as customer service, data analysis, decision support systems, and more.
As you embark on your journey with Semantic Kernel and multi-agent systems, remember that effective agent design is as much about communication patterns and clear role definition as it is about technical implementation.
Resources
For more information about Semantic Kernel and agent development, check out these resources:
- Semantic Kernel Documentation
- Semantic Kernel Agent Framework Documentation
- Semantic Kernel GitHub Repository
- Creative Writing Assistant Example
Saptak Sen
If you enjoyed this post, you should check out my book: Starting with Spark.