diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 7732715..c3564b9 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,14 +1,19 @@
-name: CI
+name: Build
 
 on:
   push:
     branches: [main]
   pull_request:
-    branches: [main]
+    branches: [main, dev]
+  release:
+    types: [created, published]
+
+permissions:
+  contents: write
 
 jobs:
   build-and-test:
-    runs-on: ubuntu-latest
+    runs-on: windows-latest
 
     steps:
       - uses: actions/checkout@v4
@@ -34,3 +39,51 @@ jobs:
 
       - name: Run tests
         run: dotnet test tests/PlanViewer.Core.Tests/PlanViewer.Core.Tests.csproj -c Release --no-build --verbosity normal
+
+      - name: Get version
+        id: version
+        shell: pwsh
+        run: |
+          $version = ([xml](Get-Content src/PlanViewer.App/PlanViewer.App.csproj)).Project.PropertyGroup.Version | Where-Object { $_ }
+          echo "VERSION=$version" >> $env:GITHUB_OUTPUT
+
+      - name: Publish App
+        run: dotnet publish src/PlanViewer.App/PlanViewer.App.csproj -c Release -o publish/App
+
+      - name: Publish CLI
+        run: dotnet publish src/PlanViewer.Cli/PlanViewer.Cli.csproj -c Release -o publish/Cli
+
+      - name: Package release artifacts
+        if: github.event_name == 'release'
+        shell: pwsh
+        run: |
+          $version = "${{ steps.version.outputs.VERSION }}"
+          New-Item -ItemType Directory -Force -Path releases
+
+          # App ZIP
+          if (Test-Path 'README.md') { Copy-Item 'README.md' 'publish/App/' }
+          if (Test-Path 'LICENSE') { Copy-Item 'LICENSE' 'publish/App/' }
+          Compress-Archive -Path 'publish/App/*' -DestinationPath "releases/PerformanceStudio-$version.zip" -Force
+
+          # CLI ZIP
+          if (Test-Path 'LICENSE') { Copy-Item 'LICENSE' 'publish/Cli/' }
+          Compress-Archive -Path 'publish/Cli/*' -DestinationPath "releases/PerformanceStudioCli-$version.zip" -Force
+
+      - name: Generate checksums
+        if: github.event_name == 'release'
+        shell: pwsh
+        run: |
+          $checksums = Get-ChildItem releases/*.zip | ForEach-Object {
+            $hash = (Get-FileHash $_.FullName -Algorithm SHA256).Hash.ToLower()
+            "$hash  $($_.Name)"
+          }
+          $checksums | Out-File -FilePath releases/SHA256SUMS.txt -Encoding utf8
+          Write-Host "Checksums:"
+          $checksums | ForEach-Object { Write-Host $_ }
+
+      - name: Upload release assets
+        if: github.event_name == 'release'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release upload ${{ github.event.release.tag_name }} releases/*.zip releases/SHA256SUMS.txt --clobber
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 8f8390e..ee7999f 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,6 +1,6 @@
-# Contributing to SQL Performance Studio
+# Contributing to Performance Studio
 
-Thank you for your interest in contributing to SQL Performance Studio! This guide will help you get started.
+Thank you for your interest in contributing to Performance Studio! This guide will help you get started.
 
 ## Reporting Issues
 
diff --git a/README.md b/README.md
index f8f3da1..b6d582e 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
-# SQL Performance Studio
+# Performance Studio
 
-A cross-platform SQL Server execution plan analyzer. Parses `.sqlplan` XML, identifies performance problems, suggests missing indexes, and provides actionable warnings — from the command line or a desktop GUI.
+A cross-platform SQL Server execution plan analyzer with built-in MCP server for AI-assisted analysis. Parses `.sqlplan` XML, identifies performance problems, suggests missing indexes, and provides actionable warnings — from the command line or a desktop GUI.
 
 Built for developers and DBAs who want fast, automated plan analysis without clicking through SSMS.
 
@@ -139,7 +139,7 @@ planview analyze ./queries/ --server sql2022 --database StackOverflow2013 \
 ```
 
 Batch mode produces three files per query:
-- `query_name.sqlplan` — the raw execution plan XML (openable in SSMS or the SQL Performance Studio GUI)
+- `query_name.sqlplan` — the raw execution plan XML (openable in SSMS or the Performance Studio GUI)
 - `query_name.analysis.json` — structured analysis with warnings, missing indexes, and operator tree
 - `query_name.analysis.txt` — human-readable text report
 
@@ -240,6 +240,7 @@ Features:
 - **Copy Repro Script** — extracts parameters, SET options, and query text into a runnable `sp_executesql` script
 - **Get Actual Plan** — connect to a server and re-execute the query to capture runtime stats
 - **Query Store Analysis** — connect to a server and analyze top queries by CPU, duration, or reads
+- **MCP Server** — built-in Model Context Protocol server for AI-assisted plan analysis (opt-in)
 - Dark theme
 
 ```bash
@@ -248,14 +249,14 @@ dotnet run --project src/PlanViewer.App
 
 ## SSMS Extension
 
-A VSIX extension that adds **"Open in SQL Performance Studio"** to the execution plan right-click context menu in SSMS 18-22.
+A VSIX extension that adds **"Open in Performance Studio"** to the execution plan right-click context menu in SSMS 18-22.
 
 ### How it works
 
 1. Right-click on any execution plan in SSMS
-2. Click "Open in SQL Performance Studio"
+2. Click "Open in Performance Studio"
 3. The extension extracts the plan XML via reflection and saves it to a temp file
-4. SQL Performance Studio opens with the plan loaded
+4. Performance Studio opens with the plan loaded
 
 ### Installation
 
@@ -267,13 +268,55 @@ A VSIX extension that adds **"Open in SQL Performance Studio"** to the execution
 
 ### First run
 
-On first use, if SQL Performance Studio isn't found automatically, the extension will prompt you to locate `PlanViewer.App.exe`. The path is saved to the registry (`HKCU\SOFTWARE\DarlingData\SQLPerformanceStudio\InstallPath`) so you only need to do this once.
+On first use, if Performance Studio isn't found automatically, the extension will prompt you to locate `PlanViewer.App.exe`. The path is saved to the registry (`HKCU\SOFTWARE\DarlingData\SQLPerformanceStudio\InstallPath`) so you only need to do this once.
 
 The extension searches for the app in this order:
 1. Registry key (set automatically after first browse)
 2. System PATH
 3. Common install locations (`%LOCALAPPDATA%\Programs\SQLPerformanceStudio\`, `Program Files`, etc.)
 
+## MCP Server (LLM Integration)
+
+The desktop GUI includes an embedded [Model Context Protocol](https://modelcontextprotocol.io) server that exposes loaded execution plans and Query Store data to LLM clients like Claude Code and Cursor.
+
+### Setup
+
+1. Enable the MCP server in `~/.planview/settings.json`:
+
+```json
+{
+  "mcp_enabled": true,
+  "mcp_port": 5152
+}
+```
+
+2. Register with Claude Code:
+
+```
+claude mcp add --transport streamable-http --scope user performance-studio http://localhost:5152/
+```
+
+3. Open a new Claude Code session and ask questions like:
+   - "What plans are loaded in the application?"
+   - "Analyze the execution plan and tell me what's wrong"
+   - "Are there any missing index suggestions?"
+   - "Compare these two plans — which is better?"
+   - "Fetch the top 10 queries by CPU from Query Store"
+
+### Available Tools
+
+13 tools for plan analysis and Query Store data:
+
+| Category | Tools |
+|---|---|
+| Discovery | `list_plans`, `get_connections` |
+| Plan Analysis | `analyze_plan`, `get_plan_summary`, `get_plan_warnings`, `get_missing_indexes`, `get_plan_parameters`, `get_expensive_operators`, `get_plan_xml`, `compare_plans`, `get_repro_script` |
+| Query Store | `check_query_store`, `get_query_store_top` |
+
+Plan analysis tools work on plans loaded in the app (via file open, paste, query execution, or Query Store fetch). Query Store tools use a built-in read-only DMV query — no arbitrary SQL can be executed.
+
+The MCP server binds to `localhost` only and does not accept remote connections. Disabled by default.
+
 ## Project Structure
 
 ```
diff --git a/SECURITY.md b/SECURITY.md
index a02e642..5a54ea9 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -2,7 +2,7 @@
 
 ## Reporting a Vulnerability
 
-If you discover a security vulnerability in SQL Performance Studio, please report it responsibly.
+If you discover a security vulnerability in Performance Studio, please report it responsibly.
 
 **Do not open a public GitHub issue for security vulnerabilities.**
 
@@ -26,7 +26,7 @@ This policy applies to:
 
 ## Security Best Practices
 
-When using SQL Performance Studio:
+When using Performance Studio:
 
 - Use Windows Authentication where possible when connecting to SQL Server
 - Use dedicated accounts with minimal required permissions
diff --git a/screenshots/.gitkeep b/screenshots/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/src/PlanViewer.App/AboutWindow.axaml b/src/PlanViewer.App/AboutWindow.axaml
index 8c30608..8f5b51e 100644
--- a/src/PlanViewer.App/AboutWindow.axaml
+++ b/src/PlanViewer.App/AboutWindow.axaml
@@ -1,8 +1,8 @@
 <Window xmlns="https://github.com/avaloniaui"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         x:Class="PlanViewer.App.AboutWindow"
-        Title="About SQL Performance Studio"
-        Width="450" Height="340"
+        Title="About Performance Studio"
+        Width="450" Height="420"
         CanResize="False"
         WindowStartupLocation="CenterOwner"
         Icon="avares://PlanViewer.App/EDD.ico"
@@ -11,7 +11,7 @@
     <Grid Margin="24" RowDefinitions="Auto,Auto,Auto,Auto,*,Auto">
 
         <!-- Title -->
-        <TextBlock Grid.Row="0" Text="SQL Performance Studio" FontWeight="Bold" FontSize="20"
+        <TextBlock Grid.Row="0" Text="Performance Studio" FontWeight="Bold" FontSize="20"
                    Foreground="{DynamicResource ForegroundBrush}" Margin="0,0,0,4"/>
         <TextBlock Grid.Row="1" x:Name="VersionText" Text="Version 0.3.0" FontSize="12"
                    Foreground="{DynamicResource ForegroundMutedBrush}" Margin="0,0,0,4"/>
@@ -46,8 +46,24 @@
                        TextDecorations="Underline"/>
         </StackPanel>
 
-        <!-- Spacer -->
-        <Panel Grid.Row="4"/>
+        <!-- MCP Settings -->
+        <StackPanel Grid.Row="4" Margin="0,0,0,12">
+            <TextBlock Text="Settings" FontWeight="SemiBold" FontSize="13"
+                       Foreground="{DynamicResource ForegroundBrush}" Margin="0,0,0,8"/>
+            <StackPanel Orientation="Horizontal" Spacing="12">
+                <CheckBox x:Name="McpEnabledCheckBox" Content="Enable MCP Server"
+                          FontSize="12" VerticalContentAlignment="Center"
+                          Foreground="{DynamicResource ForegroundBrush}"/>
+                <TextBlock Text="Port:" FontSize="12" VerticalAlignment="Center"
+                           Foreground="{DynamicResource ForegroundBrush}"/>
+                <TextBox x:Name="McpPortInput" Width="70" Height="28"
+                         Text="5152" FontSize="12" Padding="6,2"
+                         VerticalContentAlignment="Center"/>
+            </StackPanel>
+            <TextBlock Text="Restart the application after changing MCP settings."
+                       FontSize="11" Foreground="{DynamicResource ForegroundMutedBrush}"
+                       Margin="0,4,0,0"/>
+        </StackPanel>
 
         <!-- Close -->
         <Button Grid.Row="5" Content="Close" Click="CloseButton_Click"
diff --git a/src/PlanViewer.App/AboutWindow.axaml.cs b/src/PlanViewer.App/AboutWindow.axaml.cs
index 1fee846..c47485c 100644
--- a/src/PlanViewer.App/AboutWindow.axaml.cs
+++ b/src/PlanViewer.App/AboutWindow.axaml.cs
@@ -1,15 +1,19 @@
 /*
- * SQL Performance Studio — SQL Server Execution Plan Analyzer
+ * Performance Studio — SQL Server Execution Plan Analyzer
  * Copyright (c) 2026 Erik Darling, Darling Data LLC
  * Licensed under the MIT License - see LICENSE file for details
  */
 
+using System;
 using System.Diagnostics;
+using System.IO;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Text.Json;
 using Avalonia.Controls;
 using Avalonia.Input;
 using Avalonia.Interactivity;
+using PlanViewer.App.Mcp;
 
 namespace PlanViewer.App;
 
@@ -25,6 +29,31 @@ public AboutWindow()
         var version = Assembly.GetExecutingAssembly().GetName().Version;
         if (version != null)
             VersionText.Text = $"Version {version.Major}.{version.Minor}.{version.Build}";
+
+        // Load current MCP settings
+        var settings = McpSettings.Load();
+        McpEnabledCheckBox.IsChecked = settings.Enabled;
+        McpPortInput.Text = settings.Port.ToString();
+
+        // Save on change
+        McpEnabledCheckBox.IsCheckedChanged += (_, _) => SaveMcpSettings();
+        McpPortInput.LostFocus += (_, _) => SaveMcpSettings();
+    }
+
+    private void SaveMcpSettings()
+    {
+        var settingsDir = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".planview");
+        var settingsFile = Path.Combine(settingsDir, "settings.json");
+
+        var json = JsonSerializer.Serialize(new
+        {
+            mcp_enabled = McpEnabledCheckBox.IsChecked == true,
+            mcp_port = int.TryParse(McpPortInput.Text, out var p) && p >= 1024 && p <= 65535 ? p : 5152
+        }, new JsonSerializerOptions { WriteIndented = true });
+
+        Directory.CreateDirectory(settingsDir);
+        File.WriteAllText(settingsFile, json);
     }
 
     private void GitHubLink_Click(object? sender, PointerPressedEventArgs e) => OpenUrl(GitHubUrl);
diff --git a/src/PlanViewer.App/App.axaml b/src/PlanViewer.App/App.axaml
index 8ab1569..1188cfa 100644
--- a/src/PlanViewer.App/App.axaml
+++ b/src/PlanViewer.App/App.axaml
@@ -1,12 +1,12 @@
 <Application xmlns="https://github.com/avaloniaui"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              x:Class="PlanViewer.App.App"
-             Name="SQL Performance Studio"
+             Name="Performance Studio"
              RequestedThemeVariant="Dark">
 
     <NativeMenu.Menu>
         <NativeMenu>
-            <NativeMenuItem Header="About SQL Performance Studio" Click="OnAboutClicked" />
+            <NativeMenuItem Header="About Performance Studio" Click="OnAboutClicked" />
         </NativeMenu>
     </NativeMenu.Menu>
 
diff --git a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
index 242600b..2b4afb1 100644
--- a/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/PlanViewerControl.axaml.cs
@@ -16,6 +16,7 @@
 using Avalonia.Controls.Templates;
 using Avalonia.Platform.Storage;
 using PlanViewer.App.Helpers;
+using PlanViewer.App.Mcp;
 using PlanViewer.Core.Models;
 using PlanViewer.Core.Services;
 
@@ -52,6 +53,7 @@ private static string FormatDuration(long ms)
 
 public partial class PlanViewerControl : UserControl
 {
+    private readonly string _mcpSessionId = Guid.NewGuid().ToString();
     private ParsedPlan? _currentPlan;
     private PlanStatement? _currentStatement;
     private string? _queryText;
@@ -175,10 +177,36 @@ public void LoadPlan(string planXml, string label, string? queryText = null)
         PopulateStatementsGrid(allStatements);
         ShowStatementsPanel();
         StatementsGrid.SelectedIndex = 0;
+
+        // Register with MCP session manager for AI tool access
+        // Count warnings from both statement-level PlanWarnings and all node Warnings
+        int warningCount = 0, criticalCount = 0;
+        foreach (var s in allStatements)
+        {
+            warningCount += s.PlanWarnings.Count;
+            criticalCount += s.PlanWarnings.Count(w => w.Severity == PlanWarningSeverity.Critical);
+            if (s.RootNode != null)
+                CountNodeWarnings(s.RootNode, ref warningCount, ref criticalCount);
+        }
+
+        PlanSessionManager.Instance.Register(_mcpSessionId, new PlanSession
+        {
+            SessionId = _mcpSessionId,
+            Label = label,
+            Source = "file",
+            Plan = _currentPlan,
+            QueryText = queryText,
+            StatementCount = allStatements.Count,
+            HasActualStats = allStatements.Any(s => s.QueryTimeStats != null),
+            WarningCount = warningCount,
+            CriticalWarningCount = criticalCount,
+            MissingIndexCount = _currentPlan.AllMissingIndexes.Count
+        });
     }
 
     public void Clear()
     {
+        PlanSessionManager.Instance.Unregister(_mcpSessionId);
         PlanCanvas.Children.Clear();
         _nodeBorderMap.Clear();
         _currentPlan = null;
@@ -195,6 +223,14 @@ public void Clear()
         ClosePropertiesPanel();
     }
 
+    private static void CountNodeWarnings(PlanNode node, ref int total, ref int critical)
+    {
+        total += node.Warnings.Count;
+        critical += node.Warnings.Count(w => w.Severity == PlanWarningSeverity.Critical);
+        foreach (var child in node.Children)
+            CountNodeWarnings(child, ref total, ref critical);
+    }
+
     private void RenderStatement(PlanStatement statement)
     {
         _currentStatement = statement;
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index ca94be3..2dcb52f 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -607,7 +607,7 @@ private void ShowAdviceWindow(string title, string content)
 
         var window = new Window
         {
-            Title = $"SQL Performance Studio — {title}",
+            Title = $"Performance Studio — {title}",
             Width = 700,
             Height = 600,
             MinWidth = 400,
@@ -1119,7 +1119,7 @@ otherwise fall back to the currently selected database */
             database,
             planXml,
             isolationLevel: null,
-            source: "SQL Performance Studio",
+            source: "Performance Studio",
             isAzureSqlDb: IsAzureConnection);
 
         try
diff --git a/src/PlanViewer.App/Info.plist b/src/PlanViewer.App/Info.plist
index 51c6de5..49ec93f 100644
--- a/src/PlanViewer.App/Info.plist
+++ b/src/PlanViewer.App/Info.plist
@@ -3,9 +3,9 @@
 <plist version="1.0">
 <dict>
     <key>CFBundleName</key>
-    <string>SQL Performance Studio</string>
+    <string>Performance Studio</string>
     <key>CFBundleDisplayName</key>
-    <string>SQL Performance Studio</string>
+    <string>Performance Studio</string>
     <key>CFBundleIdentifier</key>
     <string>com.darlingdata.sqlperformancestudio</string>
     <key>CFBundleVersion</key>
diff --git a/src/PlanViewer.App/MainWindow.axaml b/src/PlanViewer.App/MainWindow.axaml
index 64073a0..68372c0 100644
--- a/src/PlanViewer.App/MainWindow.axaml
+++ b/src/PlanViewer.App/MainWindow.axaml
@@ -2,7 +2,7 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:controls="using:PlanViewer.App.Controls"
         x:Class="PlanViewer.App.MainWindow"
-        Title="SQL Performance Studio — SQL Server Execution Plan Analyzer"
+        Title="Performance Studio — SQL Server Execution Plan Analyzer"
         Width="1280" Height="800"
         MinWidth="640" MinHeight="480"
         WindowState="Maximized"
@@ -25,7 +25,9 @@
                           InputGesture="Alt+F4"/>
             </MenuItem>
             <MenuItem Header="_Help">
-                <MenuItem Header="_About SQL Performance Studio" Click="About_Click"/>
+                <MenuItem Header="_About Performance Studio" Click="About_Click"/>
+                <Separator/>
+                <MenuItem x:Name="McpStatusMenuItem" Header="MCP Server: Off" IsEnabled="False"/>
             </MenuItem>
         </Menu>
 
@@ -38,7 +40,7 @@
             <Border x:Name="EmptyOverlay" Background="{DynamicResource BackgroundBrush}"
                     IsVisible="True" IsHitTestVisible="False">
                 <StackPanel VerticalAlignment="Center" HorizontalAlignment="Center" Spacing="8">
-                    <TextBlock Text="SQL Performance Studio" FontSize="28" FontWeight="Bold"
+                    <TextBlock Text="Performance Studio" FontSize="28" FontWeight="Bold"
                                Foreground="{DynamicResource ForegroundBrush}"
                                HorizontalAlignment="Center"/>
                     <TextBlock Text="Ctrl+N to open a new query session"
diff --git a/src/PlanViewer.App/MainWindow.axaml.cs b/src/PlanViewer.App/MainWindow.axaml.cs
index b848b93..3304a71 100644
--- a/src/PlanViewer.App/MainWindow.axaml.cs
+++ b/src/PlanViewer.App/MainWindow.axaml.cs
@@ -18,6 +18,7 @@
 using PlanViewer.App.Services;
 using PlanViewer.Core.Interfaces;
 using PlanViewer.Core.Models;
+using PlanViewer.App.Mcp;
 using PlanViewer.Core.Output;
 using PlanViewer.Core.Services;
 
@@ -30,6 +31,8 @@ public partial class MainWindow : Window
     private readonly ICredentialService _credentialService;
     private readonly ConnectionStore _connectionStore;
     private readonly CancellationTokenSource _pipeCts = new();
+    private McpHostService? _mcpHost;
+    private CancellationTokenSource? _mcpCts;
     private int _queryCounter;
 
     public MainWindow()
@@ -95,6 +98,9 @@ public MainWindow()
             // Open with a query editor so toolbar buttons are visible on startup
             NewQuery_Click(this, new RoutedEventArgs());
         }
+
+        // Start MCP server if enabled in settings
+        StartMcpServer();
     }
 
     private void StartPipeServer()
@@ -136,9 +142,34 @@ await Dispatcher.UIThread.InvokeAsync(() =>
         }, token);
     }
 
-    protected override void OnClosed(EventArgs e)
+    private void StartMcpServer()
+    {
+        var settings = McpSettings.Load();
+        if (!settings.Enabled)
+        {
+            McpStatusMenuItem.Header = "MCP Server: Off";
+            return;
+        }
+
+        _mcpCts = new CancellationTokenSource();
+        _mcpHost = new McpHostService(
+            PlanSessionManager.Instance, _connectionStore, _credentialService, settings.Port);
+
+        _ = _mcpHost.StartAsync(_mcpCts.Token);
+        McpStatusMenuItem.Header = $"MCP Server: Running (port {settings.Port})";
+    }
+
+    protected override async void OnClosed(EventArgs e)
     {
         _pipeCts.Cancel();
+
+        if (_mcpHost != null && _mcpCts != null)
+        {
+            _mcpCts.Cancel();
+            await _mcpHost.StopAsync(CancellationToken.None);
+            _mcpHost = null;
+        }
+
         base.OnClosed(e);
     }
 
@@ -465,7 +496,7 @@ private DockPanel CreatePlanTabContent(PlanViewerControl viewer)
 
             var reproScript = ReproScriptBuilder.BuildReproScript(
                 queryText, database, planXml,
-                isolationLevel: null, source: "SQL Performance Studio");
+                isolationLevel: null, source: "Performance Studio");
 
             var clipboard = this.Clipboard;
             if (clipboard != null)
@@ -566,7 +597,7 @@ private void ShowAdviceWindow(string title, string content)
 
         var window = new Window
         {
-            Title = $"SQL Performance Studio — {title}",
+            Title = $"Performance Studio — {title}",
             Width = 700,
             Height = 600,
             MinWidth = 400,
@@ -1028,7 +1059,7 @@ private void ShowError(string message)
     {
         var dialog = new Window
         {
-            Title = "SQL Performance Studio",
+            Title = "Performance Studio",
             Width = 450,
             Height = 200,
             WindowStartupLocation = WindowStartupLocation.CenterOwner,
diff --git a/src/PlanViewer.App/Mcp/McpHelpers.cs b/src/PlanViewer.App/Mcp/McpHelpers.cs
new file mode 100644
index 0000000..6bd2807
--- /dev/null
+++ b/src/PlanViewer.App/Mcp/McpHelpers.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Text.Json;
+
+namespace PlanViewer.App.Mcp;
+
+internal static class McpHelpers
+{
+    public const int MaxTop = 100;
+
+    public static readonly JsonSerializerOptions JsonOptions = new() { WriteIndented = true };
+
+    public static string? Truncate(string? value, int maxLength)
+    {
+        if (value == null || value.Length <= maxLength) return value;
+        return value[..maxLength] + "... (truncated)";
+    }
+
+    public static string? ValidateTop(int top, string paramName = "top")
+    {
+        if (top <= 0)
+            return $"Invalid {paramName} value '{top}'. Must be a positive integer (1-{MaxTop}).";
+        if (top > MaxTop)
+            return $"{paramName} value '{top}' exceeds maximum of {MaxTop}. Use a smaller value.";
+        return null;
+    }
+
+    public static string FormatError(string operation, Exception ex) =>
+        $"Error during {operation}: {ex.Message}";
+}
diff --git a/src/PlanViewer.App/Mcp/McpHostService.cs b/src/PlanViewer.App/Mcp/McpHostService.cs
new file mode 100644
index 0000000..3e2bbbc
--- /dev/null
+++ b/src/PlanViewer.App/Mcp/McpHostService.cs
@@ -0,0 +1,100 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using ModelContextProtocol.AspNetCore;
+using PlanViewer.App.Services;
+using PlanViewer.Core.Interfaces;
+
+namespace PlanViewer.App.Mcp;
+
+/// <summary>
+/// Background service that hosts an MCP server over Streamable HTTP transport.
+/// Allows LLM clients to discover and call plan analysis tools via http://localhost:{port}.
+/// </summary>
+public sealed class McpHostService : BackgroundService
+{
+    private readonly PlanSessionManager _sessionManager;
+    private readonly ConnectionStore _connectionStore;
+    private readonly ICredentialService _credentialService;
+    private readonly int _port;
+    private WebApplication? _app;
+
+    public McpHostService(
+        PlanSessionManager sessionManager,
+        ConnectionStore connectionStore,
+        ICredentialService credentialService,
+        int port)
+    {
+        _sessionManager = sessionManager;
+        _connectionStore = connectionStore;
+        _credentialService = credentialService;
+        _port = port;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        try
+        {
+            var builder = WebApplication.CreateBuilder();
+
+            builder.WebHost.ConfigureKestrel(options =>
+            {
+                options.ListenLocalhost(_port);
+            });
+
+            /* Suppress ASP.NET Core console logging */
+            builder.Logging.ClearProviders();
+            builder.Logging.SetMinimumLevel(LogLevel.Warning);
+
+            /* Register services that MCP tools need via dependency injection */
+            builder.Services.AddSingleton(_sessionManager);
+            builder.Services.AddSingleton(_connectionStore);
+            builder.Services.AddSingleton(_credentialService);
+
+            /* Register MCP server with all tool classes */
+            builder.Services
+                .AddMcpServer(options =>
+                {
+                    options.ServerInfo = new()
+                    {
+                        Name = "PerformanceStudio",
+                        Version = "0.7.0"
+                    };
+                    options.ServerInstructions = McpInstructions.Text;
+                })
+                .WithHttpTransport()
+                .WithTools<McpPlanTools>()
+                .WithTools<McpQueryStoreTools>();
+
+            _app = builder.Build();
+            _app.MapMcp();
+
+            await _app.RunAsync(stoppingToken);
+        }
+        catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
+        {
+            /* Normal shutdown */
+        }
+        catch (Exception)
+        {
+            /* MCP server failed to start — app continues without it */
+        }
+    }
+
+    public override async Task StopAsync(CancellationToken cancellationToken)
+    {
+        if (_app != null)
+        {
+            await _app.StopAsync(cancellationToken);
+            await _app.DisposeAsync();
+            _app = null;
+        }
+
+        await base.StopAsync(cancellationToken);
+    }
+}
diff --git a/src/PlanViewer.App/Mcp/McpInstructions.cs b/src/PlanViewer.App/Mcp/McpInstructions.cs
new file mode 100644
index 0000000..ccacecd
--- /dev/null
+++ b/src/PlanViewer.App/Mcp/McpInstructions.cs
@@ -0,0 +1,122 @@
+namespace PlanViewer.App.Mcp;
+
+internal static class McpInstructions
+{
+    public const string Text = """
+        You are connected to Performance Studio, a SQL Server execution plan analyzer.
+
+        ## CRITICAL: Read-Only Access
+
+        This MCP server provides READ-ONLY access to execution plans and Query Store data. You CANNOT:
+        - Execute arbitrary or ad-hoc SQL queries against any server
+        - Modify any server configuration or settings
+        - Write or modify any files
+        - Change application settings
+
+        The only server-side query this MCP can run is the built-in Query Store fetch query
+        (via `get_query_store_top`), which reads from `sys.query_store_*` DMVs. No other
+        queries can be executed.
+
+        ## How Plans Get Loaded
+
+        Plans are loaded into the application by the user through:
+        - Opening .sqlplan files (File > Open)
+        - Pasting XML from the clipboard (Ctrl+V or File > Paste Plan XML)
+        - Executing queries from the built-in query editor (estimated or actual plans)
+        - Fetching from Query Store (via the Query Store dialog in the app)
+
+        Each loaded plan gets a unique `session_id`. Use `list_plans` to see all loaded plans and their session IDs.
+
+        ## Tool Reference
+
+        ### Discovery
+        | Tool | Purpose |
+        |------|---------|
+        | `list_plans` | Lists all loaded plans with session IDs, labels, and summary stats |
+        | `get_connections` | Lists saved SQL Server connections (names only, no credentials) |
+
+        ### Plan Analysis (works on loaded plans)
+        | Tool | Purpose |
+        |------|---------|
+        | `analyze_plan` | Full JSON analysis: statements, warnings, operators, parameters, memory grants |
+        | `get_plan_summary` | Concise text summary for quick assessment |
+        | `get_plan_warnings` | Warnings only, filterable by severity |
+        | `get_missing_indexes` | Missing index suggestions with CREATE INDEX statements |
+        | `get_plan_parameters` | Parameter details with compiled vs runtime value comparison |
+        | `get_expensive_operators` | Top N costly operators by cost or actual elapsed time |
+        | `get_plan_xml` | Raw showplan XML |
+        | `compare_plans` | Side-by-side comparison of two plans |
+        | `get_repro_script` | Generates paste-ready T-SQL reproduction script |
+
+        ### Query Store (uses built-in read-only query only)
+        | Tool | Purpose |
+        |------|---------|
+        | `check_query_store` | Checks if Query Store is enabled on a database |
+        | `get_query_store_top` | Fetches top N plans from Query Store; auto-loads them for analysis |
+
+        ## Recommended Workflow
+
+        ### Analyzing loaded plans
+        1. `list_plans` — see what plans are loaded in the application
+        2. `analyze_plan` with the target session_id — get full analysis
+        3. Focus on critical issues: `get_plan_warnings` with severity="Critical"
+        4. Check for parameter sniffing: `get_plan_parameters`
+        5. Review index suggestions: `get_missing_indexes`
+        6. Find bottlenecks: `get_expensive_operators`
+        7. For comparison: `compare_plans` with two session_ids
+        8. For reproduction: `get_repro_script` to generate runnable T-SQL
+
+        ### Fetching from Query Store
+        1. `get_connections` — see available saved connections
+        2. `check_query_store` — verify Query Store is enabled on the target database
+        3. `get_query_store_top` — fetch top queries (auto-loads plans into the app)
+        4. Use plan analysis tools above with the returned session_ids
+
+        ## Analysis Rules
+
+        The analyzer runs 30 rules covering:
+        - Memory: Large grants, grant vs used ratio, spills to TempDB (sort, hash, exchange)
+        - Estimates: Row estimate mismatches (10x+), zero-row actuals, row goals
+        - Indexes: Missing index suggestions, key lookups, RID lookups, scan with residual predicates
+        - Parallelism: Serial plan reasons, thread skew, ineffective parallelism, DOP reporting
+        - Joins: Nested loop high executions, many-to-many merge join worktables
+        - Filters: Late filter operators, function-wrapped predicates
+        - Functions: Scalar UDF detection (T-SQL and CLR)
+        - Parameters: Compiled vs runtime values, sniffing issue detection, local variables
+        - Patterns: Leading wildcards, implicit conversions, OPTIMIZE FOR UNKNOWN, NOT IN with nullable columns
+        - Compilation: High compile CPU, compile memory exceeded, early abort
+        - Objects: Table variables, table-valued functions, CTE multiple references, spools
+
+        Warnings have three severity levels: Critical, Warning, Info.
+
+        ## Data Characteristics
+
+        - Plans can be **estimated** (no runtime stats) or **actual** (with row counts, elapsed time, I/O stats)
+        - Estimated plans show expected costs and row estimates only
+        - Actual plans additionally show per-thread runtime data, elapsed times, logical/physical reads, wait stats
+        - Memory grant analysis is only meaningful in actual plans (when GrantedKB > 0)
+        - Wait stats are only present in actual plans captured with SET STATISTICS XML ON
+        - Query Store plans are always estimated (plan cache snapshots)
+
+        ## MCP Client Configuration
+
+        For Claude Code, add to your MCP config:
+        ```json
+        {
+          "mcpServers": {
+            "performance-studio": {
+              "type": "streamable-http",
+              "url": "http://localhost:5152/"
+            }
+          }
+        }
+        ```
+
+        ## Key Limitations
+
+        - Plans must be loaded in the application before MCP tools can access them
+        - Query Store tools require a saved connection with valid credentials
+        - Plan XML in `get_plan_xml` is truncated at 500KB
+        - The full operator tree in `analyze_plan` can be large for complex queries
+        """;
+}
diff --git a/src/PlanViewer.App/Mcp/McpPlanTools.cs b/src/PlanViewer.App/Mcp/McpPlanTools.cs
new file mode 100644
index 0000000..8e80b85
--- /dev/null
+++ b/src/PlanViewer.App/Mcp/McpPlanTools.cs
@@ -0,0 +1,345 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text.Json;
+using ModelContextProtocol.Server;
+using PlanViewer.App.Services;
+using PlanViewer.Core.Models;
+using PlanViewer.Core.Output;
+using PlanViewer.Core.Services;
+
+#pragma warning disable CA1707 // Identifiers should not contain underscores (MCP snake_case convention)
+
+namespace PlanViewer.App.Mcp;
+
+[McpServerToolType]
+public sealed class McpPlanTools
+{
+    [McpServerTool(Name = "list_plans")]
+    [Description("Lists all execution plans currently loaded in the application. Returns session IDs, labels, " +
+        "statement counts, warning counts, and source type. Use this first to discover available plans.")]
+    public static string ListPlans(PlanSessionManager sessionManager)
+    {
+        var sessions = sessionManager.GetAllSessions();
+        if (sessions.Count == 0)
+            return "No plans are currently loaded in the application. Open a .sqlplan file or paste plan XML to get started.";
+
+        return JsonSerializer.Serialize(new { plans = sessions }, McpHelpers.JsonOptions);
+    }
+
+    [McpServerTool(Name = "get_connections")]
+    [Description("Lists saved SQL Server connections. Returns server names and authentication types only — " +
+        "credentials are never exposed. Use connection names with Query Store tools.")]
+    public static string GetConnections(ConnectionStore connectionStore)
+    {
+        var connections = connectionStore.Load();
+        if (connections.Count == 0)
+            return "No saved connections. Add a connection in the application via the query editor toolbar.";
+
+        var safe = connections.Select(c => new
+        {
+            name = c.ServerName,
+            display_name = string.IsNullOrEmpty(c.DisplayName) ? c.ServerName : c.DisplayName,
+            auth_type = c.AuthenticationDisplay
+        });
+
+        return JsonSerializer.Serialize(new { connections = safe }, McpHelpers.JsonOptions);
+    }
+
+    [McpServerTool(Name = "analyze_plan")]
+    [Description("Returns the full JSON analysis result for a loaded plan. Includes all statements, warnings, " +
+        "missing indexes, parameters, operator tree, memory grants, and wait stats. " +
+        "This is the primary tool for understanding plan quality. Use list_plans first to get session_id values.")]
+    public static string AnalyzePlan(
+        PlanSessionManager sessionManager,
+        [Description("The session_id from list_plans.")] string session_id)
+    {
+        var session = sessionManager.GetSession(session_id);
+        if (session == null)
+            return SessionNotFound(sessionManager, session_id);
+
+        try
+        {
+            var result = ResultMapper.Map(session.Plan, session.Source);
+            return JsonSerializer.Serialize(result, McpHelpers.JsonOptions);
+        }
+        catch (Exception ex)
+        {
+            return McpHelpers.FormatError("analyze_plan", ex);
+        }
+    }
+
+    [McpServerTool(Name = "get_plan_summary")]
+    [Description("Returns a concise human-readable text summary of a loaded plan: statement count, warnings, " +
+        "missing indexes, cost, DOP, memory grants. Faster than analyze_plan for quick assessment.")]
+    public static string GetPlanSummary(
+        PlanSessionManager sessionManager,
+        [Description("The session_id from list_plans.")] string session_id)
+    {
+        var session = sessionManager.GetSession(session_id);
+        if (session == null)
+            return SessionNotFound(sessionManager, session_id);
+
+        try
+        {
+            var result = ResultMapper.Map(session.Plan, session.Source);
+            return TextFormatter.Format(result);
+        }
+        catch (Exception ex)
+        {
+            return McpHelpers.FormatError("get_plan_summary", ex);
+        }
+    }
+
+    [McpServerTool(Name = "get_plan_warnings")]
+    [Description("Returns only the warnings and analysis findings for a loaded plan. " +
+        "Optionally filter by severity (Critical, Warning, or Info).")]
+    public static string GetPlanWarnings(
+        PlanSessionManager sessionManager,
+        [Description("The session_id from list_plans.")] string session_id,
+        [Description("Optional severity filter: Critical, Warning, or Info.")] string? severity = null)
+    {
+        var session = sessionManager.GetSession(session_id);
+        if (session == null)
+            return SessionNotFound(sessionManager, session_id);
+
+        try
+        {
+            var result = ResultMapper.Map(session.Plan, session.Source);
+            var allWarnings = result.Statements
+                .SelectMany(s => s.Warnings.Select(w => new
+                {
+                    severity = w.Severity,
+                    type = w.Type,
+                    message = w.Message,
+                    node_id = w.NodeId,
+                    @operator = w.Operator,
+                    statement = McpHelpers.Truncate(s.StatementText, 200)
+                }))
+                .Where(w => severity == null ||
+                    w.severity.Equals(severity, StringComparison.OrdinalIgnoreCase))
+                .ToList();
+
+            if (allWarnings.Count == 0)
+            {
+                return severity != null
+                    ? $"No {severity} warnings found in this plan."
+                    : "No warnings found in this plan.";
+            }
+
+            return JsonSerializer.Serialize(new { warning_count = allWarnings.Count, warnings = allWarnings },
+                McpHelpers.JsonOptions);
+        }
+        catch (Exception ex)
+        {
+            return McpHelpers.FormatError("get_plan_warnings", ex);
+        }
+    }
+
+    [McpServerTool(Name = "get_missing_indexes")]
+    [Description("Returns missing index suggestions from a loaded plan with impact scores and " +
+        "ready-to-run CREATE INDEX statements.")]
+    public static string GetMissingIndexes(
+        PlanSessionManager sessionManager,
+        [Description("The session_id from list_plans.")] string session_id)
+    {
+        var session = sessionManager.GetSession(session_id);
+        if (session == null)
+            return SessionNotFound(sessionManager, session_id);
+
+        var indexes = session.Plan.AllMissingIndexes;
+        if (indexes.Count == 0)
+            return "No missing index suggestions in this plan.";
+
+        var result = indexes.Select(idx => new
+        {
+            database = idx.Database,
+            schema_name = idx.Schema,
+            table = idx.Table,
+            impact = idx.Impact,
+            equality_columns = idx.EqualityColumns,
+            inequality_columns = idx.InequalityColumns,
+            include_columns = idx.IncludeColumns,
+            create_statement = idx.CreateStatement
+        });
+
+        return JsonSerializer.Serialize(new { missing_index_count = indexes.Count, indexes = result },
+            McpHelpers.JsonOptions);
+    }
+
+    [McpServerTool(Name = "get_plan_parameters")]
+    [Description("Returns parameter details from a loaded plan including names, data types, " +
+        "compiled values, and runtime values. Highlights parameter sniffing when compiled and runtime values differ.")]
+    public static string GetPlanParameters(
+        PlanSessionManager sessionManager,
+        [Description("The session_id from list_plans.")] string session_id)
+    {
+        var session = sessionManager.GetSession(session_id);
+        if (session == null)
+            return SessionNotFound(sessionManager, session_id);
+
+        var statements = session.Plan.Batches
+            .SelectMany(b => b.Statements)
+            .Where(s => s.Parameters.Count > 0)
+            .Select(s => new
+            {
+                statement = McpHelpers.Truncate(s.StatementText, 200),
+                parameters = s.Parameters.Select(p => new
+                {
+                    name = p.Name,
+                    data_type = p.DataType,
+                    compiled_value = p.CompiledValue,
+                    runtime_value = p.RuntimeValue,
+                    sniffing_mismatch = p.CompiledValue != null && p.RuntimeValue != null
+                        && p.CompiledValue != p.RuntimeValue
+                })
+            })
+            .ToList();
+
+        if (statements.Count == 0)
+            return "No parameters found in this plan (ad-hoc query or local variables only).";
+
+        return JsonSerializer.Serialize(new { statements }, McpHelpers.JsonOptions);
+    }
+
+    [McpServerTool(Name = "get_expensive_operators")]
+    [Description("Returns the top N most expensive operators from a loaded plan, ranked by cost percentage " +
+        "or actual elapsed time (if available). Useful for quickly finding bottleneck operators.")]
+    public static string GetExpensiveOperators(
+        PlanSessionManager sessionManager,
+        [Description("The session_id from list_plans.")] string session_id,
+        [Description("Number of operators to return. Default 10.")] int top = 10)
+    {
+        var session = sessionManager.GetSession(session_id);
+        if (session == null)
+            return SessionNotFound(sessionManager, session_id);
+
+        var topError = McpHelpers.ValidateTop(top);
+        if (topError != null) return topError;
+
+        var allNodes = new List<(PlanNode Node, string Statement)>();
+        foreach (var stmt in session.Plan.Batches.SelectMany(b => b.Statements))
+        {
+            if (stmt.RootNode == null) continue;
+            CollectNodes(stmt.RootNode, McpHelpers.Truncate(stmt.StatementText, 100) ?? "", allNodes);
+        }
+
+        var hasActuals = allNodes.Any(n => n.Node.ActualElapsedMs > 0);
+        var ranked = hasActuals
+            ? allNodes.OrderByDescending(n => n.Node.ActualElapsedMs)
+            : allNodes.OrderByDescending(n => n.Node.CostPercent);
+
+        var result = ranked.Take(top).Select(n => new
+        {
+            node_id = n.Node.NodeId,
+            physical_op = n.Node.PhysicalOp,
+            logical_op = n.Node.LogicalOp,
+            cost_percent = n.Node.CostPercent,
+            estimated_rows = n.Node.EstimateRows,
+            actual_rows = n.Node.ActualRows,
+            actual_elapsed_ms = n.Node.ActualElapsedMs,
+            actual_cpu_ms = n.Node.ActualCPUMs,
+            logical_reads = n.Node.ActualLogicalReads,
+            physical_reads = n.Node.ActualPhysicalReads,
+            object_name = n.Node.ObjectName,
+            statement = n.Statement
+        });
+
+        return JsonSerializer.Serialize(new { ranked_by = hasActuals ? "actual_elapsed_ms" : "cost_percent", operators = result },
+            McpHelpers.JsonOptions);
+    }
+
+    [McpServerTool(Name = "get_plan_xml")]
+    [Description("Returns the raw showplan XML for a loaded plan. Useful when you need to examine " +
+        "plan details not captured in the structured analysis. Truncated at 500KB.")]
+    public static string GetPlanXml(
+        PlanSessionManager sessionManager,
+        [Description("The session_id from list_plans.")] string session_id)
+    {
+        var session = sessionManager.GetSession(session_id);
+        if (session == null)
+            return SessionNotFound(sessionManager, session_id);
+
+        return McpHelpers.Truncate(session.Plan.RawXml, 512_000) ?? "No plan XML available.";
+    }
+
+    [McpServerTool(Name = "compare_plans")]
+    [Description("Compares two loaded plans side by side. Returns differences in cost, DOP, warnings, " +
+        "memory grants, runtime stats, and operator shapes.")]
+    public static string ComparePlans(
+        PlanSessionManager sessionManager,
+        [Description("Session ID of the first plan (from list_plans).")] string session_id_a,
+        [Description("Session ID of the second plan (from list_plans).")] string session_id_b)
+    {
+        var sessionA = sessionManager.GetSession(session_id_a);
+        if (sessionA == null)
+            return SessionNotFound(sessionManager, session_id_a);
+
+        var sessionB = sessionManager.GetSession(session_id_b);
+        if (sessionB == null)
+            return SessionNotFound(sessionManager, session_id_b);
+
+        try
+        {
+            var resultA = ResultMapper.Map(sessionA.Plan, sessionA.Source);
+            var resultB = ResultMapper.Map(sessionB.Plan, sessionB.Source);
+            return ComparisonFormatter.Compare(resultA, resultB, sessionA.Label, sessionB.Label);
+        }
+        catch (Exception ex)
+        {
+            return McpHelpers.FormatError("compare_plans", ex);
+        }
+    }
+
+    [McpServerTool(Name = "get_repro_script")]
+    [Description("Generates a paste-ready T-SQL reproduction script from a loaded plan. " +
+        "Extracts parameters, SET options, and database context into a runnable sp_executesql call.")]
+    public static string GetReproScript(
+        PlanSessionManager sessionManager,
+        [Description("The session_id from list_plans.")] string session_id)
+    {
+        var session = sessionManager.GetSession(session_id);
+        if (session == null)
+            return SessionNotFound(sessionManager, session_id);
+
+        try
+        {
+            var stmt = session.Plan.Batches
+                .SelectMany(b => b.Statements)
+                .FirstOrDefault(s => s.RootNode != null);
+
+            if (stmt == null)
+                return "No executable statement found in this plan.";
+
+            var queryText = session.QueryText ?? stmt.StatementText ?? "";
+
+            // Extract database from first operator node's DatabaseName property
+            string? databaseName = null;
+            if (stmt.RootNode?.DatabaseName != null)
+                databaseName = stmt.RootNode.DatabaseName;
+
+            return ReproScriptBuilder.BuildReproScript(
+                queryText, databaseName, session.Plan.RawXml, null);
+        }
+        catch (Exception ex)
+        {
+            return McpHelpers.FormatError("get_repro_script", ex);
+        }
+    }
+
+    private static string SessionNotFound(PlanSessionManager sessionManager, string sessionId)
+    {
+        var available = sessionManager.GetAllSessions();
+        if (available.Count == 0)
+            return "No plans are currently loaded in the application.";
+        return $"Session '{sessionId}' not found. Use list_plans to see available sessions.";
+    }
+
+    private static void CollectNodes(PlanNode node, string statement, List<(PlanNode, string)> nodes)
+    {
+        nodes.Add((node, statement));
+        foreach (var child in node.Children)
+            CollectNodes(child, statement, nodes);
+    }
+}
diff --git a/src/PlanViewer.App/Mcp/McpQueryStoreTools.cs b/src/PlanViewer.App/Mcp/McpQueryStoreTools.cs
new file mode 100644
index 0000000..d37c5bb
--- /dev/null
+++ b/src/PlanViewer.App/Mcp/McpQueryStoreTools.cs
@@ -0,0 +1,204 @@
+using System;
+using System.ComponentModel;
+using System.Linq;
+using System.Text.Json;
+using System.Threading.Tasks;
+using ModelContextProtocol.Server;
+using PlanViewer.App.Services;
+using PlanViewer.Core.Interfaces;
+using PlanViewer.Core.Services;
+
+#pragma warning disable CA1707 // Identifiers should not contain underscores (MCP snake_case convention)
+
+namespace PlanViewer.App.Mcp;
+
+[McpServerToolType]
+public sealed class McpQueryStoreTools
+{
+    [McpServerTool(Name = "check_query_store")]
+    [Description("Checks whether Query Store is enabled and accessible on a database. " +
+        "Use this before calling get_query_store_top to verify the target database supports Query Store.")]
+    public static async Task<string> CheckQueryStore(
+        ConnectionStore connectionStore,
+        ICredentialService credentialService,
+        [Description("Server name from get_connections.")] string connection_name,
+        [Description("Database name to check.")] string database)
+    {
+        try
+        {
+            var conn = FindConnection(connectionStore, connection_name);
+            if (conn == null)
+                return ConnectionNotFound(connectionStore, connection_name);
+
+            var connectionString = conn.GetConnectionString(credentialService, database);
+            var (enabled, state) = await QueryStoreService.CheckEnabledAsync(connectionString);
+
+            return JsonSerializer.Serialize(new
+            {
+                server = conn.ServerName,
+                database,
+                query_store_enabled = enabled,
+                state
+            }, McpHelpers.JsonOptions);
+        }
+        catch (Exception ex)
+        {
+            return McpHelpers.FormatError("check_query_store", ex);
+        }
+    }
+
+    [McpServerTool(Name = "get_query_store_top")]
+    [Description("Fetches the top N queries from Query Store ranked by the specified metric. " +
+        "Uses the application's built-in Query Store query — no arbitrary SQL is executed. " +
+        "Each fetched plan is automatically loaded into the application for further analysis " +
+        "with analyze_plan, get_plan_warnings, etc. Returns summary stats and session IDs.")]
+    public static async Task<string> GetQueryStoreTop(
+        PlanSessionManager sessionManager,
+        ConnectionStore connectionStore,
+        ICredentialService credentialService,
+        [Description("Server name from get_connections.")] string connection_name,
+        [Description("Database name to query.")] string database,
+        [Description("Number of top queries to return. Default 10, max 50.")] int top = 10,
+        [Description("Ranking metric: cpu, avg-cpu, duration, avg-duration, reads, avg-reads, " +
+            "writes, avg-writes, physical-reads, avg-physical-reads, memory, avg-memory, executions. " +
+            "Default: cpu.")] string order_by = "cpu",
+        [Description("Hours of history to include. Default 24, max 168.")] int hours_back = 24)
+    {
+        try
+        {
+            var conn = FindConnection(connectionStore, connection_name);
+            if (conn == null)
+                return ConnectionNotFound(connectionStore, connection_name);
+
+            // Validate parameters
+            if (top < 1 || top > 50)
+                return "Invalid top value. Must be between 1 and 50.";
+            if (hours_back < 1 || hours_back > 168)
+                return "Invalid hours_back value. Must be between 1 and 168.";
+
+            var connectionString = conn.GetConnectionString(credentialService, database);
+
+            // Check Query Store is enabled first
+            var (enabled, state) = await QueryStoreService.CheckEnabledAsync(connectionString);
+            if (!enabled)
+                return $"Query Store is not enabled on [{database}]. State: {state ?? "unknown"}.";
+
+            // Fetch plans using the app's built-in query
+            var plans = await QueryStoreService.FetchTopPlansAsync(
+                connectionString, top, order_by, hours_back);
+
+            if (plans.Count == 0)
+                return $"No Query Store data found in [{database}] for the last {hours_back} hours.";
+
+            // Parse and register each plan with PlanSessionManager
+            var results = plans.Select(qsPlan =>
+            {
+                var sessionId = Guid.NewGuid().ToString();
+                var label = $"QS:{database} Q{qsPlan.QueryId} P{qsPlan.PlanId}";
+
+                try
+                {
+                    var xml = qsPlan.PlanXml
+                        .Replace("encoding=\"utf-16\"", "encoding=\"utf-8\"");
+                    var parsed = ShowPlanParser.Parse(xml);
+                    PlanAnalyzer.Analyze(parsed);
+
+                    var allStatements = parsed.Batches.SelectMany(b => b.Statements).ToList();
+
+                    sessionManager.Register(sessionId, new PlanSession
+                    {
+                        SessionId = sessionId,
+                        Label = label,
+                        Source = "query-store",
+                        Plan = parsed,
+                        QueryText = qsPlan.QueryText,
+                        ConnectionInfo = conn.ServerName,
+                        StatementCount = allStatements.Count,
+                        HasActualStats = false, // Query Store plans are always estimated
+                        WarningCount = allStatements.Sum(s => s.PlanWarnings.Count),
+                        CriticalWarningCount = allStatements.Sum(s =>
+                            s.PlanWarnings.Count(w => w.Severity == Core.Models.PlanWarningSeverity.Critical)),
+                        MissingIndexCount = parsed.AllMissingIndexes.Count
+                    });
+
+                    return new
+                    {
+                        session_id = sessionId,
+                        query_id = qsPlan.QueryId,
+                        plan_id = qsPlan.PlanId,
+                        label,
+                        query_text = McpHelpers.Truncate(qsPlan.QueryText, 500),
+                        executions = qsPlan.CountExecutions,
+                        total_cpu_ms = qsPlan.TotalCpuTimeUs / 1000.0,
+                        avg_cpu_ms = qsPlan.AvgCpuTimeUs / 1000.0,
+                        total_duration_ms = qsPlan.TotalDurationUs / 1000.0,
+                        avg_duration_ms = qsPlan.AvgDurationUs / 1000.0,
+                        total_logical_reads = qsPlan.TotalLogicalIoReads,
+                        avg_logical_reads = qsPlan.AvgLogicalIoReads,
+                        warning_count = allStatements.Sum(s => s.PlanWarnings.Count),
+                        missing_index_count = parsed.AllMissingIndexes.Count,
+                        last_executed_utc = qsPlan.LastExecutedUtc.ToString("yyyy-MM-dd HH:mm:ss"),
+                        loaded = true
+                    };
+                }
+                catch
+                {
+                    // Plan XML couldn't be parsed — return stats without loading
+                    return new
+                    {
+                        session_id = (string)"",
+                        query_id = qsPlan.QueryId,
+                        plan_id = qsPlan.PlanId,
+                        label,
+                        query_text = McpHelpers.Truncate(qsPlan.QueryText, 500),
+                        executions = qsPlan.CountExecutions,
+                        total_cpu_ms = qsPlan.TotalCpuTimeUs / 1000.0,
+                        avg_cpu_ms = qsPlan.AvgCpuTimeUs / 1000.0,
+                        total_duration_ms = qsPlan.TotalDurationUs / 1000.0,
+                        avg_duration_ms = qsPlan.AvgDurationUs / 1000.0,
+                        total_logical_reads = qsPlan.TotalLogicalIoReads,
+                        avg_logical_reads = qsPlan.AvgLogicalIoReads,
+                        warning_count = 0,
+                        missing_index_count = 0,
+                        last_executed_utc = qsPlan.LastExecutedUtc.ToString("yyyy-MM-dd HH:mm:ss"),
+                        loaded = false
+                    };
+                }
+            }).ToList();
+
+            return JsonSerializer.Serialize(new
+            {
+                server = conn.ServerName,
+                database,
+                order_by,
+                hours_back,
+                plan_count = results.Count,
+                plans = results
+            }, McpHelpers.JsonOptions);
+        }
+        catch (Exception ex)
+        {
+            return McpHelpers.FormatError("get_query_store_top", ex);
+        }
+    }
+
+    private static Core.Models.ServerConnection? FindConnection(
+        ConnectionStore store, string name)
+    {
+        var connections = store.Load();
+        return connections.FirstOrDefault(c =>
+            c.ServerName.Equals(name, StringComparison.OrdinalIgnoreCase) ||
+            (!string.IsNullOrEmpty(c.DisplayName) &&
+             c.DisplayName.Equals(name, StringComparison.OrdinalIgnoreCase)));
+    }
+
+    private static string ConnectionNotFound(ConnectionStore store, string name)
+    {
+        var connections = store.Load();
+        if (connections.Count == 0)
+            return "No saved connections. Add a connection in the application via the query editor toolbar.";
+        var available = string.Join(", ", connections.Select(c =>
+            string.IsNullOrEmpty(c.DisplayName) ? c.ServerName : $"{c.DisplayName} ({c.ServerName})"));
+        return $"Connection '{name}' not found. Available: {available}";
+    }
+}
diff --git a/src/PlanViewer.App/Mcp/McpSettings.cs b/src/PlanViewer.App/Mcp/McpSettings.cs
new file mode 100644
index 0000000..7caf431
--- /dev/null
+++ b/src/PlanViewer.App/Mcp/McpSettings.cs
@@ -0,0 +1,37 @@
+using System;
+using System.IO;
+using System.Text.Json;
+
+namespace PlanViewer.App.Mcp;
+
+internal sealed class McpSettings
+{
+    public bool Enabled { get; set; }
+    public int Port { get; set; } = 5152;
+
+    public static McpSettings Load()
+    {
+        var path = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+            ".planview", "settings.json");
+
+        if (!File.Exists(path))
+            return new McpSettings();
+
+        try
+        {
+            var json = File.ReadAllText(path);
+            using var doc = JsonDocument.Parse(json);
+            var root = doc.RootElement;
+            return new McpSettings
+            {
+                Enabled = root.TryGetProperty("mcp_enabled", out var e) && e.GetBoolean(),
+                Port = root.TryGetProperty("mcp_port", out var p) ? p.GetInt32() : 5152
+            };
+        }
+        catch
+        {
+            return new McpSettings();
+        }
+    }
+}
diff --git a/src/PlanViewer.App/Mcp/PlanSessionManager.cs b/src/PlanViewer.App/Mcp/PlanSessionManager.cs
new file mode 100644
index 0000000..65da26a
--- /dev/null
+++ b/src/PlanViewer.App/Mcp/PlanSessionManager.cs
@@ -0,0 +1,70 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using PlanViewer.Core.Models;
+
+namespace PlanViewer.App.Mcp;
+
+/// <summary>
+/// Thread-safe bridge between UI plan state and MCP tools.
+/// The UI registers/unregisters plans as tabs are opened/closed.
+/// MCP tools read plan data without touching the UI thread.
+/// </summary>
+public sealed class PlanSessionManager
+{
+    public static PlanSessionManager Instance { get; } = new();
+
+    private readonly ConcurrentDictionary<string, PlanSession> _sessions = new();
+
+    public void Register(string sessionId, PlanSession session) =>
+        _sessions[sessionId] = session;
+
+    public void Unregister(string sessionId) =>
+        _sessions.TryRemove(sessionId, out _);
+
+    public PlanSession? GetSession(string sessionId) =>
+        _sessions.TryGetValue(sessionId, out var session) ? session : null;
+
+    public IReadOnlyList<PlanSessionSummary> GetAllSessions() =>
+        _sessions.Values.Select(s => new PlanSessionSummary
+        {
+            SessionId = s.SessionId,
+            Label = s.Label,
+            Source = s.Source,
+            StatementCount = s.StatementCount,
+            WarningCount = s.WarningCount,
+            CriticalWarningCount = s.CriticalWarningCount,
+            MissingIndexCount = s.MissingIndexCount,
+            HasActualStats = s.HasActualStats
+        }).ToList();
+}
+
+/// <summary>
+/// Immutable snapshot of a loaded plan, safe for cross-thread reads by MCP tools.
+/// </summary>
+public sealed class PlanSession
+{
+    public required string SessionId { get; init; }
+    public required string Label { get; init; }
+    public required string Source { get; init; }
+    public required ParsedPlan Plan { get; init; }
+    public string? QueryText { get; init; }
+    public string? ConnectionInfo { get; init; }
+    public int StatementCount { get; init; }
+    public bool HasActualStats { get; init; }
+    public int WarningCount { get; init; }
+    public int CriticalWarningCount { get; init; }
+    public int MissingIndexCount { get; init; }
+}
+
+public sealed class PlanSessionSummary
+{
+    public string SessionId { get; set; } = "";
+    public string Label { get; set; } = "";
+    public string Source { get; set; } = "";
+    public int StatementCount { get; set; }
+    public int WarningCount { get; set; }
+    public int CriticalWarningCount { get; set; }
+    public int MissingIndexCount { get; set; }
+    public bool HasActualStats { get; set; }
+}
diff --git a/src/PlanViewer.App/PlanViewer.App.csproj b/src/PlanViewer.App/PlanViewer.App.csproj
index 01e9422..6845665 100644
--- a/src/PlanViewer.App/PlanViewer.App.csproj
+++ b/src/PlanViewer.App/PlanViewer.App.csproj
@@ -5,10 +5,10 @@
     <Nullable>enable</Nullable>
     <ApplicationManifest>app.manifest</ApplicationManifest>
     <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
-    <Version>0.7.0</Version>
+    <Version>0.8.0</Version>
     <Authors>Erik Darling</Authors>
     <Company>Darling Data LLC</Company>
-    <Product>SQL Performance Studio</Product>
+    <Product>Performance Studio</Product>
     <Copyright>Copyright (c) 2026 Erik Darling, Darling Data LLC</Copyright>
   </PropertyGroup>
 
@@ -27,6 +27,8 @@
     <PackageReference Include="AvaloniaEdit.TextMate" Version="11.4.1" />
     <PackageReference Include="AvaloniaEdit.TextMate.Grammars" Version="0.10.12" />
     <PackageReference Include="Meziantou.Framework.Win32.CredentialManager" Version="1.7.17" />
+    <PackageReference Include="ModelContextProtocol" Version="0.7.0-preview.1" />
+    <PackageReference Include="ModelContextProtocol.AspNetCore" Version="0.7.0-preview.1" />
     <PackageReference Include="TextMateSharp.Grammars" Version="2.0.3" />
   </ItemGroup>
 
diff --git a/src/PlanViewer.Cli/PlanViewer.Cli.csproj b/src/PlanViewer.Cli/PlanViewer.Cli.csproj
index 3776e12..d6b863e 100644
--- a/src/PlanViewer.Cli/PlanViewer.Cli.csproj
+++ b/src/PlanViewer.Cli/PlanViewer.Cli.csproj
@@ -11,10 +11,10 @@
     <Nullable>enable</Nullable>
     <RootNamespace>PlanViewer.Cli</RootNamespace>
     <AssemblyName>planview</AssemblyName>
-    <Version>0.5.0</Version>
+    <Version>0.8.0</Version>
     <Authors>Erik Darling</Authors>
     <Company>Darling Data LLC</Company>
-    <Product>SQL Performance Studio</Product>
+    <Product>Performance Studio</Product>
     <Copyright>Copyright (c) 2026 Erik Darling, Darling Data LLC</Copyright>
   </PropertyGroup>