Semantic Kernel Cookbook

The Semantic Kernel Cookbook is a learning resource designed to help developers integrate Large Language Models (LLMs) into traditional engineering and multi-language projects. It provides implementation guidance and code samples for Semantic Kernel across three primary languages: .NET, Python, and Java.

Key focus areas include:

• Azure OpenAI Service integration using SDKs.
• Semantic Kernel Foundations: Core concepts and advantages.
• Plugins: Implementing business-oriented prompt engineering.
• Planner: Enabling LLMs to perform multi-step task planning.
• Embeddings: Building Retrieval-Augmented Generation (RAG) applications.

Note: The content is based on specific versions:

• .NET: 1.16.2
• Python: 1.3.0
• Java: 1.2.0

This curriculum focuses on classical machine learning using the Scikit-learn library. It is designed to provide a fundamental understanding of pattern discovery from data without the complexity of deep learning.

What is covered:

• Core concepts of machine learning and its history.
• ML fairness.
• Regression techniques.
• Classification techniques.
• Clustering techniques.
• Natural Language Processing (NLP).
• Time series forecasting.
• Reinforcement learning.
• Real-world applications.

What is NOT covered:

• Deep learning (multi-layered model building using neural networks).
• Neural networks.
• Artificial Intelligence (AI) as a broad field.

The curriculum covers the following core concepts of classical machine learning using Scikit-learn:

• Core concepts and history of ML
• ML and fairness
• Regression techniques
• Classification techniques
• Clustering techniques
• Natural Language Processing (NLP) techniques
• Time series forecasting
• Reinforcement learning
• Real-world applications

This cookbook primarily focuses on using models provided via Azure OpenAI Services, specifically:

• OpenAI models: GPT-3, GPT-3.5, and GPT-4
• DALL·E models: DALL·E-3

A Planner is a core component in Semantic Kernel designed to decompose complex, multi-step natural language instructions into a sequence of actionable steps. It works by mapping a user's high-level task (e.g., "Check the weather and email the travelers") to existing plugins (both built-in and custom) that have been registered with the Kernel.

Instead of requiring a developer to manually code every step of a workflow, the Planner analyzes the available plugins and orchestrates them to fulfill the intent of the prompt.

Semantic Kernel is a lightweight open-source framework designed to integrate Large Language Models (LLMs) like OpenAI, Azure OpenAI, and Hugging Face into applications using C#, Python, or Java. It serves as an orchestration layer (part of the 'Copilot Stack') that allows developers to combine LLMs with prompt engineering and software plugins.

Key features include:

• Powerful Plugins: Combine custom or predefined code with intelligent plugins to solve business problems.
• Multi-model Support: Easily switch between different 'brains' (models) using connectors.
• Diverse Connectors: Link your application to vector databases, commercial software, and business middleware.
• Developer Friendly: Designed for seamless integration into traditional engineering workflows.

The Planner is a core component of Semantic Kernel designed to decompose complex, multi-step natural language instructions into a sequence of actionable steps. Instead of executing a single task, the Planner analyzes a user's goal and orchestrates existing built-in or custom plugins registered in the Kernel to complete the work step-by-step.

Example Workflow: For an instruction like "Send a dressing reminder email to people on business trips based on the weather in Seattle", the Planner identifies and executes the following logical steps:

1. Check the weather in Seattle.
2. Query business travelers and contact info from the company system.
3. Prepare the reminder email template.
4. Send the email.

The Transformer algorithm is a deep learning architecture based on the self-attention mechanism, used for processing natural language and other sequence data. Unlike Recurrent Neural Networks (RNNs) or Convolutional Neural Networks (CNNs), Transformers can process entire sequences in parallel and are highly effective at capturing long-distance dependencies.

Architecture Components:

• Encoder and Decoder: The model consists of these two main parts.
• Multi-Head Self-Attention: Allows the model to focus on different parts of the input sequence simultaneously.
• Feed-Forward Neural Networks: Layers within each part of the architecture.

Notable Transformer-based Models:

• BERT
• GPT-3 / GPT-4
• T5

Choosing between Semantic Kernel and LangChain depends on your team's expertise and technical stack:

Plugins are modular functional units that extend the capabilities of a Large Language Model (LLM). While LLMs have knowledge cutoffs and limited real-time access, plugins allow the model to:

1. Retrieve real-time information (e.g., weather, stock prices).
2. Access private knowledge bases (e.g., company documents, personal notes).
3. Perform actions (e.g., booking flights, sending emails).

In Semantic Kernel, plugins act as the building blocks (like Lego modules) that can be combined to solve complex business requirements. For example, a high-level instruction like "Send an email to managers whose contracts are expiring" can be fulfilled by combining a Contract plugin, a Managers plugin, and an HRMail plugin.

Model fitting refers to how accurately the model's underlying function analyzes data. Two common failure modes are:

• Overfitting: The model learns the training data's details and noise too well. It performs excellently on training data but fails to generalize to new, unseen data.
• Underfitting: The model is too simple to capture the underlying patterns. It performs poorly on both the training data and unseen data.