From 4dd5cac31619964c8a133b58a6d5dede69df0a30 Mon Sep 17 00:00:00 2001
From: Josh Eckels <jeckels@labkey.com>
Date: Tue, 31 Mar 2026 16:43:14 -0700
Subject: [PATCH 1/5] Improve accessibility - remove inappropriate
 role="presentation" on tabs (#7534)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

#### Rationale
We are inappropriately tagging our folder portal tabs with
`role="presentation"`. You're not allowed to use it on an `<li>` without
a similar tag on a parent element like the `<ul>`.

Since these tabs are full-page navigations instead of in-page
replacements, it seems the most appropriate thing is to simply remove
this incorrect attribute.

https://www.w3.org/WAI/ARIA/apg/practices/hiding-semantics/

#### Changes
- Remove `role="presentation"` from folder portal tabs
- Signify the active tab using `aria-current="page"`

<!-- list of standard tasks (remove this comment to enable)
#### Tasks 📍
- [ ] Manual Testing
- [ ] Needs Automation
- [ ] Verify Fix
-->
---
 .../labkey/core/view/template/bootstrap/navigation.jsp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/core/src/org/labkey/core/view/template/bootstrap/navigation.jsp b/core/src/org/labkey/core/view/template/bootstrap/navigation.jsp
index da033714512..d885448d20b 100644
--- a/core/src/org/labkey/core/view/template/bootstrap/navigation.jsp
+++ b/core/src/org/labkey/core/view/template/bootstrap/navigation.jsp
@@ -114,8 +114,8 @@
                             if (show && null != tab.getText() && !tab.getText().isEmpty())
                             {
                 %>
-                <li role="presentation" class="<%= unsafe(tab.isSelected() ? "active" : "") %>">
-                    <a href="<%=h(tab.getHref())%>" id="<%=h(tab.getText().replace(" ", ""))%>Tab">
+                <li class="<%= unsafe(tab.isSelected() ? "active" : "") %>">
+                    <a href="<%=h(tab.getHref())%>" id="<%=h(tab.getText().replace(" ", ""))%>Tab"<%= unsafe(tab.isSelected() ? " aria-current=\"page\"" : "") %>>
                         <% if (tab.isDisabled()) { %>
                         <i class="fa fa-eye-slash"></i>
                         <% } %>
@@ -141,7 +141,7 @@
                     {
                         HtmlString plus = HtmlString.unsafe("<i class=\"fa fa-plus\" style=\"font-size: 12px;\"></i>");
                 %>
-                <li role="presentation">
+                <li>
                     <%=simpleLink(plus).id("addTab").title("Add New Tab").onClick("LABKEY.Portal.addTab();")%>
                 </li>
                 <%
@@ -160,7 +160,7 @@
                                 if (tab.isSelected())
                                 {
                 %>
-                <li role="presentation" class="dropdown active">
+                <li class="dropdown active">
                     <a data-target="#" class="dropdown-toggle" data-toggle="dropdown">
                         <%=h(tab.getText())%>&nbsp;
                         <span class="fa fa-chevron-down" style="font-size: 12px;"></span>
@@ -181,7 +181,7 @@
                                 {
                         %>
                         <li>
-                            <a href="<%=h(tab.getHref())%>">
+                            <a href="<%=h(tab.getHref())%>"<%= unsafe(tab.isSelected() ? " aria-current=\"page\"" : "") %>>
                                 <% if (tab.isSelected())
                                    {
                                         %><b><%=h(tab.getText())%></b><%

From 295704c236ba8c6ebd7031880cb57ca796d466e7 Mon Sep 17 00:00:00 2001
From: Josh Eckels <jeckels@labkey.com>
Date: Fri, 3 Apr 2026 12:59:21 -0700
Subject: [PATCH 2/5] Use ReleaseVersion instead of no-longer-populated vcsTag
 (#7542)

---
 api/src/org/labkey/api/module/DefaultModule.java     | 12 +-----------
 api/src/org/labkey/api/module/MockModule.java        |  6 ------
 api/src/org/labkey/api/module/Module.java            |  1 -
 api/src/org/labkey/api/util/UsageReportingLevel.java |  6 ++++--
 4 files changed, 5 insertions(+), 20 deletions(-)

diff --git a/api/src/org/labkey/api/module/DefaultModule.java b/api/src/org/labkey/api/module/DefaultModule.java
index 7ef73cc157a..4efd224d43c 100644
--- a/api/src/org/labkey/api/module/DefaultModule.java
+++ b/api/src/org/labkey/api/module/DefaultModule.java
@@ -137,7 +137,6 @@ public abstract class DefaultModule implements Module, ApplicationContextAware
     private String _vcsRevision = null;
     private String _vcsUrl = null;
     private String _vcsBranch = "Unknown";
-    private String _vcsTag = "Unknown";
     private String _buildUser = null;
     private String _buildTime = null;
     private String _buildOS = null;
@@ -818,17 +817,10 @@ public void setVcsBranch(String vcsBranch)
         _vcsBranch = vcsBranch;
     }
 
-    @Nullable
-    @Override
-    public String getVcsTag()
-    {
-        return _vcsTag;
-    }
-
     @SuppressWarnings({"UnusedDeclaration"})
     public void setVcsTag(String vcsTag)
     {
-        _vcsTag = vcsTag;
+        // Ignored - present in module.xml but not used
     }
 
     public final String getBuildUser()
@@ -974,7 +966,6 @@ public final Map<String, String> getProperties()
         props.put("VCS URL", getVcsUrl());
         props.put("VCS Revision", getVcsRevision());
         props.put("VCS Branch", getVcsBranch());
-        props.put("VCS Tag", getVcsTag());
         props.put("Build OS", getBuildOS());
 
         props.put("Build Time", getBuildTime());
@@ -1605,7 +1596,6 @@ public void copyPropertiesFrom(DefaultModule from)
         this.setUrl(from.getUrl());
         this.setVcsBranch(from.getVcsBranch());
         this.setVcsRevision(from.getVcsRevision());
-        this.setVcsTag(from.getVcsTag());
         this.setVcsUrl(from.getVcsUrl());
         this.setZippedPath(from.getZippedPath());
     }
diff --git a/api/src/org/labkey/api/module/MockModule.java b/api/src/org/labkey/api/module/MockModule.java
index ee2c70dbc23..1d98b34f1e6 100644
--- a/api/src/org/labkey/api/module/MockModule.java
+++ b/api/src/org/labkey/api/module/MockModule.java
@@ -331,12 +331,6 @@ public String getVcsBranch()
         return null;
     }
 
-    @Override
-    public String getVcsTag()
-    {
-        return null;
-    }
-
     @Override
     public boolean shouldManageVersion()
     {
diff --git a/api/src/org/labkey/api/module/Module.java b/api/src/org/labkey/api/module/Module.java
index e72d8e5350e..8785d11d9b4 100644
--- a/api/src/org/labkey/api/module/Module.java
+++ b/api/src/org/labkey/api/module/Module.java
@@ -311,7 +311,6 @@ default void startBackgroundThreads()
     String getVcsRevision();
     String getVcsUrl();
     String getVcsBranch();
-    String getVcsTag();
     String getBuildNumber();
 
     default String getBuildTime()
diff --git a/api/src/org/labkey/api/util/UsageReportingLevel.java b/api/src/org/labkey/api/util/UsageReportingLevel.java
index 37a7ead98ac..70b1f35e088 100644
--- a/api/src/org/labkey/api/util/UsageReportingLevel.java
+++ b/api/src/org/labkey/api/util/UsageReportingLevel.java
@@ -327,9 +327,11 @@ public static void putModulesBuildInfo(Map<String, Map<String, Object>> allModul
             moduleBuildInfo.put("vcsUrl", module.getVcsUrl());
             moduleBuildInfo.put("vcsBranch", module.getVcsBranch());
             moduleBuildInfo.put("vcsRevision", module.getVcsRevision());
-            moduleBuildInfo.put("vcsTag", module.getVcsTag());
+            // We stopped capturing the Git tag in module metadata. The release version property serves
+            // the same purpose. Continue reporting as vcsTag for backwards compatibility with mothership reporting.
+            moduleBuildInfo.put("vcsTag", module.getReleaseVersion());
             moduleBuildInfo.put("moduleClass", module.getClass().getName());
-            moduleBuildInfo.put("version", module.getFormattedSchemaVersion()); // TODO: call this "schemaVersion"? Also send "releaseVersion"?
+            moduleBuildInfo.put("version", module.getFormattedSchemaVersion()); // TODO: call this "schemaVersion"?
 
             // Add to the module's info to be included in the submission
             moduleStats.put("buildInfo", moduleBuildInfo);

From d35b630e1c8c2e3676316b30c77e6dbce2abb24c Mon Sep 17 00:00:00 2001
From: Adam Rauch <adam@labkey.com>
Date: Sat, 4 Apr 2026 08:57:47 -0700
Subject: [PATCH 3/5] MCP Server MVP (#7506) (#7548)

---
 api/src/org/labkey/api/mcp/McpException.java  |  11 +
 api/src/org/labkey/api/mcp/McpService.java    | 147 ++-
 .../org/labkey/api/mcp/NoopMcpService.java    |  87 ++
 .../org/labkey/api/module/McpProvider.java    |  24 -
 .../api/security/RequiresNoPermission.java    |  12 +-
 .../api/security/RequiresPermission.java      |   6 +-
 core/src/org/labkey/core/CoreMcp.java         |  83 +-
 core/src/org/labkey/core/CoreModule.java      |   6 -
 core/src/org/labkey/core/FileBasedModules.md  | 442 +++++++++
 .../org/labkey/core/mcp/McpServiceImpl.java   | 916 ------------------
 .../labkey/query/controllers/QueryMcp.java    | 229 ++---
 .../src/org/labkey/search/SearchModule.java   |  12 +-
 12 files changed, 837 insertions(+), 1138 deletions(-)
 create mode 100644 api/src/org/labkey/api/mcp/McpException.java
 create mode 100644 api/src/org/labkey/api/mcp/NoopMcpService.java
 delete mode 100644 api/src/org/labkey/api/module/McpProvider.java
 create mode 100644 core/src/org/labkey/core/FileBasedModules.md
 delete mode 100644 core/src/org/labkey/core/mcp/McpServiceImpl.java

diff --git a/api/src/org/labkey/api/mcp/McpException.java b/api/src/org/labkey/api/mcp/McpException.java
new file mode 100644
index 00000000000..e9270a8f88f
--- /dev/null
+++ b/api/src/org/labkey/api/mcp/McpException.java
@@ -0,0 +1,11 @@
+package org.labkey.api.mcp;
+
+// A special exception that MCP endpoints can throw when they want to provide guidance to the client without making
+// it a big red error. The message will be extracted and sent as text to the client.
+public class McpException extends RuntimeException
+{
+    public McpException(String message)
+    {
+        super(message);
+    }
+}
diff --git a/api/src/org/labkey/api/mcp/McpService.java b/api/src/org/labkey/api/mcp/McpService.java
index 67854a58c61..63bfcaabfa6 100644
--- a/api/src/org/labkey/api/mcp/McpService.java
+++ b/api/src/org/labkey/api/mcp/McpService.java
@@ -3,13 +3,19 @@
 
 import io.modelcontextprotocol.server.McpServerFeatures;
 import jakarta.servlet.http.HttpSession;
+import org.apache.logging.log4j.Logger;
 import org.jetbrains.annotations.NotNull;
 import org.jspecify.annotations.NonNull;
-import org.labkey.api.module.McpProvider;
+import org.labkey.api.data.Container;
+import org.labkey.api.security.User;
 import org.labkey.api.services.ServiceRegistry;
+import org.labkey.api.settings.OptionalFeatureService;
 import org.labkey.api.util.HtmlString;
-import org.springaicommunity.mcp.provider.resource.SyncMcpResourceProvider;
+import org.labkey.api.util.logging.LogHelper;
+import org.labkey.api.writer.ContainerUser;
 import org.springframework.ai.chat.client.ChatClient;
+import org.springframework.ai.chat.model.ToolContext;
+import org.springframework.ai.mcp.annotation.provider.resource.SyncMcpResourceProvider;
 import org.springframework.ai.support.ToolCallbacks;
 import org.springframework.ai.tool.ToolCallback;
 import org.springframework.ai.tool.ToolCallbackProvider;
@@ -19,23 +25,98 @@
 import java.util.List;
 import java.util.function.Supplier;
 
-/**
- * This service lets you expose functionality over the MCP protocol (only simple http for now).  This allows
- * external chat sessions to pull information from LabKey Server.  These methods are also made available
- * to chat session hosted by LabKey (see AbstractAgentAction).
- * <p></p>
- * These calls are not security checked.  Any tools registered here must check user permissions.  Maybe that
- * will come as we get further along.  Note that the LLM may make callbacks concerning containers other than the
- * current container.  This is an area for investigation.
- */
+///
+/// ### MCP Development Guide
+/// `McpService` lets you expose functionality over the MCP protocol (only simple http for now). This allows external
+/// chat sessions to pull information from LabKey Server. Exposed functionality is also made available to chat sessions
+/// hosted by LabKey (see `AbstractAgentAction``).
+///
+/// ### Adding a new MCP class
+/// 1. Create a new class that implements `McpImpl` (see below) in the appropriate module
+/// 2. Register that class in your module `init()` method: `McpService.get().register(new MyMcp())`
+/// 3. Add tools and resources
+///
+/// ### Adding a new MCP tool
+/// 1.  In your MCP class, create a new method that returns a String with the name you want to advertise
+/// 2.  Annotate it with `@Tool` and provide a detailed description. This description is important since it instructs
+///     the LLM client (and the user) in the use of your tool.
+/// 3.  Annotate it with `@RequiredPermission(Class&lt;? extends Permission>)` or `@RequiredNoPermission`. **A
+///     permission annotation is required, otherwise your tool will not be registered.**
+/// 4.  Add `ToolContext` as the first parameter to the method
+/// 5.  Add additional required or optional parameters to the method signature, as needed. Note that "required" is the
+///     default. Again here, the parameter descriptions are very important. Provide examples.
+/// 6.  Use the helper method `getContext(ToolContext)` to retrieve the current `Container` and `User`
+/// 7.  Use the helper method `getUser(ToolContext)` in the rare cases where you need just a `User`
+/// 8.  Perform additional permissions checking (beyond what the annotations offer), where appropriate
+/// 9.  Filter all results to the current container, of course
+/// 10. For any error conditions, throw exceptions with detailed information. These will get translated into appropriate
+///     failure responses and the LLM client will attempt to correct the problem.
+/// 11. For success cases, return a String with a message or JSON content, for example, `JSONObject.toString()`. Spring
+///     has some limited ability to convert other objects into JSON strings, but we haven't experimented with that. See
+///     `DefaultToolCallResultConverter` and the ability to provide a custom result converter via the `@Tool` annotation.
+///
+/// At registration time, the framework will:
+/// - Ensure all tools are annotated for permissions
+/// - Ensure there aren't multiple tools with the same name
+///
+/// On every tool request, before invoking any tool code, the framework will:
+/// - Authenticate the user or provide a guest user
+/// - Ensure a container has been set if the tool requires a container
+/// - Verify that the user has whatever permissions are required based on the tool's annotation(s)
+/// - Verify that every required parameter is non-null and every string parameter is non-blank
+/// - Push the container and user into the ToolContext to give the tool access
+/// - Increment a metrics counter for that tool
+///
+/// CoreMcp and QueryMcp have examples of tool declarations.
+///
+/// ### Adding a new MCP resource
+/// 1. In your MCP class, create a new method that returns `ReadResourceResult` with an appropriate name
+/// 2. Annotate it with `@McpResource` and provide a uri, mimeType, name, and description
+/// 3. Call `incrementResourceRequestCount()` with a short but unique name to increment its metrics count
+/// 4. Read the resource, construct a `ReadResourceResult`, and return it.
+///
+/// No permissions checking is performed on resources. All resources are public.
+///
+/// CoreMcp and QueryMcp have examples of resource declarations.
+///
 public interface McpService extends ToolCallbackProvider
 {
-    // marker interface for classes that we will "ingest" using Spring annotations
-    interface McpImpl {}
+    Logger LOG = LogHelper.getLogger(McpService.class, "MCP registration exceptions");
+    String ENABLE_MCP_SERVER_FLAG = "enableMcpServer";
+
+    // Interface for MCP classes that we will "ingest" using Spring annotations. Provides a few helper methods.
+    interface McpImpl
+    {
+        default ContainerUser getContext(ToolContext toolContext)
+        {
+            User user = (User)toolContext.getContext().get("user");
+            Container container = (Container)toolContext.getContext().get("container");
+            if (container == null)
+                throw new McpException("No container path is set. Ask the user which container/folder they want to use (you can call listContainers to show available options), then call setContainer before retrying.");
+            return ContainerUser.create(container, user);
+        }
+
+        default User getUser(ToolContext toolContext)
+        {
+            return (User)toolContext.getContext().get("user");
+        }
+
+        // Every MCP resource should call this on every invocation
+        default void incrementResourceRequestCount(String resource)
+        {
+            if (!OptionalFeatureService.get().isFeatureEnabled(ENABLE_MCP_SERVER_FLAG))
+                throw new RuntimeException("The MCP server is not enabled for external requests. Consider toggling the experimental feature flag.");
+
+            get().incrementResourceRequestCount(resource);
+        }
+    }
 
     static @NotNull McpService get()
     {
-        return ServiceRegistry.get().getService(McpService.class);
+        McpService svc = ServiceRegistry.get().getService(McpService.class);
+        if (svc == null)
+            svc = NoopMcpService.get();
+        return svc;
     }
 
     static void setInstance(McpService service)
@@ -45,27 +126,25 @@ static void setInstance(McpService service)
 
     boolean isReady();
 
-
-    default void register(McpImpl obj)
+    default void register(McpImpl mcp)
     {
-        ToolCallback[] tools = ToolCallbacks.from(obj);
-        if (null != tools && tools.length > 0)
-            registerTools(Arrays.asList(tools));
-
-        var resources = new SyncMcpResourceProvider(List.of(obj)).getResourceSpecifications();
-        if (null != resources && !resources.isEmpty())
-            registerResources(resources);
+        try
+        {
+            ToolCallback[] tools = ToolCallbacks.from(mcp);
+            if (tools.length > 0)
+                registerTools(Arrays.asList(tools), mcp);
+
+            var resources = new SyncMcpResourceProvider(List.of(mcp)).getResourceSpecifications();
+            if (null != resources && !resources.isEmpty())
+                registerResources(resources);
+        }
+        catch (NoSuchMethodError t)
+        {
+            LOG.error("You likely need to do a clean build of API! Exception while registering an MCP implementation.", t);
+        }
     }
 
-
-    default void register(McpProvider mcp)
-    {
-        registerTools(mcp.getMcpTools());
-        registerPrompts(mcp.getMcpPrompts());
-        registerResources(mcp.getMcpResources());
-    }
-
-    void registerTools(@NotNull List<ToolCallback> tools);
+    void registerTools(@NotNull List<ToolCallback> tools, McpImpl mcp);
 
     void registerPrompts(@NotNull List<McpServerFeatures.SyncPromptSpecification> prompts);
 
@@ -79,6 +158,10 @@ default ChatClient getChat(HttpSession session, String agentName, Supplier<Strin
         return getChat(session, agentName, systemPromptSupplier, true);
     }
 
+    void saveSessionContainer(ToolContext context, Container container);
+
+    void incrementResourceRequestCount(String resource);
+
     ChatClient getChat(HttpSession session, String agentName, Supplier<String> systemPromptSupplier, boolean createIfNotExists);
 
     void close(HttpSession session, ChatClient chat);
diff --git a/api/src/org/labkey/api/mcp/NoopMcpService.java b/api/src/org/labkey/api/mcp/NoopMcpService.java
new file mode 100644
index 00000000000..f6f63534ce0
--- /dev/null
+++ b/api/src/org/labkey/api/mcp/NoopMcpService.java
@@ -0,0 +1,87 @@
+package org.labkey.api.mcp;
+
+import io.modelcontextprotocol.server.McpServerFeatures;
+import jakarta.servlet.http.HttpSession;
+import org.jetbrains.annotations.NotNull;
+import org.jspecify.annotations.NonNull;
+import org.labkey.api.data.Container;
+import org.springframework.ai.chat.client.ChatClient;
+import org.springframework.ai.chat.model.ToolContext;
+import org.springframework.ai.tool.ToolCallback;
+import org.springframework.ai.vectorstore.VectorStore;
+
+import java.util.List;
+import java.util.function.Supplier;
+
+class NoopMcpService implements McpService
+{
+    private static final McpService INSTANCE = new NoopMcpService();
+
+    static McpService get()
+    {
+        return INSTANCE;
+    }
+
+    @Override
+    public boolean isReady()
+    {
+        return false;
+    }
+
+    @Override
+    public void registerTools(@NotNull List<ToolCallback> tools, McpImpl mcp)
+    {
+
+    }
+
+    @Override
+    public void registerPrompts(@NotNull List<McpServerFeatures.SyncPromptSpecification> prompts)
+    {
+
+    }
+
+    @Override
+    public void registerResources(@NotNull List<McpServerFeatures.SyncResourceSpecification> resources)
+    {
+
+    }
+
+    @Override
+    public ToolCallback @NonNull [] getToolCallbacks()
+    {
+        return new ToolCallback[0];
+    }
+
+    @Override
+    public void saveSessionContainer(ToolContext context, Container container)
+    {
+    }
+
+    @Override
+    public void incrementResourceRequestCount(String resource)
+    {
+    }
+
+    @Override
+    public ChatClient getChat(HttpSession session, String agentName, Supplier<String> systemPromptSupplier, boolean createIfNotExists)
+    {
+        return null;
+    }
+
+    @Override
+    public void close(HttpSession session, ChatClient chat)
+    {
+    }
+
+    @Override
+    public MessageResponse sendMessage(ChatClient chat, String message)
+    {
+        return null;
+    }
+
+    @Override
+    public VectorStore getVectorStore()
+    {
+        return null;
+    }
+}
diff --git a/api/src/org/labkey/api/module/McpProvider.java b/api/src/org/labkey/api/module/McpProvider.java
deleted file mode 100644
index 6ca9061e73f..00000000000
--- a/api/src/org/labkey/api/module/McpProvider.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package org.labkey.api.module;
-
-import io.modelcontextprotocol.server.McpServerFeatures;
-import org.springframework.ai.tool.ToolCallback;
-
-import java.util.List;
-
-public interface McpProvider
-{
-    default List<ToolCallback> getMcpTools()
-    {
-        return List.of();
-    }
-
-    default List<McpServerFeatures.SyncPromptSpecification> getMcpPrompts()
-    {
-        return List.of();
-    }
-
-    default List<McpServerFeatures.SyncResourceSpecification> getMcpResources()
-    {
-        return List.of();
-    }
-}
diff --git a/api/src/org/labkey/api/security/RequiresNoPermission.java b/api/src/org/labkey/api/security/RequiresNoPermission.java
index 77d640cb657..c09a43a06b5 100644
--- a/api/src/org/labkey/api/security/RequiresNoPermission.java
+++ b/api/src/org/labkey/api/security/RequiresNoPermission.java
@@ -21,12 +21,12 @@
 import java.lang.annotation.Target;
 
 /**
- * Indicates that an action does not require any kind of authentication or permission to invoke. Use with extreme
- * caution. Typically, actions marked with this annotation will handle their own permission checks in their own code path.
- * User: adam
- * Date: Dec 22, 2009
-*/
-public @Retention(java.lang.annotation.RetentionPolicy.RUNTIME) @Target(ElementType.TYPE)
+ * Indicates that an action class or an MCP tool method does not require any kind of authentication or permission to
+ * invoke. Use with extreme caution. Typically, actions marked with this annotation will handle their own permission
+ * checks in their own code path. Note that this is the lowest priority permission annotation; all other @Requires*
+ * annotations effectively override this annotation.
+ */
+public @Retention(java.lang.annotation.RetentionPolicy.RUNTIME) @Target({ElementType.TYPE, ElementType.METHOD})
 @interface RequiresNoPermission
 {
 }
\ No newline at end of file
diff --git a/api/src/org/labkey/api/security/RequiresPermission.java b/api/src/org/labkey/api/security/RequiresPermission.java
index 8630a20a2ad..ed7dec3a3e0 100644
--- a/api/src/org/labkey/api/security/RequiresPermission.java
+++ b/api/src/org/labkey/api/security/RequiresPermission.java
@@ -22,10 +22,10 @@
 import java.lang.annotation.Target;
 
 /**
- * Specifies the required permission for an action. It does not imply that the user needs to be logged in or otherwise
- * authenticated.
+ * Specifies the required permission for an action class or an MCP tool method. It does not imply that the user needs
+ * to be logged in or otherwise authenticated.
  */
-@Retention(java.lang.annotation.RetentionPolicy.RUNTIME) @Target(ElementType.TYPE)
+@Retention(java.lang.annotation.RetentionPolicy.RUNTIME) @Target({ElementType.TYPE, ElementType.METHOD})
 public @interface RequiresPermission
 {
     Class<? extends Permission> value();
diff --git a/core/src/org/labkey/core/CoreMcp.java b/core/src/org/labkey/core/CoreMcp.java
index 06482fe5627..da97a986ba9 100644
--- a/core/src/org/labkey/core/CoreMcp.java
+++ b/core/src/org/labkey/core/CoreMcp.java
@@ -1,17 +1,30 @@
 package org.labkey.core;
 
+import io.modelcontextprotocol.spec.McpSchema;
+import io.modelcontextprotocol.spec.McpSchema.ReadResourceResult;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.json.JSONObject;
+import org.labkey.api.collections.LabKeyCollectors;
 import org.labkey.api.data.Container;
-import org.labkey.api.mcp.McpContext;
+import org.labkey.api.data.ContainerManager;
 import org.labkey.api.mcp.McpService;
+import org.labkey.api.security.RequiresNoPermission;
+import org.labkey.api.security.RequiresPermission;
 import org.labkey.api.security.User;
+import org.labkey.api.security.permissions.ReadPermission;
 import org.labkey.api.settings.AppProps;
 import org.labkey.api.settings.LookAndFeelProperties;
 import org.labkey.api.study.Study;
 import org.labkey.api.study.StudyService;
 import org.labkey.api.util.HtmlString;
+import org.springframework.ai.chat.model.ToolContext;
+import org.springframework.ai.mcp.annotation.McpResource;
 import org.springframework.ai.tool.annotation.Tool;
+import org.springframework.ai.tool.annotation.ToolParam;
 
+import java.io.IOException;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 
@@ -19,13 +32,14 @@
 
 public class CoreMcp implements McpService.McpImpl
 {
-    // TODO ChatSessions are currently per session.  The McpService should detect change of folder.
-    @Tool(description = "Call this tool before answering any prompts!  This tool provides useful context information about the current user (name, userid), webserver (name, url, description), and current folder (name, path, url, description).")
-    String whereAmIWhoAmITalkingTo()
+    @Tool(description = "This tool provides useful context information about the current user (name, userid), webserver " +
+        "(name, url, description), and current container/folder (name, path, url, description) once the container is set via setContainer.")
+    @RequiresPermission(ReadPermission.class)
+    String whereAmIWhoAmITalkingTo(ToolContext context)
     {
-        McpContext context = McpContext.get();
-        User user = context.getUser();
-        Container folder = context.getContainer();
+        var cu = getContext(context);
+        User user = cu.getUser();
+        Container folder = cu.getContainer();
         AppProps appProps = AppProps.getInstance();
         Study study = null != StudyService.get() ? Objects.requireNonNull(StudyService.get()).getStudy(folder) : null;
         LookAndFeelProperties laf = LookAndFeelProperties.getInstance(folder);
@@ -63,4 +77,59 @@ String whereAmIWhoAmITalkingTo()
             "site", siteObj
         )).toString();
     }
+
+    @Tool(description = "List the hierarchical path for every container in the server where the user has read permissions.")
+    @RequiresNoPermission
+    String listContainers(ToolContext toolContext)
+    {
+        return ContainerManager.getAllChildren(ContainerManager.getRoot(), getUser(toolContext), ReadPermission.class)
+            .stream()
+            .map(container -> StringUtils.stripStart(container.getPath(), "/")) // No leading slash since typing that brings up custom shortcuts
+            .collect(LabKeyCollectors.toJSONArray())
+            .toString();
+    }
+
+    @Tool(description = "Every tool in this MCP requires a container path, e.g. MyProject/MyFolder. A container is also called a folder or project. " +
+        "Please prompt the user for a container path and use this tool to save the path for this MCP session. The user can also change the container " +
+        "during the session using this tool. The user must have read permissions in the container, in other words, the path must be on the list that " +
+        "the listContainers tool returns. Don't suggest a leading slash on the path because typing a slash in some LLM clients triggers custom shortcuts.")
+    @RequiresNoPermission // Because we don't have a container yet, but the tool will verify read permission before setting the container
+    String setContainer(ToolContext context, @ToolParam(description = "Container path, e.g. MyProject/MyFolder") String containerPath)
+    {
+        final String message;
+
+        Container container = ContainerManager.getForPath(containerPath);
+
+        // Must exist and user must have read permission to set a container. Note: Send the same message in either
+        // case to prevent information exposure.
+        if (container == null || !container.hasPermission(getUser(context), ReadPermission.class))
+        {
+            message = "That's not a valid container path. Try using listContainers to see the valid options.";
+        }
+        else
+        {
+            McpService.get().saveSessionContainer(context, container);
+            message = "Container has been set to " + container.getPath();
+        }
+
+        return message;
+    }
+
+    @McpResource(
+        uri = "resource://org/labkey/core/FileBasedModules.md",
+        mimeType = "application/markdown",
+        name = "File-Based Module Development Guide",
+        description = "Provide documentation for developing LabKey file-based modules")
+    public ReadResourceResult getFileBasedModuleDevelopmentGuide() throws IOException
+    {
+        incrementResourceRequestCount("File-Based Modules");
+        String markdown = IOUtils.resourceToString("org/labkey/core/FileBasedModules.md", null, CoreModule.class.getClassLoader());
+        return new ReadResourceResult(List.of(
+            new McpSchema.TextResourceContents(
+                "resource://org/labkey/core/FileBasedModules.md",
+                "application/markdown",
+                markdown
+            )
+        ));
+    }
 }
diff --git a/core/src/org/labkey/core/CoreModule.java b/core/src/org/labkey/core/CoreModule.java
index 4c5cc386958..2312ec48f5f 100644
--- a/core/src/org/labkey/core/CoreModule.java
+++ b/core/src/org/labkey/core/CoreModule.java
@@ -254,7 +254,6 @@
 import org.labkey.core.login.DbLoginAuthenticationProvider;
 import org.labkey.core.login.DbLoginManager;
 import org.labkey.core.login.LoginController;
-import org.labkey.core.mcp.McpServiceImpl;
 import org.labkey.core.metrics.SimpleMetricsServiceImpl;
 import org.labkey.core.metrics.WebSocketConnectionManager;
 import org.labkey.core.notification.EmailPreferenceConfigServiceImpl;
@@ -1284,8 +1283,6 @@ public void moduleStartupComplete(ServletContext servletContext)
         UserManager.addUserListener(new EmailPreferenceUserListener());
 
         Encryption.checkMigration();
-
-        McpServiceImpl.get().startMpcServer();
     }
 
     // Issue 7527: Auto-detect missing SQL views and attempt to recreate
@@ -1320,9 +1317,6 @@ public void registerServlets(ServletContext servletCtx)
         _webdavServletDynamic = servletCtx.addServlet("static", new WebdavServlet(true));
         _webdavServletDynamic.setMultipartConfig(SpringActionController.getMultiPartConfigElement());
         _webdavServletDynamic.addMapping("/_webdav/*");
-
-        McpService.setInstance(new McpServiceImpl());
-        McpServiceImpl.get().registerServlets(servletCtx);
     }
 
     @Override
diff --git a/core/src/org/labkey/core/FileBasedModules.md b/core/src/org/labkey/core/FileBasedModules.md
new file mode 100644
index 00000000000..20fc8811fb2
--- /dev/null
+++ b/core/src/org/labkey/core/FileBasedModules.md
@@ -0,0 +1,442 @@
+# File-Based Module Development Guide
+
+This document provides guidance for creating and developing LabKey file-based modules.
+
+## What is a File-Based Module?
+
+A file-based module is a LabKey module that doesn't contain any Java code. It enables custom development without compiling, letting you directly deploy and test module resources, often without restarting the server. File-based modules support:
+
+- SQL queries and views
+- Reports (R, JavaScript, HTML)
+- Custom data views
+- Web parts and HTML/JavaScript client-side applications
+- Assay definitions
+- ETL configurations
+- Pipeline definitions
+
+## Module Directory Structure
+
+### Development/Source Layout
+```
+myModule/
+├── module.properties          # Module configuration (REQUIRED)
+├── README.md                  # Module documentation
+└── resources/                 # All module resources go here
+    ├── queries/               # SQL queries and query metadata
+    │   └── [schema_name]/     # Organize by schema
+    │       ├── [query_name].sql
+    │       ├── [query_name].query.xml
+    │       └── [query_name]/  # Query-specific views
+    │           └── [view_name].html
+    ├── reports/               # Report definitions
+    │   └── schemas/
+    │       └── [schema_name]/
+    │           └── [query_name]/
+    │               ├── [report_name].r
+    │               ├── [report_name].rhtml
+    │               └── [report_name].report.xml
+    ├── views/                 # Custom views and web parts
+    │   ├── [view_name].html
+    │   └── [view_name].webpart.xml
+    ├── schemas/               # Database schema definitions
+    │   └── dbscripts/
+    │       ├── postgresql/
+    │       └── sqlserver/
+    ├── web/                   # JavaScript, CSS, images
+    │   └── [moduleName]/
+    │       ├── [moduleName].js
+    │       └── [moduleName].css
+    ├── assay/                 # Assay type definitions
+    ├── etls/                  # ETL configurations
+    ├── folderTypes/           # Custom folder type definitions
+    └── pipeline/              # Pipeline task definitions
+```
+
+### Deployed Layout
+When deployed, the structure changes slightly:
+- `resources/` directory contents move to root level
+- `module.properties` becomes `config/module.xml`
+- Compiled code (if any) goes to `lib/`
+
+## module.properties File
+
+This is the **required** configuration file for your module. Place it in the module root.
+
+### Required Properties
+```properties
+ModuleClass: org.labkey.api.module.SimpleModule
+Name: myModule
+```
+
+### Recommended Properties
+```properties
+ModuleClass: org.labkey.api.module.SimpleModule
+Name: myModule
+Label: My Custom Module
+Description: A file-based module for custom queries, reports, and views.\
+             Multi-line descriptions can span multiple lines using backslash continuation.
+Version: 1.0.0
+Author: Your Name <your.email@example.com>
+Organization: Your Organization
+OrganizationURL: https://example.com
+License: Apache 2.0
+LicenseURL: https://www.apache.org/licenses/LICENSE-2.0
+Maintainer: Your Name <your.email@example.com>
+RequiredServerVersion: 23.11
+```
+`Name` should usually be the same as the directory name, especially for file-based modules.
+
+### Additional Properties
+- **SchemaVersion**: Version number for SQL schema upgrade scripts (e.g., `1.00`)
+- **ManageVersion**: Boolean (true/false) for schema version management
+- **BuildType**: "Development" or "Production"
+- **SupportedDatabases**: "pgsql" or "mssql" (comma-separated)
+- **URL**: Homepage URL for the module
+
+### Auto-Generated Properties (Don't Set)
+These are set during build: BuildNumber, BuildOS, BuildPath, BuildTime, BuildUser, EnlistmentId, ResourcePath, SourcePath, VcsRevision, VcsURL
+
+## Creating Web Parts
+
+Web parts are HTML views that can be added to LabKey pages.
+
+### Basic Web Part Structure
+
+**File**: `resources/views/myWebPart.html`
+```html
+<div class="labkey-module-content">
+    <h2>My Web Part</h2>
+    <p>Content goes here</p>
+</div>
+
+<script type="text/javascript" nonce="<%=scriptNonce%>">
+// JavaScript code here
+// IMPORTANT: Always include nonce="<%=scriptNonce%>" for CSP compliance
+</script>
+```
+
+**Configuration**: `resources/views/myWebPart.webpart.xml`
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<webpart xmlns="http://labkey.org/data/xml/webpart">
+    <name>My Web Part</name>
+    <description>Description of what this web part does</description>
+    <location>body</location>
+</webpart>
+```
+
+### Important: Content Security Policy (CSP)
+
+LabKey enforces CSP, so **all inline scripts must include the nonce attribute**:
+```html
+<script type="text/javascript" nonce="<%=scriptNonce%>">
+    // Your code here
+</script>
+```
+
+Without the nonce, your inline scripts will be blocked by the browser.
+
+### Template Variables
+
+LabKey automatically substitutes the following variables in HTML view files (use `<%=variableName%>` syntax):
+
+- **scriptNonce**: CSP nonce for inline scripts. **Required for all `<script>` tags** to comply with Content Security Policy.
+  ```html
+  <script type="text/javascript" nonce="<%=scriptNonce%>">
+  ```
+
+- **contextPath**: The web application's context path (e.g., `/labkey`). Use for building URLs to server resources.
+  ```javascript
+  var url = '<%=contextPath%>' + '/someResource.js';
+  ```
+
+- **containerPath**: The current container's path (e.g., `/MyProject/MyFolder`). Use for building container-specific URLs.
+  ```javascript
+  var containerUrl = '<%=contextPath%>' + '<%=containerPath%>';
+  ```
+
+- **wrapperDivId**: A unique ID for the wrapper div containing the view (format: `ModuleHtmlView_<uniqueID>`). Useful for scoping JavaScript or CSS to a specific view instance.
+  ```javascript
+  var wrapper = document.getElementById('<%=wrapperDivId%>');
+  ```
+
+- **id**: The web part's row ID (or `-1` if not rendered as a web part). Use to identify specific web part instances.
+  ```javascript
+  var webPartId = <%=id%>; // Note: no quotes, this is a number
+  ```
+
+- **webpartContext**: A JSON string containing configuration for the web part, including:
+  - `wrapperDivId`: The wrapper div ID
+  - `id`: The web part row ID
+  - `properties`: An object containing the web part's custom properties (from webpart.xml configuration)
+  - Any additional properties set on the web part
+
+  ```javascript
+  var config = JSON.parse('<%=webpartContext%>');
+  console.log('Web part ID:', config.id);
+  console.log('Properties:', config.properties);
+  ```
+
+**Note**: The entire view is automatically wrapped in a div with the `wrapperDivId`, so you don't need to create it yourself.
+
+## Using LabKey JavaScript APIs
+
+LabKey provides a comprehensive JavaScript API for interacting with the server.
+
+**Complete API Reference**: For the full JavaDoc-style API documentation, see https://labkey.github.io/labkey-api-js/
+
+### Accessing User and Container Information
+
+User and container information is automatically rendered into the page:
+
+```javascript
+// Access current user information
+console.log('User ID:', LABKEY.user.id);
+console.log('Display Name:', LABKEY.user.displayName);
+console.log('Email:', LABKEY.user.email);
+console.log('Is Admin:', LABKEY.user.isAdmin);
+console.log('Is Guest:', LABKEY.user.isGuest);
+
+// Access current container/folder information
+console.log('Container ID:', LABKEY.container.id);
+console.log('Container Path:', LABKEY.container.path);
+console.log('Container Name:', LABKEY.container.name);
+```
+
+### Common LABKEY JavaScript Objects
+
+- **LABKEY.ActionURL**: Build URLs to LabKey controllers and actions
+- **LABKEY.Ajax**: Make AJAX requests to LabKey APIs
+- **LABKEY.Query**: Execute SQL queries and retrieve data
+- **LABKEY.Security**: Access user permissions and security info
+- **LABKEY.Utils**: Utility functions for common tasks
+
+### Example: Querying Data
+
+```javascript
+LABKEY.Query.selectRows({
+    schemaName: 'lists',
+    queryName: 'MyList',
+    success: function(data) {
+        console.log('Rows:', data.rows);
+    },
+    failure: function(error) {
+        console.error('Query failed:', error);
+    }
+});
+```
+
+## Creating SQL Queries
+
+Place SQL query files in `resources/queries/[schema_name]/`.
+
+### Basic Query
+
+**File**: `resources/queries/core/Users.sql`
+```sql
+SELECT
+    UserId,
+    DisplayName,
+    Email,
+    Active
+FROM core.Users
+WHERE Active = TRUE
+ORDER BY DisplayName
+```
+
+### Query Metadata
+
+**File**: `resources/queries/core/Users.query.xml`
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<query xmlns="http://labkey.org/data/xml/query">
+    <metadata>
+        <columns>
+            <column columnName="UserId">
+                <description>Unique user identifier</description>
+            </column>
+            <column columnName="DisplayName">
+                <description>User's display name</description>
+            </column>
+        </columns>
+    </metadata>
+</query>
+```
+
+## XML Schema Reference
+
+LabKey modules use various XML configuration files with specific schemas. When creating these files, always consult the official schema documentation for complete element and attribute references.
+
+**Official Schema Documentation**: https://www.labkey.org/download/schema-docs/xml-schemas/
+
+### Common XML File Types
+
+| File Type | Purpose | Root Element | Namespace | Location |
+|-----------|---------|--------------|-----------|----------|
+| `.query.xml` | Query metadata (columns, validators, FKs) | `<query>` | `http://labkey.org/data/xml/query` | `resources/queries/[schema]/[query].query.xml` |
+| `.qview.xml` | Custom query views (filters, sorts) | `<cv:customView>` | `http://labkey.org/data/xml/queryCustomView` | `resources/queries/[schema]/[query]/[view].qview.xml` |
+| `.webpart.xml` | Web part configuration | `<webpart>` | `http://labkey.org/data/xml/webpart` | `resources/views/[view].webpart.xml` |
+| `.view.xml` | View with dependencies | `<view>` | `http://labkey.org/data/xml/view` | `resources/views/[view].view.xml` |
+| `.report.xml` | Report definitions (R, JS, etc.) | `<ReportDescriptor>` | `http://labkey.org/query/xml` | `resources/reports/schemas/[schema]/[query]/[report].report.xml` |
+| `.folderType.xml` | Custom folder types | `<ft:folderType>` | `http://labkey.org/data/xml/folderType` | `resources/folderTypes/[name].folderType.xml` |
+| `.task.xml` | Pipeline task definitions | `<task>` | `http://labkey.org/pipeline/xml` | `resources/pipeline/tasks/[task].task.xml` |
+| `.pipeline.xml` | Pipeline definitions | `<pipeline>` | `http://labkey.org/pipeline/xml` | `resources/pipeline/pipelines/[pipeline].pipeline.xml` |
+| `.template.xml` | Domain templates (Lists, DataClasses, SampleSets) | `<templates>` | `http://labkey.org/data/xml/domainTemplate` | `resources/domain-templates/[template].template.xml` |
+
+### Finding Examples
+
+Real-world examples of these XML files can be found in the LabKey testAutomation modules: https://github.com/LabKey/testAutomation/tree/develop/modules
+
+Browse specific modules for examples:
+- **simpletest**: Basic queries, views, web parts, folder types
+- **scriptpad**: Reports and R scripts
+- **pipelinetest2**: Pipeline tasks and definitions
+- **editableModule**: Editable grid queries
+- **linkedschematest**: Schema templates and linked queries
+
+### Key Points
+
+- **Query metadata** (`.query.xml`) often uses two namespaces: the primary `query` namespace for the root element and the `data/xml` namespace for the `<tables>` element
+- **Report descriptors** (`.report.xml`) use two namespaces: `http://labkey.org/query/xml` for the main descriptor and `http://labkey.org/data/xml/reportProps` (prefix `rep:`) for properties
+- **Domain templates** (`.template.xml`) use `xsi:type` to specify template types: `ListTemplateType`, `DataClassTemplateType`, `SampleSetTemplateType`
+- **Pipeline tasks** (`.task.xml`) use `xsi:type` to specify task types: `ScriptTaskType`, `JavaTaskType`, `CommandTaskType`
+- **View files** (`.view.xml`) are used when you need to declare JavaScript/CSS dependencies; simple web parts only need `.webpart.xml`
+
+### Typical Workflow
+
+1. Create the primary resource file (`.sql`, `.html`, `.r`, etc.)
+2. Add the corresponding XML configuration file if needed
+3. Reference the online schema documentation for available elements and attributes
+4. Look at examples in the testAutomation modules on GitHub for real patterns
+5. Test your changes (most XML updates don't require server restart)
+
+## Deployment and Testing
+
+### Location
+
+File-based modules are deployed to:
+```
+<LABKEY_ROOT>/build/deploy/externalModules/[moduleName]/
+```
+
+**IMPORTANT**: Back up your module before running `gradlew cleanBuild` as the build directory may be deleted.
+
+### Enabling the Module
+
+1. Navigate to your target folder in LabKey
+2. Go to **Folder > Management**
+3. Click the **Folder Type** tab
+4. Check your module's checkbox under "Modules"
+5. Click **Update Folder**
+
+### Hot Deployment
+
+Most changes to file-based module resources don't require a server restart:
+- ✅ HTML/JavaScript changes in views: No restart needed
+- ✅ Query definition changes: No restart needed
+- ✅ Report updates: No restart needed
+- ⚠️ module.properties changes: Restart required
+- ⚠️ Adding new resource types: May require restart
+
+Simply refresh your browser to see changes.
+
+## Best Practices
+
+### Security
+- Always use `nonce="<%=scriptNonce%>"` for inline scripts
+- Escape user-supplied data before rendering in HTML
+- Use LABKEY.Utils.encodeHtml() to prevent XSS
+- Never expose sensitive data in client-side code
+
+### Code Organization
+- Keep JavaScript in separate files under `resources/web/[moduleName]/`
+- Use meaningful names for queries, views, and reports
+- Group related queries by schema
+- Document your queries with .query.xml metadata files
+
+### Performance
+- Use query metadata to hide unnecessary columns
+- Limit result sets with WHERE clauses
+- Create database indexes for frequently queried columns
+- Cache expensive queries when possible
+
+### Maintenance
+- Version your module.properties appropriately
+- Document breaking changes in your README
+- Test on both PostgreSQL and SQL Server if supporting both
+- Keep module.properties up to date with RequiredServerVersion
+
+## Common Patterns
+
+### Creating a Dashboard Web Part
+
+```html
+<div class="labkey-module-content">
+    <h2>My Dashboard</h2>
+    <div id="dashboard-content">Loading...</div>
+</div>
+
+<script type="text/javascript" nonce="<%=scriptNonce%>">
+(function() {
+    // Parse web part configuration
+    var config = JSON.parse('<%=webpartContext%>');
+    console.log('Web part ID:', config.id);
+    console.log('Custom properties:', config.properties);
+
+    // Query data in the current container
+    LABKEY.Query.selectRows({
+        containerPath: '<%=containerPath%>',
+        schemaName: 'core',
+        queryName: 'Users',
+        success: function(data) {
+            var html = '<ul>';
+            data.rows.forEach(function(row) {
+                html += '<li>' + LABKEY.Utils.encodeHtml(row.DisplayName) + '</li>';
+            });
+            html += '</ul>';
+
+            // Use wrapperDivId to scope to this specific view instance
+            var wrapper = document.getElementById('<%=wrapperDivId%>');
+            var contentDiv = wrapper.querySelector('#dashboard-content');
+            contentDiv.innerHTML = html;
+        }
+    });
+})();
+</script>
+```
+
+### Adding Custom Button Actions
+
+```html
+<div class="labkey-module-content">
+    <button id="myButton" class="labkey-button">Click Me</button>
+</div>
+
+<script type="text/javascript" nonce="<%=scriptNonce%>">
+(function() {
+    document.getElementById('myButton').addEventListener('click', function() {
+        LABKEY.Utils.alert('Button Clicked', 'You clicked the button!');
+    });
+})();
+</script>
+```
+
+## Documentation Resources
+
+For more information, see:
+- Simple Modules Overview: https://www.labkey.org/Documentation/wiki-page.view?name=simpleModules
+- File-Based Module Tutorial: https://www.labkey.org/Documentation/wiki-page.view?name=moduleqvr
+- JavaScript API Documentation: https://labkey.github.io/labkey-api-js/
+- Module Directory Structures: https://www.labkey.org/Documentation/wiki-page.view?name=moduleDirectoryStructures
+- Query Development: https://www.labkey.org/Documentation/wiki-page.view?name=addSQLQuery
+
+## Quick Start Checklist
+
+- [ ] Create module directory in `build/deploy/externalModules/`
+- [ ] Add `module.properties` with required fields
+- [ ] Create `resources/` directory structure
+- [ ] Add at least one view or query
+- [ ] Enable module in a test folder
+- [ ] Test functionality in browser
+- [ ] Document usage in README.md
+- [ ] Back up module outside build directory
diff --git a/core/src/org/labkey/core/mcp/McpServiceImpl.java b/core/src/org/labkey/core/mcp/McpServiceImpl.java
deleted file mode 100644
index 0937f308a20..00000000000
--- a/core/src/org/labkey/core/mcp/McpServiceImpl.java
+++ /dev/null
@@ -1,916 +0,0 @@
-package org.labkey.core.mcp;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.genai.Client;
-import com.google.genai.types.ClientOptions;
-import io.modelcontextprotocol.json.McpJsonMapper;
-import io.modelcontextprotocol.server.McpServer;
-import io.modelcontextprotocol.server.McpServerFeatures;
-import io.modelcontextprotocol.server.McpSyncServer;
-import io.modelcontextprotocol.server.transport.HttpServletStreamableServerTransportProvider;
-import io.modelcontextprotocol.spec.McpSchema;
-import jakarta.servlet.ServletContext;
-import jakarta.servlet.ServletException;
-import jakarta.servlet.ServletRequest;
-import jakarta.servlet.ServletResponse;
-import jakarta.servlet.http.HttpServlet;
-import jakarta.servlet.http.HttpServletRequest;
-import jakarta.servlet.http.HttpServletRequestWrapper;
-import jakarta.servlet.http.HttpServletResponse;
-import jakarta.servlet.http.HttpSession;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.logging.log4j.Logger;
-import org.jetbrains.annotations.NotNull;
-import org.jspecify.annotations.NonNull;
-import org.labkey.api.collections.CopyOnWriteHashMap;
-import org.labkey.api.markdown.MarkdownService;
-import org.labkey.api.mcp.McpContext;
-import org.labkey.api.mcp.McpService;
-import org.labkey.api.util.ContextListener;
-import org.labkey.api.util.FileUtil;
-import org.labkey.api.util.HtmlString;
-import org.labkey.api.util.JsonUtil;
-import org.labkey.api.util.SessionHelper;
-import org.labkey.api.util.ShutdownListener;
-import org.labkey.api.util.logging.LogHelper;
-import org.springframework.ai.anthropic.AnthropicChatModel;
-import org.springframework.ai.anthropic.AnthropicChatOptions;
-import org.springframework.ai.google.genai.common.GoogleGenAiThinkingLevel;
-import org.springframework.ai.openai.OpenAiChatModel;
-import org.springframework.ai.openai.OpenAiChatOptions;
-import org.springframework.ai.openai.OpenAiEmbeddingModel;
-import org.springframework.ai.openai.OpenAiEmbeddingOptions;
-import org.springframework.ai.openai.api.OpenAiApi;
-import org.springframework.ai.document.MetadataMode;
-import org.springframework.ai.anthropic.api.AnthropicApi;
-import org.springframework.ai.chat.client.ChatClient;
-import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;
-import org.springframework.ai.chat.client.advisor.api.Advisor;
-import org.springframework.ai.chat.client.advisor.vectorstore.QuestionAnswerAdvisor;
-import org.springframework.ai.chat.memory.ChatMemory;
-import org.springframework.ai.chat.memory.ChatMemoryRepository;
-import org.springframework.ai.chat.memory.InMemoryChatMemoryRepository;
-import org.springframework.ai.chat.memory.MessageWindowChatMemory;
-import org.springframework.ai.chat.model.ChatModel;
-import org.springframework.ai.chat.model.Generation;
-import org.springframework.ai.chat.prompt.ChatOptions;
-import org.springframework.ai.chat.prompt.Prompt;
-import org.springframework.ai.embedding.EmbeddingModel;
-import org.springframework.ai.google.genai.GoogleGenAiChatModel;
-import org.springframework.ai.google.genai.GoogleGenAiChatOptions;
-import org.springframework.ai.google.genai.GoogleGenAiEmbeddingConnectionDetails;
-import org.springframework.ai.google.genai.text.GoogleGenAiTextEmbeddingModel;
-import org.springframework.ai.google.genai.text.GoogleGenAiTextEmbeddingOptions;
-import org.springframework.ai.mcp.McpToolUtils;
-import org.springframework.ai.chat.model.ToolContext;
-import org.springframework.ai.tool.ToolCallback;
-import org.springframework.ai.tool.definition.ToolDefinition;
-import org.springframework.ai.tool.metadata.ToolMetadata;
-import org.springframework.ai.document.Document;
-import org.springframework.ai.vectorstore.SearchRequest;
-import org.springframework.ai.vectorstore.SimpleVectorStore;
-import org.springframework.ai.vectorstore.VectorStore;
-import org.springframework.ai.vectorstore.filter.Filter;
-import org.springframework.mock.web.MockHttpServletRequest;
-import org.springframework.mock.web.MockHttpServletResponse;
-import reactor.core.publisher.Mono;
-
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.time.Duration;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.ConcurrentModificationException;
-import java.util.List;
-import java.util.NoSuchElementException;
-import java.util.Objects;
-import java.util.function.Supplier;
-
-import static org.apache.commons.lang3.StringUtils.isBlank;
-import static org.apache.commons.lang3.StringUtils.isNotBlank;
-import static org.springframework.ai.chat.messages.MessageType.ASSISTANT;
-
-
-public class McpServiceImpl implements McpService
-{
-    public static final String MESSAGE_ENDPOINT = "/_mcp/message";
-    public static final String SSE_ENDPOINT = "/_mcp/sse";
-    private static final Logger LOG = LogHelper.getLogger(McpServiceImpl.class, "MCP services");
-
-    private final CopyOnWriteHashMap<String, ToolCallback> toolMap = new CopyOnWriteHashMap<>();
-    private final CopyOnWriteHashMap<String, McpServerFeatures.SyncPromptSpecification> promptMap = new CopyOnWriteHashMap<>();
-    private final CopyOnWriteHashMap<String, McpServerFeatures.SyncResourceSpecification> resourceMap = new CopyOnWriteHashMap<>();
-
-    private final _McpServlet mcpServlet = new _McpServlet(JsonUtil.DEFAULT_MAPPER, MESSAGE_ENDPOINT, SSE_ENDPOINT);
-    private final ChatMemoryRepository chatMemoryRepository = new InMemoryChatMemoryRepository();
-    private VectorStore vectorStore = null;
-    private boolean serverReady = false;
-
-    private final _ModelProvider modelProvider;
-    private final _ModelProvider embeddingProvider;
-
-
-    public static McpServiceImpl get()
-    {
-        return (McpServiceImpl) McpService.get();
-    }
-
-    public McpServiceImpl()
-    {
-        _ModelProvider model = null;
-        _ModelProvider embedding = null;
-        if (isNotBlank(System.getenv("CLAUDE_API_KEY")))
-        {
-            model = new _ClaudeProvider();
-        }
-        if (isNotBlank(System.getenv("OPENAI_API_KEY")))
-        {
-            var openai = new _ChatGptProvider();
-            if (null == embedding)
-                embedding = openai;
-            if (null == model)
-                model = openai;
-        }
-        if (isNotBlank(System.getenv("GEMINI_API_KEY")))
-        {
-            var gemini = new _GeminiProvider();
-            if (null == embedding)
-                embedding = gemini;
-            if (null == model)
-                model = gemini;
-        }
-        modelProvider = model;
-        embeddingProvider = embedding;
-    }
-
-
-    /**
-     * Called by CoreModule.registerServlets()
-     * The servlet will return SC_SERVICE_UNAVAILABLE until startMcpServer() is called
-     */
-    public void registerServlets(ServletContext servletCtx)
-    {
-        var mcpServletDynamic = servletCtx.addServlet("mcpServlet", mcpServlet);
-        mcpServletDynamic.setAsyncSupported(true);
-        mcpServletDynamic.addMapping(MESSAGE_ENDPOINT + "/*");
-        mcpServletDynamic.addMapping(SSE_ENDPOINT + "/*");
-    }
-
-
-    public void startMpcServer()
-    {
-        if (null  == modelProvider)
-        {
-            return;
-        }
-        vectorStore = createVectorStore();
-        mcpServlet.startMcpServer();
-        serverReady = true;
-    }
-
-
-    @Override
-    public boolean isReady()
-    {
-        return serverReady;
-    }
-
-
-    @Override
-    public void registerTools(@NotNull List<ToolCallback> tools)
-    {
-        tools.forEach(tool -> toolMap.put(tool.getToolDefinition().name(), new _LoggingToolCallback(tool)));
-    }
-
-    @Override
-    public void registerPrompts(@NotNull List<McpServerFeatures.SyncPromptSpecification> prompts)
-    {
-        prompts.forEach(prompt -> promptMap.put(prompt.prompt().name(), prompt));
-    }
-
-    @Override
-    public void registerResources(@NotNull List<McpServerFeatures.SyncResourceSpecification> resources)
-    {
-        resources.forEach(resource -> resourceMap.put(resource.resource().name(), resource));
-    }
-
-
-    @Override
-    public ToolCallback @NonNull [] getToolCallbacks()
-    {
-        return toolMap.values().toArray(new ToolCallback[0]);
-    }
-
-
-    public List<McpSchema.Tool> tools()
-    {
-        McpJsonMapper mapper = McpJsonMapper.getDefault();
-        return toolMap.values().stream().map(ToolCallback::getToolDefinition).map(td ->
-                McpSchema.Tool.builder()
-                        .name(td.name())
-                        .description(td.description())
-                        .inputSchema(mapper, td.inputSchema())
-                        .build()
-        ).toList();
-    }
-
-    private class _McpServlet extends HttpServlet // wraps HttpServletSseServerTransportProvider
-    {
-        HttpServletStreamableServerTransportProvider transportProvider;
-        McpSyncServer mcpServer = null;
-
-        _McpServlet(ObjectMapper objectMapper, String messageEndpoint, String sseEndpoint)
-        {
-            transportProvider = HttpServletStreamableServerTransportProvider.builder()
-                    .jsonMapper(McpJsonMapper.getDefault())
-                    .mcpEndpoint(messageEndpoint)
-                    .build();
-        }
-
-        void startMcpServer()
-        {
-            List<McpServerFeatures.SyncToolSpecification> tools = Arrays.stream(getToolCallbacks()).map(McpToolUtils::toSyncToolSpecification).toList();
-            List<McpServerFeatures.SyncResourceSpecification> resources = new ArrayList<>(resourceMap.values());
-
-            mcpServer = McpServer.sync(transportProvider)
-                    .tools(tools)
-                    .resources(resources)
-//                    .capabilities(new McpSchema.ServerCapabilities())
-                    .build();
-            ContextListener.addShutdownListener(new _ShutdownListener());
-        }
-
-        @Override
-        public void service(ServletRequest sreq, ServletResponse sres) throws ServletException, IOException
-        {
-            if (!(sreq instanceof HttpServletRequest req) || !(sres instanceof HttpServletResponse res))
-            {
-                // how to set error???
-                throw new ServletException("non-HTTP request");
-            }
-
-            if (null == mcpServer)
-            {
-                res.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE);
-                return;
-            }
-
-            if ("POST".equals(req.getMethod()))
-            {
-                if (null == req.getParameter("sessionId") && null == req.getSession(true).getAttribute("McpServiceImpl#mcpSessionId"))
-                {
-                    // USE SSE endpoint to get a sessionId
-                    MockHttpServletRequest mockRequest = new MockHttpServletRequest(req.getServletContext(), "GET", SSE_ENDPOINT);
-                    mockRequest.setAsyncSupported(true);
-                    MockHttpServletResponse mockResponse = new MockHttpServletResponse();
-                    transportProvider.service(mockRequest, mockResponse);
-                    String body = new String(mockResponse.getContentAsByteArray(), StandardCharsets.UTF_8);
-                    String mcpSessionId = StringUtils.substringBetween(body, "sessionId=", "\n");
-                    req.getSession(true).setAttribute("McpServiceImpl#mcpSessionId", mcpSessionId);
-                    mockRequest.close();
-                    mockResponse.getOutputStream().close();
-                }
-
-                req = new HttpServletRequestWrapper(req)
-                {
-                    @Override
-                    public String getParameter(String name)
-                    {
-                        var ret = super.getParameter(name);
-                        if (null == ret && "sessionId".equals(name))
-                            return String.valueOf(Objects.requireNonNull(((HttpServletRequest) getRequest()).getSession(true).getAttribute("McpServiceImpl#mcpSessionId")));
-                        return ret;
-                    }
-                };
-            }
-            transportProvider.service(req, res);
-        }
-
-        public Mono<Void> closeGracefully()
-        {
-            if (null != transportProvider)
-                return transportProvider.closeGracefully();
-            return Mono.empty();
-        }
-    }
-
-
-    // ShutdownListener
-
-    class _ShutdownListener implements ShutdownListener
-    {
-        @Override
-        public String getName()
-        {
-            return "MpcService";
-        }
-
-
-        Mono<Void> closing = null;
-
-        @Override
-        public void shutdownPre()
-        {
-            closing = mcpServlet.closeGracefully();
-            saveVectorDatabase();
-        }
-
-        @Override
-        public void shutdownStarted()
-        {
-            if (null == closing)
-                closing = mcpServlet.closeGracefully();
-            closing.block(Duration.ofSeconds(5));
-        }
-    }
-
-
-    /** Delegating wrapper that logs vector store similarity searches */
-    private static class _LoggingVectorStore implements VectorStore
-    {
-        private final VectorStore delegate;
-
-        _LoggingVectorStore(VectorStore delegate)
-        {
-            this.delegate = delegate;
-        }
-
-        @Override
-        public void add(List<Document> documents)
-        {
-            delegate.add(documents);
-        }
-
-        @Override
-        public void delete(Filter.Expression filterExpression)
-        {
-            delegate.delete(filterExpression);
-        }
-
-        @Override
-        public void delete(List<String> idList)
-        {
-            delegate.delete(idList);
-        }
-
-        @Override
-        public List<Document> similaritySearch(SearchRequest request)
-        {
-            LOG.info("Vector store search: query=\"{}\"", request.getQuery());
-            List<Document> results = delegate.similaritySearch(request);
-            if (results.isEmpty())
-            {
-                LOG.info("Vector store search returned no results");
-            }
-            else
-            {
-                LOG.info("Vector store search returned {} result(s):", results.size());
-                for (Document doc : results)
-                {
-                    String content = doc.getText();
-                    String snippet = content.length() > 200 ? content.substring(0, 200) + "..." : content;
-                    LOG.info("  - [{}] {}", doc.getMetadata(), snippet);
-                }
-            }
-            return results;
-        }
-
-        @Override
-        public String getName()
-        {
-            return delegate.getName();
-        }
-    }
-
-
-    @Override
-    public ChatClient getChat(HttpSession session, String agentName, Supplier<String> systemPromptSupplier, boolean createIfNotExists)
-    {
-        if (!serverReady)
-            return null;
-
-        String sessionKey = ChatClient.class.getName() + "#" + agentName;
-        if (createIfNotExists)
-        {
-            return SessionHelper.getAttribute(session, sessionKey, () ->
-                    {
-                        var springClient = createSpringChat(session, agentName, systemPromptSupplier);
-                        return new _ChatClient(springClient, sessionKey);
-                    });
-        }
-        return SessionHelper.getAttribute(session, sessionKey, null);
-    }
-
-    private ChatClient createSpringChat(HttpSession session, String agentName, Supplier<String> systemPromptSupplier)
-    {
-        String systemPrompt = systemPromptSupplier.get();
-        String conversationId = session.getId() + ":" + agentName;
-        List<Advisor> advisors = new ArrayList<>();
-
-        ChatMemory chatMemory = MessageWindowChatMemory.builder()
-                .maxMessages(100)
-                .chatMemoryRepository(chatMemoryRepository)
-                .build();
-
-        MessageChatMemoryAdvisor chatMemoryAdvisor = MessageChatMemoryAdvisor.builder(chatMemory)
-                .conversationId(conversationId)
-                .build();
-        advisors.add(chatMemoryAdvisor);
-
-        VectorStore vs = getVectorStore();
-        if (null != vs)
-            advisors.add(QuestionAnswerAdvisor.builder(new _LoggingVectorStore(vs)).build());
-
-        return ChatClient.builder(modelProvider.getChatModel())
-                .defaultOptions(modelProvider.getChatOptions())
-                .defaultAdvisors(advisors)
-                .defaultSystem(systemPrompt)
-                .build();
-    }
-
-    private class _ChatClient implements ChatClient
-    {
-        final ChatClient springClient;
-        final String key;
-        _ChatClient(ChatClient client, String key)
-        {
-            this.springClient = client;
-            this.key = key;
-        }
-
-        @Override
-        public ChatClientRequestSpec prompt()
-        {
-            return springClient.prompt();
-        }
-
-        @Override
-        public ChatClientRequestSpec prompt(String content)
-        {
-            return springClient.prompt(content);
-        }
-
-        @Override
-        public ChatClientRequestSpec prompt(Prompt prompt)
-        {
-            return springClient.prompt(prompt);
-        }
-
-        @Override
-        public Builder mutate()
-        {
-            throw new UnsupportedOperationException();
-        }
-    }
-
-    @Override
-    public void close(HttpSession session, ChatClient chat)
-    {
-        if (null == chat)
-            return;
-        session.removeAttribute(((_ChatClient)chat).key);
-    }
-
-    @Override
-    public MessageResponse sendMessage(ChatClient chatSession, String message)
-    {
-        try
-        {
-            var callResponse = chatSession
-                    .prompt(message)
-                    .toolContext(McpContext.get().getToolContext().getContext())
-                    .call();
-            StringBuilder sb = new StringBuilder();
-            for (Generation result : callResponse.chatResponse().getResults())
-            {
-                var output = result.getOutput();
-                if (ASSISTANT == output.getMessageType())
-                {
-                    sb.append(output.getText());
-                    sb.append("\n\n");
-                }
-            }
-            String md = sb.toString().strip();
-            HtmlString html = HtmlString.unsafe(MarkdownService.get().toHtml(md));
-            return new MessageResponse("text/markdown", md, html);
-        }
-        catch (java.util.NoSuchElementException x)
-        {
-            // Spring AI GoogleGenAiChatModel bug: empty candidates cause NoSuchElementException
-            // https://github.com/spring-projects/spring-ai/issues/4556
-            LOG.warn("Empty response from chat model (likely a filtered or empty candidate)", x);
-            return new MessageResponse("text/plain", "The model returned an empty response. Please try resubmitting and, if the problem continues, rephrase your question/prompt.", HtmlString.of("The model returned an empty response. Please try rephrasing your question."));
-        }
-    }
-
-    @Override
-    public List<MessageResponse> sendMessageEx(ChatClient chatSession, String message)
-    {
-        if (isBlank(message))
-            return List.of();
-        try
-        {
-            var callResponse = chatSession
-                    .prompt(message)
-                    .toolContext(McpContext.get().getToolContext().getContext())
-                    .call();
-            List<MessageResponse> ret = new ArrayList<>();
-            for (Generation result : callResponse.chatResponse().getResults())
-            {
-                var output = result.getOutput();
-                if (ASSISTANT == output.getMessageType())
-                {
-                    String md = output.getText();
-                    HtmlString html = HtmlString.unsafe(MarkdownService.get().toHtml(md));
-                    ret.add(new MessageResponse("text/markdown", md, html));
-                }
-            }
-            return ret;
-        }
-        catch (NoSuchElementException x)
-        {
-            // Spring AI GoogleGenAiChatModel bug: empty candidates cause NoSuchElementException
-            // https://github.com/spring-projects/spring-ai/issues/4556
-            LOG.warn("Empty response from chat model (likely a filtered or empty candidate)", x);
-            return List.of(new MessageResponse("text/plain", "The model returned an empty response. Please try rephrasing your question.", HtmlString.of("The model returned an empty response. Please try rephrasing your question.")));
-        }
-        catch (ConcurrentModificationException x)
-        {
-            // This can happen when the vector store is still loading, typically a problem shortly after startup
-            // Should do better synchronization or state checking
-            LOG.warn("Vector store not ready", x);
-            return List.of(new MessageResponse("text/plain", "Vector store likely not ready yet. Try again.", HtmlString.of("Vector store likely not ready yet. Try again.")));
-        }
-    }
-
-
-    @Override
-    public VectorStore getVectorStore()
-    {
-        return !serverReady ? null : vectorStore;
-    }
-
-
-    VectorStore createVectorStore()
-    {
-        SimpleVectorStore ret = null;
-
-        try
-        {
-            EmbeddingModel embeddingModel = embeddingProvider.createEmbeddingModel();
-            if (null == embeddingModel)
-                return null;
-
-            ret = SimpleVectorStore.builder(embeddingModel).build();
-
-            var savedFile = FileUtil.getTempDirectoryFileLike().resolveChild("VectorStore.database");
-            if (savedFile.exists())
-            {
-                try
-                {
-                    ret.load(savedFile.toNioPathForRead().toFile());
-                }
-                catch (Exception x)
-                {
-                    LogHelper.getLogger(McpServiceImpl.class,"mcp service")
-                            .error("error restoring saved vectordb: " + savedFile.toNioPathForRead(), x);
-                }
-            }
-        }
-        catch (Exception x)
-        {
-            LOG.error("Can't create vector store", x);
-        }
-
-        return ret;
-    }
-
-    void saveVectorDatabase()
-    {
-        SimpleVectorStore vectorStore = (SimpleVectorStore)getVectorStore();
-        if (null == vectorStore)
-            return;
-
-        var db = FileUtil.getTempDirectoryFileLike().resolveChild("VectorStore.database");
-        try
-        {
-            vectorStore.save(db.toNioPathForRead().toFile());
-        }
-        catch (Exception x)
-        {
-            LOG.error("Can't save vector store", x);
-        }
-    }
-
-
-    interface _ModelProvider
-    {
-        String getModel();
-
-        String getEmbeddingModel();
-
-        ChatOptions getChatOptions();
-
-        ChatModel getChatModel();
-
-        EmbeddingModel createEmbeddingModel();
-    }
-
-
-    class _GeminiProvider implements _ModelProvider
-    {
-        final Object _initClientLock = new Object();
-        Client _genAiClient = null;
-
-        @Override
-        public String getModel()
-        {
-            return "gemini-3-pro-preview";
-        }
-
-        @Override
-        public String getEmbeddingModel()
-        {
-            return "gemini-embedding-001";
-        }
-
-        Client getLlmClient()
-        {
-            synchronized (_initClientLock)
-            {
-                if (null == _genAiClient)
-                {
-                    ClientOptions clientOptions = ClientOptions.builder()
-                            .build();
-                    _genAiClient = Client.builder()
-                            .clientOptions(clientOptions)
-                            .build();
-                }
-
-                return _genAiClient;
-            }
-        }
-
-/*
-        Generation Options
-
-            ┌──────────────────┬──────────────┬─────────────────────────────────────────────────┐
-            │      Option      │     Type     │                   Description                   │
-            ├──────────────────┼──────────────┼─────────────────────────────────────────────────┤
-            │ model            │ String       │ Model name (e.g., gemini-2.5-pro-preview)       │
-            ├──────────────────┼──────────────┼─────────────────────────────────────────────────┤
-            │ temperature      │ Double       │ Randomness of predictions (0.0–2.0)             │
-            ├──────────────────┼──────────────┼─────────────────────────────────────────────────┤
-            │ topP             │ Double       │ Nucleus sampling threshold                      │
-            ├──────────────────┼──────────────┼─────────────────────────────────────────────────┤
-            │ topK             │ Integer      │ Top-k sampling parameter                        │
-            ├──────────────────┼──────────────┼─────────────────────────────────────────────────┤
-            │ candidateCount   │ Integer      │ Number of candidate responses to generate       │
-            ├──────────────────┼──────────────┼─────────────────────────────────────────────────┤
-            │ maxOutputTokens  │ Integer      │ Maximum tokens in the response                  │
-            ├──────────────────┼──────────────┼─────────────────────────────────────────────────┤
-            │ frequencyPenalty │ Double       │ Penalizes frequently used tokens                │
-            ├──────────────────┼──────────────┼─────────────────────────────────────────────────┤
-            │ presencePenalty  │ Double       │ Penalizes tokens already present in the output  │
-            ├──────────────────┼──────────────┼─────────────────────────────────────────────────┤
-            │ stopSequences    │ List<String> │ Sequences that stop generation when encountered │
-            └──────────────────┴──────────────┴─────────────────────────────────────────────────┘
-
-        Response Format
-
-            ┌──────────────────┬────────┬───────────────────────────────────┐
-            │      Option      │  Type  │            Description            │
-            ├──────────────────┼────────┼───────────────────────────────────┤
-            │ responseMimeType │ String │ text/plain or application/json    │
-            ├──────────────────┼────────┼───────────────────────────────────┤
-            │ responseSchema   │ String │ JSON schema for structured output │
-            └──────────────────┴────────┴───────────────────────────────────┘
-
-        Thinking (Extended Reasoning)
-
-            ┌──────────────────────────────┬──────────────────────────┬────────────────────────────────────────────────────┐
-            │            Option            │           Type           │                    Description                     │
-            ├──────────────────────────────┼──────────────────────────┼────────────────────────────────────────────────────┤
-            │ thinkingBudget               │ Integer                  │ Token budget for the thinking process              │
-            ├──────────────────────────────┼──────────────────────────┼────────────────────────────────────────────────────┤
-            │ includeThoughts              │ Boolean                  │ Whether to include reasoning steps in the response │
-            ├──────────────────────────────┼──────────────────────────┼────────────────────────────────────────────────────┤
-            │ thinkingLevel                │ GoogleGenAiThinkingLevel │ Enum: THINKING_LEVEL_UNSPECIFIED, LOW, HIGH        │
-            ├──────────────────────────────┼──────────────────────────┼────────────────────────────────────────────────────┤
-            │ includeExtendedUsageMetadata │ Boolean                  │ Include token-level usage details in the response  │
-            └──────────────────────────────┴──────────────────────────┴────────────────────────────────────────────────────┘
-
-        Caching
-
-            ┌────────────────────┬──────────┬───────────────────────────────────────────────┐
-            │       Option       │   Type   │                  Description                  │
-            ├────────────────────┼──────────┼───────────────────────────────────────────────┤
-            │ cachedContentName  │ String   │ Name of cached content to reuse               │
-            ├────────────────────┼──────────┼───────────────────────────────────────────────┤
-            │ useCachedContent   │ Boolean  │ Whether to use cached content if available    │
-            ├────────────────────┼──────────┼───────────────────────────────────────────────┤
-            │ autoCacheThreshold │ Integer  │ Auto-cache prompts exceeding this token count │
-            ├────────────────────┼──────────┼───────────────────────────────────────────────┤
-            │ autoCacheTtl       │ Duration │ TTL for auto-cached content                   │
-            └────────────────────┴──────────┴───────────────────────────────────────────────┘
-
-        Tools / Function Calling
-
-            ┌──────────────────────────────┬─────────────────────┬───────────────────────────────────────────────────┐
-            │            Option            │        Type         │                    Description                    │
-            ├──────────────────────────────┼─────────────────────┼───────────────────────────────────────────────────┤
-            │ toolCallbacks                │ List<ToolCallback>  │ Tool implementations for function calling         │
-            ├──────────────────────────────┼─────────────────────┼───────────────────────────────────────────────────┤
-            │ toolNames                    │ Set<String>         │ Tool names resolved at runtime                    │
-            ├──────────────────────────────┼─────────────────────┼───────────────────────────────────────────────────┤
-            │ internalToolExecutionEnabled │ Boolean             │ Whether Spring AI handles the tool execution loop │
-            ├──────────────────────────────┼─────────────────────┼───────────────────────────────────────────────────┤
-            │ toolContext                  │ Map<String, Object> │ Contextual data passed to tools                   │
-            └──────────────────────────────┴─────────────────────┴───────────────────────────────────────────────────┘
-
-        Safety & Search
-
-            ┌───────────────────────┬────────────────────────────────┬────────────────────────────────────┐
-            │        Option         │              Type              │            Description             │
-            ├───────────────────────┼────────────────────────────────┼────────────────────────────────────┤
-            │ safetySettings        │ List<GoogleGenAiSafetySetting> │ Safety filters and harm thresholds │
-            ├───────────────────────┼────────────────────────────────┼────────────────────────────────────┤
-            │ googleSearchRetrieval │ Boolean                        │ Enable Google Search grounding     │
-            ├───────────────────────┼────────────────────────────────┼────────────────────────────────────┤
-            │ labels                │ Map<String, String>            │ Custom labels attached to requests │
-            └───────────────────────┴────────────────────────────────┴────────────────────────────────────┘
-*/
-        public GoogleGenAiChatOptions getChatOptions()
-        {
-            GoogleGenAiChatOptions chatOptions = GoogleGenAiChatOptions.builder()
-                    .model(getModel())
-                    .toolCallbacks(getToolCallbacks())
-                    .build();
-            return chatOptions;
-        }
-
-        public ChatModel getChatModel()
-        {
-            Client genAiClient = getLlmClient();
-            GoogleGenAiChatOptions chatOptions = getChatOptions();
-
-            ChatModel chatModel = GoogleGenAiChatModel.builder()
-                    .genAiClient(genAiClient)
-                    .defaultOptions(chatOptions)
-                    .build();
-            return chatModel;
-        }
-
-        @Override
-        public EmbeddingModel createEmbeddingModel()
-        {
-            ClientOptions clientOptions = ClientOptions.builder()
-                    .build();
-            Client client = Client.builder() // not shared with getLlmClient() ??? maybe causing problems?
-                    .clientOptions(clientOptions)
-                    .build();
-            GoogleGenAiEmbeddingConnectionDetails connectionDetails = GoogleGenAiEmbeddingConnectionDetails.builder()
-                    .genAiClient(client)
-                    .build();
-            GoogleGenAiTextEmbeddingOptions embeddingOptions = GoogleGenAiTextEmbeddingOptions.builder()
-                    .model(getEmbeddingModel())
-                    .build();
-            EmbeddingModel embeddingModel;
-            embeddingModel = new GoogleGenAiTextEmbeddingModel(connectionDetails, embeddingOptions);
-            return embeddingModel;
-        }
-    }
-
-
-    private static class _LoggingToolCallback implements ToolCallback
-    {
-        private final ToolCallback delegate;
-
-        _LoggingToolCallback(ToolCallback delegate)
-        {
-            this.delegate = delegate;
-        }
-
-        @Override
-        public ToolDefinition getToolDefinition()
-        {
-            return delegate.getToolDefinition();
-        }
-
-        @Override
-        public ToolMetadata getToolMetadata()
-        {
-            return delegate.getToolMetadata();
-        }
-
-        @Override
-        public String call(String toolInput)
-        {
-            LOG.info("MCP tool invoked: {}", delegate.getToolDefinition().name());
-            return delegate.call(toolInput);
-        }
-
-        @Override
-        public String call(String toolInput, ToolContext toolContext)
-        {
-            LOG.info("MCP tool invoked: {}", delegate.getToolDefinition().name());
-            return delegate.call(toolInput, toolContext);
-        }
-    }
-
-
-    class _ClaudeProvider implements _ModelProvider
-    {
-        @Override
-        public String getModel()
-        {
-            return "claude-sonnet-4-5-20250929";
-        }
-
-        @Override
-        public String getEmbeddingModel()
-        {
-            // NYI in spring-ai -- need to use a different service (or Claude java library)
-            // return "voyage-3.5-lite";
-            return null;
-        }
-
-        public AnthropicChatOptions getChatOptions()
-        {
-            AnthropicChatOptions chatOptions = AnthropicChatOptions.builder()
-                    .model(getModel())
-                    .toolCallbacks(getToolCallbacks())
-                    .build();
-            return chatOptions;
-        }
-
-        public AnthropicChatModel getChatModel()
-        {
-            AnthropicChatOptions chatOptions = getChatOptions();
-            AnthropicApi api = AnthropicApi.builder()
-                    .apiKey(System.getenv("CLAUDE_API_KEY"))
-                    .build();
-            AnthropicChatModel chatModel = AnthropicChatModel.builder()
-                    .anthropicApi(api)
-                    .build();
-            return chatModel;
-        }
-
-        @Override
-        public EmbeddingModel createEmbeddingModel()
-        {
-            return null;
-        }
-    }
-
-    class _ChatGptProvider implements _ModelProvider
-    {
-        @Override
-        public String getModel()
-        {
-            return "gpt-4o";
-        }
-
-        @Override
-        public String getEmbeddingModel()
-        {
-            return "text-embedding-3-small";
-        }
-
-        @Override
-        public OpenAiChatOptions getChatOptions()
-        {
-            return OpenAiChatOptions.builder()
-                    .model(getModel())
-                    .toolCallbacks(getToolCallbacks())
-                    .build();
-        }
-
-        @Override
-        public OpenAiChatModel getChatModel()
-        {
-            OpenAiApi openAiApi = OpenAiApi.builder()
-                    .apiKey(System.getenv("OPENAI_API_KEY"))
-                    .build();
-
-            return OpenAiChatModel.builder()
-                    .openAiApi(openAiApi)
-                    .defaultOptions(getChatOptions())
-                    .build();
-        }
-
-        @Override
-        public EmbeddingModel createEmbeddingModel()
-        {
-            OpenAiApi openAiApi = OpenAiApi.builder()
-                    .apiKey(System.getenv("OPENAI_API_KEY"))
-                    .build();
-
-            OpenAiEmbeddingOptions embeddingOptions = OpenAiEmbeddingOptions.builder()
-                    .model(getEmbeddingModel())
-                    .build();
-
-            return new OpenAiEmbeddingModel(openAiApi, MetadataMode.EMBED, embeddingOptions);
-        }
-    }
-}
diff --git a/query/src/org/labkey/query/controllers/QueryMcp.java b/query/src/org/labkey/query/controllers/QueryMcp.java
index 99bb2df99c0..b68f2c4ea67 100644
--- a/query/src/org/labkey/query/controllers/QueryMcp.java
+++ b/query/src/org/labkey/query/controllers/QueryMcp.java
@@ -1,18 +1,16 @@
 package org.labkey.query.controllers;
 
-import io.modelcontextprotocol.spec.McpSchema;
+import io.modelcontextprotocol.spec.McpSchema.ReadResourceResult;
+import io.modelcontextprotocol.spec.McpSchema.TextResourceContents;
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.json.JSONArray;
 import org.json.JSONObject;
-import org.labkey.api.action.SpringActionController;
 import org.labkey.api.collections.CaseInsensitiveHashSet;
 import org.labkey.api.data.ColumnInfo;
-import org.labkey.api.data.ContainerManager;
 import org.labkey.api.data.PropertyManager;
 import org.labkey.api.data.TableDescription;
 import org.labkey.api.data.TableInfo;
-import org.labkey.api.mcp.McpContext;
 import org.labkey.api.mcp.McpService;
 import org.labkey.api.query.DefaultSchema;
 import org.labkey.api.query.QueryDefinition;
@@ -22,9 +20,13 @@
 import org.labkey.api.query.SchemaKey;
 import org.labkey.api.query.SimpleSchemaTreeVisitor;
 import org.labkey.api.query.UserSchema;
-import org.labkey.api.security.UserManager;
+import org.labkey.api.security.RequiresPermission;
+import org.labkey.api.security.permissions.ReadPermission;
+import org.labkey.api.view.NotFoundException;
+import org.labkey.api.writer.ContainerUser;
 import org.labkey.query.sql.SqlParser;
-import org.springaicommunity.mcp.annotation.McpResource;
+import org.springframework.ai.chat.model.ToolContext;
+import org.springframework.ai.mcp.annotation.McpResource;
 import org.springframework.ai.tool.annotation.Tool;
 import org.springframework.ai.tool.annotation.ToolParam;
 
@@ -36,111 +38,80 @@
 
 import static org.apache.commons.lang3.StringUtils.isNotBlank;
 
-/* TODO: integrate ToolContext support */
-
 public class QueryMcp implements McpService.McpImpl
 {
     @McpResource(
-            uri = "resource://org/labkey/query/controllers/LabKeySql.md",
-            mimeType = "application/markdown",
-            name = "LabKey SQL",
-            description = "Provide documentation for LabKey SQL specific syntax")
-    public McpSchema.ReadResourceResult getLabKeySQLDocumentation() throws IOException
+        uri = "resource://org/labkey/query/controllers/LabKeySql.md",
+        mimeType = "application/markdown",
+        name = "LabKey SQL",
+        description = "Provide documentation for LabKey SQL specific syntax")
+    public ReadResourceResult getLabKeySQLDocumentation() throws IOException
     {
+        incrementResourceRequestCount("LabKey SQL");
         String markdown = IOUtils.resourceToString("org/labkey/query/controllers/LabKeySql.md", null, QueryController.class.getClassLoader());
-        return new McpSchema.ReadResourceResult(List.of(
-                new McpSchema.TextResourceContents(
-                        "resource://org/labkey/query/controllers/LabKeySql.md",
-                        "application/markdown",
-                        markdown)
+        return new ReadResourceResult(List.of(
+            new TextResourceContents(
+                "resource://org/labkey/query/controllers/LabKeySql.md",
+                "application/markdown",
+                markdown
+            )
         ));
     }
 
-
-    @Tool(description = "Provide column metadata for a sql table.  This tool will also return SQL source for saved queries.")
-    String listColumnMetaData(@ToolParam(description = "Fully qualified table name as it would appear in SQL e.g. \"schema\".\"table\"") String fullQuotedTableName)
-    {
-        var json = _listColumnsForTable(fullQuotedTableName);
-        // can I just return a JSONObject
-        return json.toString();
-    }
-
-    @Tool(description = "Provide list of tables within the provided schema.")
-    String listTablesForSchema(@ToolParam(description = "Fully qualified schema name as it would appear in SQL e.g. \"schema\"") String quotedSchemaName)
-    {
-        var json = _listTablesForSchema(quotedSchemaName);
-        // can I just return a JSONObject
-        return json.toString();
-    }
-
     @Tool(description = "Provide list of database schemas")
-    String listSchemas()
+    @RequiresPermission(ReadPermission.class)
+    String listSchemas(ToolContext toolContext)
     {
-        McpContext context = getContext();
-        var map = _listAllSchemas(DefaultSchema.get(context.getUser(), context.getContainer()));
+        ContainerUser cu = getContext(toolContext);
+        var map = _listAllSchemas(DefaultSchema.get(cu.getUser(), cu.getContainer()));
         var array = new JSONArray();
         for (var entry : map.entrySet())
         {
-                array.put(new JSONObject(Map.of(
-                        "name", entry.getKey().getName(),
-                        "quotedName", entry.getKey().toSQLString(),
-                        "description", StringUtils.trimToEmpty(entry.getValue().getDescription())
-                )));
+            array.put(new JSONObject(Map.of(
+                "name", entry.getKey().getName(),
+                "quotedName", entry.getKey().toSQLString(),
+                "description", StringUtils.trimToEmpty(entry.getValue().getDescription())
+            )));
         }
-        return new JSONObject(Map.of("success", "true", "schemas", array)).toString();
+        return new JSONArray(array).toString();
     }
 
-
-    @Tool(description = "Provide the SQL source for a saved query.")
-    String getSourceForSavedQuery(@ToolParam(description = "Fully qualified query name as it would appear in SQL e.g. \"schema\".\"table or query\"") String fullQuotedTableName)
+    @Tool(description = "Provide list of tables within the provided schema.")
+    @RequiresPermission(ReadPermission.class)
+    String listTables(ToolContext toolContext, @ToolParam(description = "Fully qualified schema name as it would appear in SQL e.g. Study or \"Study.Datasets\"") String schemaName)
     {
-        var json = _listTablesForSchema(fullQuotedTableName);
-        if (json.has("sql"))
-            return "```sql\n" + json.getString("sql") + "\n```\n";
-        else
-            return "I could not find the source for " + fullQuotedTableName;
+        var json = _listTables(getContext(toolContext), schemaName);
+        return json.toString();
     }
 
-
-    @Tool(description = """
-            Save addition information for database columns.  If additional metadata is gathered via
-            chat, it can be saved to improve further interactions.
-            """)
-    String saveColumnDescription(
-            @ToolParam(description = "Fully qualified table or query name as it would appear in SQL e.g. \"schema\".\"table or query\"")
-                String fullQuotedTableName,
-            @ToolParam(description = "Quoted column name as it would appear in SQL e.g. \"column name\"")
-                String quotedColumnName,
-            @ToolParam(description = "Additional metadata to remember for future use.  This will replace any currently saved value")
-                String columnMetadata
+    @Tool(description = "Provide column metadata for a sql table. The metadata includes SQL source for saved queries.")
+    @RequiresPermission(ReadPermission.class)
+    String listColumns(
+        ToolContext toolContext,
+        @ToolParam(description = "Fully qualified schema name as it would appear in SQL e.g. Study or \"Study.Datasets\"") String schemaName,
+        @ToolParam(description = "Table or query name as it would appear in SQL e.g. MyTable, MyQuery, or \"MyTable\"") String queryName
     )
     {
-        McpContext context = McpContext.get();
-        var map = PropertyManager.getWritableProperties(context.getContainer(), "QueryMCP.annotations", true);
-        String fullPath = normalizeIdentifier(fullQuotedTableName + "." + quotedColumnName);
-        map.put(fullPath, columnMetadata);
-        try (var ignore = SpringActionController.ignoreSqlUpdates())
-        {
-            map.save();
-        }
-        return new JSONObject(Map.of("success",Boolean.TRUE)).toString();
+        var json = _listColumns(toolContext, schemaName, queryName);
+        return json.toString();
     }
 
-    /* TODO  McpContext setup */
-
-    static McpContext getContext()
+    @Tool(description = "Provide the SQL source for a saved query.")
+    @RequiresPermission(ReadPermission.class)
+    String getSourceForSavedQuery(
+        ToolContext toolContext,
+        @ToolParam(description = "Fully qualified schema name as it would appear in SQL e.g. Study or \"Study.Datasets\"") String schemaName,
+        @ToolParam(description = "Table or query name as it would appear in SQL e.g. MyTable, MyQuery, or \"MyTable\"") String queryName
+    )
     {
-        try
-        {
-            return McpContext.get();
-        }
-        catch (Exception x)
-        {
-            return new McpContext(ContainerManager.getHomeContainer(), UserManager.getGuestUser());
-        }
+        var json = _listColumns(toolContext, schemaName, queryName);
+        if (json.has("sql"))
+            return "```sql\n" + json.getString("sql") + "\n```\n";
+        else
+            throw new NotFoundException("Could not find the source for " + schemaName + "." + queryName);
     }
 
-    /* For now, list all schemas.  CONSIDER support incremental querying. */
+    /* For now, list all schemas. CONSIDER support incremental querying. */
     public static Map<SchemaKey, UserSchema> _listAllSchemas(DefaultSchema root)
     {
         SimpleSchemaTreeVisitor<Map<SchemaKey,UserSchema>, Void> visitor = new SimpleSchemaTreeVisitor<>(false)
@@ -178,28 +149,13 @@ public Map<SchemaKey, UserSchema> reduce(Map<SchemaKey, UserSchema> r1, Map<Sche
         return ret;
     }
 
-
-    public static JSONObject _listTablesForSchema(String fullQuotedName)
+    public static JSONObject _listTables(ContainerUser cu, String schemaName)
     {
-        SchemaKey fullKey;
-
-        // TODO : correct method for parsing quoted identifier
-        if (fullQuotedName.startsWith("\"") && fullQuotedName.endsWith("\""))
-        {
-            String[] parts = StringUtils.strip(fullQuotedName, "\"").split("\"\\.\"");
-            fullKey = SchemaKey.fromParts(parts);
-        }
-        else
-        {
-            String[] parts = StringUtils.split(fullQuotedName, ".");
-            fullKey = SchemaKey.fromParts(parts);
-        }
+        var defaultSchema = DefaultSchema.get(cu.getUser(), cu.getContainer());
+        var schema = DefaultSchema.resolve(defaultSchema, getSchemaKey(schemaName));
 
-        McpContext context = getContext();
-        var defaultSchema = DefaultSchema.get(context.getUser(), context.getContainer());
-        var schema = DefaultSchema.resolve(defaultSchema, fullKey);
         if (!(schema instanceof UserSchema userSchema))
-            return new JSONObject("error", "could not find schema for : " + fullQuotedName);
+            throw new NotFoundException("Could not find schema " + schemaName);
 
         JSONArray array = new JSONArray();
         CaseInsensitiveHashSet names = new CaseInsensitiveHashSet(schema.getTableNames());
@@ -220,7 +176,7 @@ public static JSONObject _listTablesForSchema(String fullQuotedName)
             {
                 continue;
             }
-            QueryDefinition qd = ((UserSchema)schema).getQueryDef(tableName);
+            QueryDefinition qd = userSchema.getQueryDef(tableName);
             JSONObject table = new JSONObject();
             table.put("schemaName", schema.getName());
             table.put("tableName", td.getName());
@@ -239,41 +195,24 @@ public static JSONObject _listTablesForSchema(String fullQuotedName)
         return ret;
     }
 
-    public static JSONObject _listColumnsForTable(String fullQuotedName)
+    public JSONObject _listColumns(ToolContext toolContext, String schemaName, String tableName)
     {
-        McpContext context = McpContext.get();
-        QueryKey fullKey = dottedIdentifier(fullQuotedName);
-        SchemaKey schemaKey;
-
-        var props = PropertyManager.getProperties(context.getContainer(), "QueryMCP.annotations");
-
-        String tableName;
-        if (fullKey.size() > 1)
-        {
-            schemaKey = SchemaKey.fromParts(fullKey.getParent().getParts());
-            tableName = fullKey.getName();
-        }
-        else if (fullKey.size() == 1)
-        {
-            schemaKey = SchemaKey.fromParts("study");
-            tableName = fullKey.getName();
-        }
-        else
-        {
-            return new JSONObject("error", "could not find table");
-        }
-
-        SchemaKey tableKey = new SchemaKey(schemaKey, tableName);
+        var context = getContext(toolContext);
 
+        SchemaKey schemaKey = getSchemaKey(schemaName);
         var defaultSchema = DefaultSchema.get(context.getUser(), context.getContainer());
-
         var schema = DefaultSchema.resolve(defaultSchema, schemaKey);
         if (null == schema)
-            return new JSONObject("error", "could not find table");
+            throw new NotFoundException("Could not find schema " + schemaName);
+
+        var props = PropertyManager.getProperties(context.getContainer(), "QueryMCP.annotations");
+
+        QueryKey<?> queryKey = dottedIdentifier(tableName);
+        SchemaKey tableKey = new SchemaKey(schemaKey, queryKey.getName());
 
-        TableInfo td = schema.getTable(tableName, null);
+        TableInfo td = schema.getTable(queryKey.getName(), null);
         if (null == td)
-            return new JSONObject("error", "could not find table");
+            throw new NotFoundException("Could not find table " + schemaName + "." + tableName);
 
         String sourceSQL = null;
         if (schema instanceof UserSchema userSchema)
@@ -290,10 +229,10 @@ else if (fullKey.size() == 1)
         if (isNotBlank(td.getDescription()))
             table.put("description", td.getDescription());
         if (isNotBlank(sourceSQL))
-            table.put("sql", sourceSQL);
+            table.put("sql", sourceSQL.trim());
 
         var pkColumns = td.getPkColumns();
-        var pk = pkColumns.size() == 1 ? pkColumns.get(0).getFieldKey() : null;
+        var pk = pkColumns.size() == 1 ? pkColumns.getFirst().getFieldKey() : null;
         JSONArray columns = new JSONArray();
         for (ColumnInfo col : td.getColumns())
         {
@@ -336,11 +275,27 @@ else if (fullKey.size() == 1)
             }
             columns.put(md);
         }
-        table.put("columns",columns);
+        table.put("columns", columns);
 
         return table;
     }
 
+    private static SchemaKey getSchemaKey(String schemaName)
+    {
+        final String[] parts;
+
+        // TODO : correct method for parsing quoted identifier
+        if (schemaName.startsWith("\"") && schemaName.endsWith("\""))
+        {
+            parts = StringUtils.strip(schemaName, "\"").split("\"\\.\"");
+        }
+        else
+        {
+            parts = StringUtils.split(schemaName, ".");
+        }
+
+        return SchemaKey.fromParts(parts);
+    }
 
     static QueryKey<?> dottedIdentifier(String compoundIdentifier)
     {
@@ -354,7 +309,6 @@ static String normalizeIdentifier(String compoundIdentifier)
         return new SqlParser().parseIdentifier(compoundIdentifier).toSQLString(true).toLowerCase();
     }
 
-
     /** JSON schema example provided by GEMINI, using triple tick-marks to delimit the machine-readable structured data
      *
      * Here is the database schema in JSON format:
@@ -383,4 +337,3 @@ static String normalizeIdentifier(String compoundIdentifier)
      * }```
      */
 }
-
diff --git a/search/src/org/labkey/search/SearchModule.java b/search/src/org/labkey/search/SearchModule.java
index 679d8bbe5c9..1fa610ed183 100644
--- a/search/src/org/labkey/search/SearchModule.java
+++ b/search/src/org/labkey/search/SearchModule.java
@@ -29,7 +29,6 @@
 import org.labkey.api.data.UpgradeCode;
 import org.labkey.api.mbean.LabKeyManagement;
 import org.labkey.api.mbean.SearchMXBean;
-import org.labkey.api.mcp.McpService;
 import org.labkey.api.migration.DatabaseMigrationConfiguration;
 import org.labkey.api.migration.DatabaseMigrationService;
 import org.labkey.api.migration.DefaultMigrationSchemaHandler;
@@ -134,11 +133,12 @@ public WebdavResource resolve(@NotNull String path)
             }
         });
 
-        var mcp = McpService.get();
-        if (null != mcp)
-        {
-            mcp.register(new SearchMcp());
-        }
+        // Search endpoints are not ready for prime time. For now, don't register.
+//        var mcp = McpService.get();
+//        if (null != mcp)
+//        {
+//            mcp.register(new SearchMcp());
+//        }
     }
 
     @Override

From be13ff50beebdc5c878d805c445cc6d49297552f Mon Sep 17 00:00:00 2001
From: Cory Nathe <cnathe@labkey.com>
Date: Mon, 6 Apr 2026 15:55:09 -0500
Subject: [PATCH 4/5] GitHub Issue 974: Lookup data type incorrectly shown in
 app assay designer (#7544)

- update @labkey/components package version
---
 assay/package-lock.json      | 8 ++++----
 assay/package.json           | 2 +-
 core/package-lock.json       | 8 ++++----
 core/package.json            | 2 +-
 experiment/package-lock.json | 8 ++++----
 experiment/package.json      | 2 +-
 pipeline/package-lock.json   | 8 ++++----
 pipeline/package.json        | 2 +-
 8 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/assay/package-lock.json b/assay/package-lock.json
index 0392199c880..00891ad6ac8 100644
--- a/assay/package-lock.json
+++ b/assay/package-lock.json
@@ -8,7 +8,7 @@
       "name": "assay",
       "version": "0.0.0",
       "dependencies": {
-        "@labkey/components": "7.21.0"
+        "@labkey/components": "7.21.4"
       },
       "devDependencies": {
         "@labkey/build": "8.9.0",
@@ -2765,9 +2765,9 @@
       }
     },
     "node_modules/@labkey/components": {
-      "version": "7.21.0",
-      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.21.0.tgz",
-      "integrity": "sha512-LK2ul66TvykGJk2/jWU3Gdq4w5maw8+qbElEol0eGAQAPQ9M0qCIzW75XVO8HMZ+VEXXXm6cKmbK1nF1m/pZRQ==",
+      "version": "7.21.4",
+      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.21.4.tgz",
+      "integrity": "sha512-8JTxwcdGDIRu3gHqIbwHJKTlr3eW0MsjZbeel3/yeW5uzKAj1P9ZgKqR6/S6+w8UjYmANgmspwZ5/SkaEB0qcQ==",
       "license": "SEE LICENSE IN LICENSE.txt",
       "dependencies": {
         "@hello-pangea/dnd": "18.0.1",
diff --git a/assay/package.json b/assay/package.json
index 84e9452666e..09727be4cd1 100644
--- a/assay/package.json
+++ b/assay/package.json
@@ -12,7 +12,7 @@
     "clean": "rimraf resources/web/assay/gen && rimraf resources/views/gen && rimraf resources/web/gen"
   },
   "dependencies": {
-    "@labkey/components": "7.21.0"
+    "@labkey/components": "7.21.4"
   },
   "devDependencies": {
     "@labkey/build": "8.9.0",
diff --git a/core/package-lock.json b/core/package-lock.json
index 24da56b166c..58da93e5cab 100644
--- a/core/package-lock.json
+++ b/core/package-lock.json
@@ -8,7 +8,7 @@
       "name": "labkey-core",
       "version": "0.0.0",
       "dependencies": {
-        "@labkey/components": "7.21.0",
+        "@labkey/components": "7.21.4",
         "@labkey/themes": "1.7.0"
       },
       "devDependencies": {
@@ -3760,9 +3760,9 @@
       }
     },
     "node_modules/@labkey/components": {
-      "version": "7.21.0",
-      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.21.0.tgz",
-      "integrity": "sha512-LK2ul66TvykGJk2/jWU3Gdq4w5maw8+qbElEol0eGAQAPQ9M0qCIzW75XVO8HMZ+VEXXXm6cKmbK1nF1m/pZRQ==",
+      "version": "7.21.4",
+      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.21.4.tgz",
+      "integrity": "sha512-8JTxwcdGDIRu3gHqIbwHJKTlr3eW0MsjZbeel3/yeW5uzKAj1P9ZgKqR6/S6+w8UjYmANgmspwZ5/SkaEB0qcQ==",
       "license": "SEE LICENSE IN LICENSE.txt",
       "dependencies": {
         "@hello-pangea/dnd": "18.0.1",
diff --git a/core/package.json b/core/package.json
index e3b8310db46..74a4bd2f2ad 100644
--- a/core/package.json
+++ b/core/package.json
@@ -53,7 +53,7 @@
     }
   },
   "dependencies": {
-    "@labkey/components": "7.21.0",
+    "@labkey/components": "7.21.4",
     "@labkey/themes": "1.7.0"
   },
   "devDependencies": {
diff --git a/experiment/package-lock.json b/experiment/package-lock.json
index 08f4d14fd23..df095bfafaf 100644
--- a/experiment/package-lock.json
+++ b/experiment/package-lock.json
@@ -8,7 +8,7 @@
       "name": "experiment",
       "version": "0.0.0",
       "dependencies": {
-        "@labkey/components": "7.21.0"
+        "@labkey/components": "7.21.4"
       },
       "devDependencies": {
         "@labkey/build": "8.9.0",
@@ -3611,9 +3611,9 @@
       }
     },
     "node_modules/@labkey/components": {
-      "version": "7.21.0",
-      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.21.0.tgz",
-      "integrity": "sha512-LK2ul66TvykGJk2/jWU3Gdq4w5maw8+qbElEol0eGAQAPQ9M0qCIzW75XVO8HMZ+VEXXXm6cKmbK1nF1m/pZRQ==",
+      "version": "7.21.4",
+      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.21.4.tgz",
+      "integrity": "sha512-8JTxwcdGDIRu3gHqIbwHJKTlr3eW0MsjZbeel3/yeW5uzKAj1P9ZgKqR6/S6+w8UjYmANgmspwZ5/SkaEB0qcQ==",
       "license": "SEE LICENSE IN LICENSE.txt",
       "dependencies": {
         "@hello-pangea/dnd": "18.0.1",
diff --git a/experiment/package.json b/experiment/package.json
index 2ec3b1510e5..3224ba773cf 100644
--- a/experiment/package.json
+++ b/experiment/package.json
@@ -13,7 +13,7 @@
     "test-integration": "cross-env NODE_ENV=test jest --ci --runInBand -c test/js/jest.config.integration.js"
   },
   "dependencies": {
-    "@labkey/components": "7.21.0"
+    "@labkey/components": "7.21.4"
   },
   "devDependencies": {
     "@labkey/build": "8.9.0",
diff --git a/pipeline/package-lock.json b/pipeline/package-lock.json
index 7540e0ce153..bc1d94e440f 100644
--- a/pipeline/package-lock.json
+++ b/pipeline/package-lock.json
@@ -8,7 +8,7 @@
       "name": "pipeline",
       "version": "0.0.0",
       "dependencies": {
-        "@labkey/components": "7.21.0"
+        "@labkey/components": "7.21.4"
       },
       "devDependencies": {
         "@labkey/build": "8.9.0",
@@ -2925,9 +2925,9 @@
       }
     },
     "node_modules/@labkey/components": {
-      "version": "7.21.0",
-      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.21.0.tgz",
-      "integrity": "sha512-LK2ul66TvykGJk2/jWU3Gdq4w5maw8+qbElEol0eGAQAPQ9M0qCIzW75XVO8HMZ+VEXXXm6cKmbK1nF1m/pZRQ==",
+      "version": "7.21.4",
+      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.21.4.tgz",
+      "integrity": "sha512-8JTxwcdGDIRu3gHqIbwHJKTlr3eW0MsjZbeel3/yeW5uzKAj1P9ZgKqR6/S6+w8UjYmANgmspwZ5/SkaEB0qcQ==",
       "license": "SEE LICENSE IN LICENSE.txt",
       "dependencies": {
         "@hello-pangea/dnd": "18.0.1",
diff --git a/pipeline/package.json b/pipeline/package.json
index 952921d9471..f90e840a405 100644
--- a/pipeline/package.json
+++ b/pipeline/package.json
@@ -14,7 +14,7 @@
     "build-prod": "npm run clean && cross-env NODE_ENV=production PROD_SOURCE_MAP=source-map webpack --config node_modules/@labkey/build/webpack/prod.config.js --color --progress --profile"
   },
   "dependencies": {
-    "@labkey/components": "7.21.0"
+    "@labkey/components": "7.21.4"
   },
   "devDependencies": {
     "@labkey/build": "8.9.0",

From 6ac2f942887e4c042ba71b85c22b2f9a9265eb20 Mon Sep 17 00:00:00 2001
From: cnathe <cnathe@labkey.com>
Date: Tue, 7 Apr 2026 09:46:29 -0500
Subject: [PATCH 5/5] update @labkey/components package version

---
 assay/package-lock.json      | 8 ++++----
 assay/package.json           | 2 +-
 core/package-lock.json       | 8 ++++----
 core/package.json            | 2 +-
 experiment/package-lock.json | 8 ++++----
 experiment/package.json      | 2 +-
 pipeline/package-lock.json   | 8 ++++----
 pipeline/package.json        | 2 +-
 8 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/assay/package-lock.json b/assay/package-lock.json
index 35e46c318e2..4479d7102d2 100644
--- a/assay/package-lock.json
+++ b/assay/package-lock.json
@@ -8,7 +8,7 @@
       "name": "assay",
       "version": "0.0.0",
       "dependencies": {
-        "@labkey/components": "7.26.4"
+        "@labkey/components": "7.26.6"
       },
       "devDependencies": {
         "@labkey/build": "9.1.0",
@@ -2765,9 +2765,9 @@
       }
     },
     "node_modules/@labkey/components": {
-      "version": "7.26.4",
-      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.26.4.tgz",
-      "integrity": "sha512-pJ/P/qEiOdV2QYtLC+aDHcxUlroo5ENkYToYqb83+N4ksgmRYmv4oaTi0sIvXH0xSpRn3b31qys7gcHbL0yIbA==",
+      "version": "7.26.6",
+      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.26.6.tgz",
+      "integrity": "sha512-7mMRqSKWl3W+X6G3qQRpdJ+M4CLtyBZUTXV4XrP/ZBxukMBsXpJFNAOO70T65PeAtuDn6dae5kxzGknGvVFdUg==",
       "license": "SEE LICENSE IN LICENSE.txt",
       "dependencies": {
         "@hello-pangea/dnd": "18.0.1",
diff --git a/assay/package.json b/assay/package.json
index 66312dce83d..fc65d009e73 100644
--- a/assay/package.json
+++ b/assay/package.json
@@ -12,7 +12,7 @@
     "clean": "rimraf resources/web/assay/gen && rimraf resources/views/gen && rimraf resources/web/gen"
   },
   "dependencies": {
-    "@labkey/components": "7.26.4"
+    "@labkey/components": "7.26.6"
   },
   "devDependencies": {
     "@labkey/build": "9.1.0",
diff --git a/core/package-lock.json b/core/package-lock.json
index b73c7089e77..39fc52dd1c1 100644
--- a/core/package-lock.json
+++ b/core/package-lock.json
@@ -8,7 +8,7 @@
       "name": "labkey-core",
       "version": "0.0.0",
       "dependencies": {
-        "@labkey/components": "7.26.4",
+        "@labkey/components": "7.26.6",
         "@labkey/themes": "1.8.0"
       },
       "devDependencies": {
@@ -3759,9 +3759,9 @@
       }
     },
     "node_modules/@labkey/components": {
-      "version": "7.26.4",
-      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.26.4.tgz",
-      "integrity": "sha512-pJ/P/qEiOdV2QYtLC+aDHcxUlroo5ENkYToYqb83+N4ksgmRYmv4oaTi0sIvXH0xSpRn3b31qys7gcHbL0yIbA==",
+      "version": "7.26.6",
+      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.26.6.tgz",
+      "integrity": "sha512-7mMRqSKWl3W+X6G3qQRpdJ+M4CLtyBZUTXV4XrP/ZBxukMBsXpJFNAOO70T65PeAtuDn6dae5kxzGknGvVFdUg==",
       "license": "SEE LICENSE IN LICENSE.txt",
       "dependencies": {
         "@hello-pangea/dnd": "18.0.1",
diff --git a/core/package.json b/core/package.json
index f36db022851..155a26aeb35 100644
--- a/core/package.json
+++ b/core/package.json
@@ -53,7 +53,7 @@
     }
   },
   "dependencies": {
-    "@labkey/components": "7.26.4",
+    "@labkey/components": "7.26.6",
     "@labkey/themes": "1.8.0"
   },
   "devDependencies": {
diff --git a/experiment/package-lock.json b/experiment/package-lock.json
index 06fb01a56d0..e52985735e9 100644
--- a/experiment/package-lock.json
+++ b/experiment/package-lock.json
@@ -8,7 +8,7 @@
       "name": "experiment",
       "version": "0.0.0",
       "dependencies": {
-        "@labkey/components": "7.26.4"
+        "@labkey/components": "7.26.6"
       },
       "devDependencies": {
         "@labkey/build": "9.1.0",
@@ -3609,9 +3609,9 @@
       }
     },
     "node_modules/@labkey/components": {
-      "version": "7.26.4",
-      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.26.4.tgz",
-      "integrity": "sha512-pJ/P/qEiOdV2QYtLC+aDHcxUlroo5ENkYToYqb83+N4ksgmRYmv4oaTi0sIvXH0xSpRn3b31qys7gcHbL0yIbA==",
+      "version": "7.26.6",
+      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.26.6.tgz",
+      "integrity": "sha512-7mMRqSKWl3W+X6G3qQRpdJ+M4CLtyBZUTXV4XrP/ZBxukMBsXpJFNAOO70T65PeAtuDn6dae5kxzGknGvVFdUg==",
       "license": "SEE LICENSE IN LICENSE.txt",
       "dependencies": {
         "@hello-pangea/dnd": "18.0.1",
diff --git a/experiment/package.json b/experiment/package.json
index d6898a03485..ce6ef8d2b50 100644
--- a/experiment/package.json
+++ b/experiment/package.json
@@ -13,7 +13,7 @@
     "test-integration": "cross-env NODE_ENV=test jest --ci --runInBand -c test/js/jest.config.integration.js"
   },
   "dependencies": {
-    "@labkey/components": "7.26.4"
+    "@labkey/components": "7.26.6"
   },
   "devDependencies": {
     "@labkey/build": "9.1.0",
diff --git a/pipeline/package-lock.json b/pipeline/package-lock.json
index 9aca16dd0f2..63748a3dc05 100644
--- a/pipeline/package-lock.json
+++ b/pipeline/package-lock.json
@@ -8,7 +8,7 @@
       "name": "pipeline",
       "version": "0.0.0",
       "dependencies": {
-        "@labkey/components": "7.26.4"
+        "@labkey/components": "7.26.6"
       },
       "devDependencies": {
         "@labkey/build": "9.1.0",
@@ -2925,9 +2925,9 @@
       }
     },
     "node_modules/@labkey/components": {
-      "version": "7.26.4",
-      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.26.4.tgz",
-      "integrity": "sha512-pJ/P/qEiOdV2QYtLC+aDHcxUlroo5ENkYToYqb83+N4ksgmRYmv4oaTi0sIvXH0xSpRn3b31qys7gcHbL0yIbA==",
+      "version": "7.26.6",
+      "resolved": "https://labkey.jfrog.io/artifactory/api/npm/libs-client/@labkey/components/-/@labkey/components-7.26.6.tgz",
+      "integrity": "sha512-7mMRqSKWl3W+X6G3qQRpdJ+M4CLtyBZUTXV4XrP/ZBxukMBsXpJFNAOO70T65PeAtuDn6dae5kxzGknGvVFdUg==",
       "license": "SEE LICENSE IN LICENSE.txt",
       "dependencies": {
         "@hello-pangea/dnd": "18.0.1",
diff --git a/pipeline/package.json b/pipeline/package.json
index 5d80afe4b0c..97bc74a7c80 100644
--- a/pipeline/package.json
+++ b/pipeline/package.json
@@ -14,7 +14,7 @@
     "build-prod": "npm run clean && cross-env NODE_ENV=production PROD_SOURCE_MAP=source-map webpack --config node_modules/@labkey/build/webpack/prod.config.js --color --progress --profile"
   },
   "dependencies": {
-    "@labkey/components": "7.26.4"
+    "@labkey/components": "7.26.6"
   },
   "devDependencies": {
     "@labkey/build": "9.1.0",