added questions 13 and 14 answers in AI

Author: rcallaby

Artificial-Intelligence/AI-Question13.md

@@ -1 +1,123 @@
-# AI - Question13 - Describe the "Planner" concept in Microsoft’s Semantic Kernel. How does it allow an AI to autonomously choose which C# methods to execute to solve a complex goal?
+# AI - Question13 - Describe the "Planner" concept in Microsoft’s Semantic Kernel. How does it allow an AI to autonomously choose which C# methods to execute to solve a complex goal?
+
+**In modern Semantic Kernel (as of 2025–2026), the dedicated "Planner" classes** (such as the old Sequential, Stepwise, and Handlebars Planners) have been deprecated and removed from the core package. The recommended and far more powerful approach is **automatic function calling** (also called tool calling) integrated directly with the `Kernel` and chat completion services. This mechanism effectively *is* the current Planner.
+
+### What is the Planner Concept?
+A **Planner** in Semantic Kernel is an orchestration component that enables an LLM to break down a complex natural-language **goal** into a sequence of executable steps by intelligently selecting and invoking registered **plugins** (collections of functions). These functions can be:
+
+- **Native Functions**: Plain C# methods decorated with `[KernelFunction]`.
+- **Prompt Functions**: Semantic prompts defined in YAML or inline.
+
+The AI autonomously decides *which* C# methods to call, *in what order*, with *what parameters*, and can iterate (observe results and replan) until the goal is achieved.
+
+**Mermaid: Modern Function-Calling Planner Flow**
+```mermaid
+flowchart TD
+    A["User Goal<br/>'Book a meeting and summarize notes'"] --> B[Kernel + Chat Service]
+    C["LLM receives Function Schemas<br/>(JSON descriptions of all C# methods)"] --> D{LLM Decides}
+    B --> C
+    D -->|Needs info| E["Call C# Method e.g. GetCalendar()"]
+    D -->|Action ready| F["Call C# Method e.g. CreateEvent()"]
+    E --> G[Execute Native C# Code]
+    F --> G
+    G --> H[Return Result to LLM]
+    H --> I[LLM Evaluates + Next Step or Final Answer]
+    I -->|Not Done| B
+    I -->|Goal Achieved| J[Return Final Response]
+```
+
+### How It Allows Autonomous C# Method Execution
+
+1. **Function Exposure**: You register plugins. Semantic Kernel automatically generates detailed JSON schemas (including descriptions, parameter types, and `KernelFunction` attributes) for the LLM.
+
+2. **Automatic Tool Choice**: Set `FunctionChoiceBehavior.Auto()` (or `Required`/`None`). The LLM receives these schemas in every request.
+
+3. **Iterative Execution Loop**: SK handles the full ReAct-style loop internally:
+   - LLM requests one or more function calls (parallel supported).
+   - SK invokes the corresponding C# methods.
+   - Results are injected back into the chat history.
+   - LLM decides the next action or produces a final answer.
+
+This gives the AI true autonomy while keeping all business logic safely in your strongly-typed C# code.
+
+### Code Example: Autonomous Planning via Function Calling
+```csharp
+using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.ChatCompletion;
+using Microsoft.SemanticKernel.Connectors.OpenAI;
+
+public class CalendarPlugin
+{
+    [KernelFunction("GetUpcomingEvents")]
+    [Description("Retrieves upcoming calendar events")]
+    public async Task<string> GetUpcomingEventsAsync()
+    {
+        // Real implementation (Outlook, Google, etc.)
+        return "Team sync at 10am tomorrow";
+    }
+
+    [KernelFunction("CreateEvent")]
+    [Description("Creates a new calendar event")]
+    public async Task<string> CreateEventAsync(string title, string dateTime, string attendees)
+    {
+        // Business logic here
+        return $"Event '{title}' created successfully.";
+    }
+}
+
+// Setup
+var builder = Kernel.CreateBuilder()
+    .AddAzureOpenAIChatCompletion("gpt-4o", endpoint, apiKey);
+
+builder.Plugins.AddFromType<CalendarPlugin>("Calendar");
+Kernel kernel = builder.Build();
+
+var chatService = kernel.GetRequiredService<IChatCompletionService>();
+
+// Enable autonomous planning
+var executionSettings = new OpenAIPromptExecutionSettings
+{
+    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()  // This is the Planner
+};
+
+var history = new ChatHistory();
+history.AddUserMessage("Schedule a 30-minute sync with the team tomorrow at 10am and confirm availability.");
+
+var result = await chatService.GetChatMessageContentAsync(
+    history, 
+    executionSettings, 
+    kernel);  // SK handles multiple tool calls automatically
+
+Console.WriteLine(result);
+```
+
+**Mermaid: Single Interaction with Autonomous Steps**
+```mermaid
+sequenceDiagram
+    participant User
+    participant SK Kernel
+    participant LLM
+    participant CSharpCode as C# Plugin Methods
+
+    User->>SK Kernel: Complex Goal
+    SK Kernel->>LLM: Goal + All Function Schemas
+    LLM->>SK Kernel: Call GetUpcomingEvents()
+    SK Kernel->>CSharpCode: Execute method
+    CSharpCode-->>SK Kernel: Result
+    SK Kernel->>LLM: Result injected
+    LLM->>SK Kernel: Call CreateEvent(title, time, attendees)
+    SK Kernel->>CSharpCode: Execute method
+    CSharpCode-->>SK Kernel: Success
+    SK Kernel->>User: Final natural language response
+```
+
+### Key Advantages
+- **Autonomy**: The LLM dynamically composes solutions using your C# logic without hard-coded workflows.
+- **Safety**: All execution stays within your controlled C# methods (no arbitrary code gen in production).
+- **Observability**: Full chat history shows every tool call and result.
+- **Extensibility**: Combine with `Microsoft.Extensions.AI`, memory/vector stores (RAG), and agents.
+- **Performance**: Leverages native function calling in modern models (OpenAI, Azure, Anthropic, etc.) — faster and more reliable than old prompt-based planners.
+
+**Note on Legacy Planners**: Older `HandlebarsPlanner` and `StepwisePlanner` are no longer recommended or included by default. Microsoft now directs developers to function calling for new applications due to superior flexibility, streaming support, and accuracy.
+
+This function-calling planner pattern is the foundation of modern agentic applications in Semantic Kernel. It transforms static C# methods into dynamic, AI-orchestrated capabilities while maintaining full type safety and enterprise control. For the latest patterns, refer to the official Microsoft Learn documentation on Semantic Kernel planning and function calling.

Artificial-Intelligence/AI-Question14.md

@@ -1 +1,146 @@
-# AI - Question 14 - How would you design a DI-friendly service that can swap between local LlamaEdge models and OpenAI cloud models without changing the business logic?
+# AI - Question 14 - How would you design a DI-friendly service that can swap between local LlamaEdge models and OpenAI cloud models without changing the business logic?
+
+**Use `Microsoft.Extensions.AI` abstractions** (`IChatClient` and `IEmbeddingGenerator<TInput, TEmbedding>`) for a clean, DI-friendly, provider-agnostic design. This allows seamless swapping between cloud OpenAI and local models (via Ollama for Llama models or LlamaEdge’s OpenAI-compatible server) without altering business logic.
+
+### Core Design Principle
+Code against the **abstractions** (`IChatClient`). Register the concrete implementation (OpenAI, Azure, Ollama, etc.) in the DI container via configuration or environment. Middleware (logging, retry, telemetry, function calling) applies uniformly.
+
+**Provider-Agnostic Architecture**
+```mermaid
+flowchart TD
+    A[Business Services] --> B[IChatClient Interface]
+    C["Middleware Pipeline<br/>(Logging, Caching, FunctionCalling, OTEL)"] --> D{Configuration}
+    B --> C
+    D -->|Production| E["OpenAIChatClient / Azure"]
+    D -->|Development / Edge| F["OllamaChatClient / LlamaEdge via OpenAI endpoint"]
+    E --> G[Cloud LLM]
+    F --> H[Local Llama Model]
+    style B fill:#90EE90
+```
+
+### DI Registration (Program.cs / Startup)
+```csharp
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Configuration;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Read configuration
+var aiSettings = builder.Configuration.GetSection("AI").Get<AISettings>() ?? new();
+
+IChatClient chatClient;
+
+if (aiSettings.UseLocalModel)
+{
+    // Local: Ollama (recommended for Llama models)
+    chatClient = new OllamaChatClient(
+        new Uri(aiSettings.LocalEndpoint ?? "http://localhost:11434"),
+        aiSettings.LocalModel ?? "llama3.2");
+    
+    // Alternative: LlamaEdge (OpenAI-compatible server)
+    // chatClient = new OpenAIChatClient(
+    //     new OpenAIClient(new ApiKeyCredential("ignored"), new OpenAIClientOptions
+    //     {
+    //         Endpoint = new Uri(aiSettings.LocalEndpoint)
+    //     }))
+    //     .GetChatClient(aiSettings.LocalModel);
+}
+else
+{
+    // Cloud
+    chatClient = new OpenAIChatClient(aiSettings.OpenAIModel, aiSettings.ApiKey);
+    // Or Azure: new AzureOpenAIChatClient(...)
+}
+
+// Add to DI with middleware
+builder.Services.AddChatClient(chatClient)
+    .UseLogging()
+    .UseFunctionInvocation()      // For tool calling / agents
+    .UseOpenTelemetry();          // Observability
+
+// Optional: Keyed services for multiple models
+// builder.Services.AddKeyedChatClient("local", localClient);
+// builder.Services.AddKeyedChatClient("cloud", cloudClient);
+```
+
+**Configuration Example (appsettings.json):**
+```json
+{
+  "AI": {
+    "UseLocalModel": true,
+    "LocalEndpoint": "http://localhost:11434",
+    "LocalModel": "llama3.2",
+    "OpenAIModel": "gpt-4o",
+    "ApiKey": "sk-..."
+  }
+}
+```
+
+### DI-Friendly Service (No Provider Awareness)
+```csharp
+public interface IRagService
+{
+    Task<string> AnswerQuestionAsync(string question, CancellationToken ct = default);
+}
+
+public class RagService : IRagService
+{
+    private readonly IChatClient _chatClient;
+    private readonly IEmbeddingGenerator<string, Embedding<float>> _embeddingGenerator; // Optional for RAG
+
+    public RagService(IChatClient chatClient, IEmbeddingGenerator<string, Embedding<float>> embeddingGenerator)
+    {
+        _chatClient = chatClient;
+        _embeddingGenerator = embeddingGenerator;
+    }
+
+    public async Task<string> AnswerQuestionAsync(string question, CancellationToken ct = default)
+    {
+        // Business logic stays identical regardless of provider
+        var history = new ChatHistory();
+        history.AddUserMessage(question);
+
+        // Optional: RAG retrieval using embeddings...
+
+        var response = await _chatClient.GetResponseAsync(
+            history,
+            new ChatOptions { Temperature = 0.7f },
+            ct);
+
+        return response.Message.Text ?? string.Empty;
+    }
+}
+
+// Registration
+builder.Services.AddScoped<IRagService, RagService>();
+```
+
+**Mermaid: Service Dependency Flow**
+```mermaid
+flowchart TD
+    subgraph "Business Layer"
+        A[RagService / Agents] --> B[IChatClient]
+        A --> C[IEmbeddingGenerator]
+    end
+    subgraph "DI Container"
+        B --> D[OpenAI Implementation]
+        B --> E[Ollama / LlamaEdge Implementation]
+    end
+    D --> F[Cloud]
+    E --> G[Local Llama]
+```
+
+### Key Benefits
+- **Zero business logic changes** when switching providers.
+- **Middleware reuse** — logging, retry, caching, and function calling work for both local and cloud.
+- **Environment-specific** behavior via configuration (local for dev/privacy, cloud for production scale/quality).
+- **Streaming support** remains identical using `IAsyncEnumerable<StreamingChatCompletionUpdate>`.
+- **Semantic Kernel compatibility** — SK works natively on top of `IChatClient`.
+
+### Local Model Notes (Llama)
+- **Ollama** is the most common, stable choice for Llama models in .NET via `OllamaSharp` / `Microsoft.Extensions.AI.Ollama` (or successor packages).
+- **LlamaEdge** exposes an OpenAI-compatible endpoint, so the standard `OpenAIChatClient` with a custom `Endpoint` works perfectly.
+- For pure native execution without a server, consider LLamaSharp or ONNX Runtime GenAI with custom wrappers implementing `IChatClient`.
+
+This design follows official Microsoft recommendations for provider-agnostic .NET AI applications. It scales from development (fast local iteration) to production (cloud reliability) while keeping your core application code clean and maintainable. Always test model-specific behaviors (context length, tool calling quality) when swapping. Refer to Microsoft Learn documentation for `Microsoft.Extensions.AI` for the latest configuration patterns.