Build your first Semantic Kernel Agent

Get started building an agent using semantic kernel

Semantic Kernel

You can get up and running quickly building agents leveraging Semantic Kernel as your orchestration layer. The following code demonstrates how to create an agent group chat that utilizes An Art Director Chat Completion Agent along with a Copy Writer Chat Completion Agent to complete a task. I found this to be one of the more straight forward examples from the Microsoft repo.

Configuring the Kernel

Let's get started with the necessary configuration to run Semantic Kernel. Create a new file named .env and place it in the root directory.

NOTE: Please make sure to include GLOBAL_LLM_SERVICE set to either OpenAI, AzureOpenAI, or HuggingFace in your .env file. If this setting is not included, the Service will default to AzureOpenAI. We will be using AzureOpenAI for this example.

GLOBAL_LLM_SERVICE="AzureOpenAI"
AZURE_OPENAI_API_KEY="..."
AZURE_OPENAI_ENDPOINT="https://..."
AZURE_OPENAI_CHAT_DEPLOYMENT_NAME="..."
AZURE_OPENAI_TEXT_DEPLOYMENT_NAME="..."
AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME="..."
AZURE_OPENAI_API_VERSION="..."

Import Semantic Kernel SDK from pypi.org

pip install -U semantic-kernel

Import the relevant libraries to get started.

import asyncio
 
from semantic_kernel.agents import AgentGroupChat, ChatCompletionAgent
from semantic_kernel.agents.strategies.termination.termination_strategy import TerminationStrategy
from semantic_kernel.connectors.ai.open_ai.services.azure_chat_completion import AzureChatCompletion
from semantic_kernel.contents.chat_message_content import ChatMessageContent
from semantic_kernel.contents.utils.author_role import AuthorRole
from semantic_kernel.kernel import Kernel

You need to be careful when creating agents that loop and they can get into an infinite loop. You need to build in a strategy for determining when an agent should terminate. In this case one and approval is given, then we can terminate as they have completed the task.

class ApprovalTerminationStrategy(TerminationStrategy):
    """A strategy for determining when an agent should terminate."""
 
    async def should_agent_terminate(self, agent, history):
        """Check if the agent should terminate."""
        return "approved" in history[-1].content.lower()

This is where creating good prompts makes a big difference. You need to have an appropriate set of instructions for the personas of the agents. Below we define the "Art Director" and the "CopyWriter" agent and define instructions they should follow. You can test by making changes to these prompts and see how your agents act.

REVIEWER_NAME = "ArtDirector"
REVIEWER_INSTRUCTIONS = """
You are an art director who has opinions about copywriting born of a love for David Ogilvy.
The goal is to determine if the given copy is acceptable to print.
If so, state that it is approved.
If not, provide insight on how to refine suggested copy without example.
"""
 
COPYWRITER_NAME = "CopyWriter"
COPYWRITER_INSTRUCTIONS = """
You are a copywriter with ten years of experience and are known for brevity and a dry humor.
The goal is to refine and decide on the single best copy as an expert in the field.
Only provide a single proposal per response.
You're laser focused on the goal at hand.
Don't waste time with chit chat.
Consider suggestions when refining an idea.
"""

We create a kernel which will excute the chat completion.

def _create_kernel_with_chat_completion(service_id: str) -> Kernel:
    kernel = Kernel()
    kernel.add_service(AzureChatCompletion(service_id=service_id))
    return kernel

This is where we now stich it all together. We create the two agents and add them to an AgentGroupChat and define our termination strategy which we defined above.

async def main():
    agent_reviewer = ChatCompletionAgent(
        service_id="artdirector",
        kernel=_create_kernel_with_chat_completion("artdirector"),
        name=REVIEWER_NAME,
        instructions=REVIEWER_INSTRUCTIONS,
    )
 
    agent_writer = ChatCompletionAgent(
        service_id="copywriter",
        kernel=_create_kernel_with_chat_completion("copywriter"),
        name=COPYWRITER_NAME,
        instructions=COPYWRITER_INSTRUCTIONS,
    )
 
    chat = AgentGroupChat(
        agents=[agent_writer, agent_reviewer],
        termination_strategy=ApprovalTerminationStrategy(agents=[agent_reviewer], maximum_iterations=10),
    )
 
    input = "a slogan for a new line of electric cars."
 
    await chat.add_chat_message(ChatMessageContent(role=AuthorRole.USER, content=input))
    print(f"# {AuthorRole.USER}: '{input}'")
 
    async for content in chat.invoke():
        print(f"# {content.role} - {content.name or '*'}: '{content.content}'")
 
    print(f"# IS COMPLETE: {chat.is_complete}")

Finally we can execute the main function.

if __name__ == "__main__":
    asyncio.run(main())

And thats it...you have built your first agent using Semantic Kernel. It provides a powerful orchestration layer that helps you quickly get up and running and you can spend time focusing on the business logic.

Check out the Microsoft Docs to get more information on Semantic Kernel.