Feature/mcp

.dockerignore

@@ -5,7 +5,6 @@ target/maven-*
 target/ROOT
 target/test-classes/
 target/war
-target/duplicate-finder-result.xml
 target/jacoco.exec
 target/*.original
 .idea

pom.xml

@@ -383,6 +383,31 @@
             <version>5.0.1</version>
         </dependency>
 
+        <dependency>
+            <groupId>org.springframework.ai</groupId>
+            <artifactId>spring-ai-mcp</artifactId>
+            <version>1.0.1</version>
+        </dependency>
+        <!--
+        This will be included as well as using Spring Automatic Configuration
+        once spring-ai and io.modelcontextprotocol.sdk are on par
+        <dependency>
+            <groupId>org.springframework.ai</groupId>
+            <artifactId>spring-ai-starter-mcp-server</artifactId>
+            <version>1.0.1</version>
+        </dependency>
+        -->
+        <dependency>
+            <groupId>io.modelcontextprotocol.sdk</groupId>
+            <artifactId>mcp</artifactId>
+            <version>0.11.2</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+
+        </dependency>
 
         <dependency>
             <groupId>org.junit.jupiter</groupId>

src/main/java/ca/uhn/fhir/jpa/starter/AppProperties.java

@@ -21,9 +21,9 @@
 
 import static org.apache.commons.lang3.ObjectUtils.defaultIfNull;
 
+@EnableConfigurationProperties
 @ConfigurationProperties(prefix = "hapi.fhir")
 @Configuration
-@EnableConfigurationProperties
 public class AppProperties {
 
 	private final Set<String> auto_version_reference_at_paths = new HashSet<>();

src/main/java/ca/uhn/fhir/jpa/starter/mcp/CallToolResultFactory.java

@@ -0,0 +1,40 @@
+package ca.uhn.fhir.jpa.starter.mcp;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.modelcontextprotocol.spec.McpSchema;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+
+@Component
+public class CallToolResultFactory {
+
+	public static McpSchema.CallToolResult success(
+			String resourceType, Interaction interaction, String response, int status) {
+		Map<String, Object> payload = Map.of(
+				"resourceType", resourceType,
+				"interaction", interaction,
+				"response", response,
+				"status", status);
+
+		ObjectMapper objectMapper = new ObjectMapper();
+		String jacksonData;
+		try {
+			jacksonData = objectMapper.writeValueAsString(payload);
+		} catch (JsonProcessingException e) {
+			throw new RuntimeException(e);
+		}
+
+		return McpSchema.CallToolResult.builder()
+				.addContent(new McpSchema.TextContent(jacksonData))
+				.build();
+	}
+
+	public static McpSchema.CallToolResult failure(String message) {
+		return McpSchema.CallToolResult.builder()
+				.isError(true)
+				.addTextContent(message)
+				.build();
+	}
+}

src/main/java/ca/uhn/fhir/jpa/starter/mcp/Interaction.java

@@ -0,0 +1,34 @@
+package ca.uhn.fhir.jpa.starter.mcp;
+
+import ca.uhn.fhir.rest.api.RequestTypeEnum;
+
+public enum Interaction {
+	CALL_CDS_HOOK("call-cds-hook"),
+	SEARCH("search"),
+	READ("read"),
+	CREATE("create"),
+	UPDATE("update"),
+	DELETE("delete"),
+	PATCH("patch"),
+	TRANSACTION("transaction");
+
+	private final String name;
+
+	Interaction(String name) {
+		this.name = name;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public RequestTypeEnum asRequestType() {
+		return switch (this) {
+			case SEARCH, READ -> RequestTypeEnum.GET;
+			case CREATE, TRANSACTION, CALL_CDS_HOOK -> RequestTypeEnum.POST;
+			case UPDATE -> RequestTypeEnum.PUT;
+			case DELETE -> RequestTypeEnum.DELETE;
+			case PATCH -> RequestTypeEnum.PATCH;
+		};
+	}
+}

src/main/java/ca/uhn/fhir/jpa/starter/mcp/McpServerConfig.java

@@ -0,0 +1,74 @@
+package ca.uhn.fhir.jpa.starter.mcp;
+
+import ca.uhn.fhir.context.FhirContext;
+import ca.uhn.fhir.rest.server.McpBridge;
+import ca.uhn.fhir.rest.server.McpCdsBridge;
+import ca.uhn.fhir.rest.server.McpFhirBridge;
+import ca.uhn.fhir.rest.server.RestfulServer;
+import ca.uhn.hapi.fhir.cdshooks.api.ICdsServiceRegistry;
+import ca.uhn.hapi.fhir.cdshooks.module.CdsHooksObjectMapperFactory;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.modelcontextprotocol.server.McpServer;
+import io.modelcontextprotocol.server.McpSyncServer;
+import io.modelcontextprotocol.server.transport.HttpServletStreamableServerTransportProvider;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.web.servlet.ServletRegistrationBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.util.List;
+
+// https://mcp-cn.ssshooter.com/sdk/java/mcp-server#sse-servlet
+// https://www.baeldung.com/spring-ai-model-context-protocol-mcp
+// https://github.com/spring-projects/spring-ai-examples/blob/main/model-context-protocol/weather/manual-webflux-server/src/main/java/org/springframework/ai/mcp/sample/server/McpServerConfig.java
+// https://github.com/spring-projects/spring-ai-examples/tree/main/model-context-protocol/weather/starter-stdio-server/src/main/java/org/springframework/ai/mcp/sample/server
+// https://github.com/spring-projects/spring-ai-examples/blob/main/model-context-protocol/sampling/mcp-weather-webmvc-server/src/main/java/org/springframework/ai/mcp/sample/server/WeatherService.java
+// https://docs.spring.io/spring-ai/reference/api/mcp/mcp-server-boot-starter-docs.html
+@Configuration
+@ConditionalOnProperty(
+		prefix = "spring.ai.mcp.server",
+		name = {"enabled"},
+		havingValue = "true")
+public class McpServerConfig {
+
+	@Bean
+	public McpSyncServer syncServer(
+			List<McpBridge> mcpBridges, HttpServletStreamableServerTransportProvider transportProvider) {
+		return McpServer.sync(transportProvider)
+				.tools(mcpBridges.stream()
+						.flatMap(bridge -> bridge.generateTools().stream())
+						.toList())
+				.build();
+	}
+
+	@Bean
+	public McpFhirBridge mcpFhirBridge(RestfulServer restfulServer) {
+		return new McpFhirBridge(restfulServer);
+	}
+
+	@Bean
+	@ConditionalOnProperty(
+			prefix = "hapi.fhir.cr",
+			name = {"enabled"},
+			havingValue = "true")
+	public McpCdsBridge mcpCdsBridge(FhirContext fhirContext, ICdsServiceRegistry cdsServiceRegistry) {
+
+		return new McpCdsBridge(
+				fhirContext, cdsServiceRegistry, new CdsHooksObjectMapperFactory(fhirContext).newMapper());
+	}
+
+	@Bean
+	public HttpServletStreamableServerTransportProvider servletSseServerTransportProvider() {
+		return HttpServletStreamableServerTransportProvider.builder()
+				.disallowDelete(false)
+				.mcpEndpoint("/mcp/message")
+				.objectMapper(new ObjectMapper())
+				.contextExtractor((serverRequest, context) -> context)
+				.build();
+	}
+
+	@Bean
+	public ServletRegistrationBean customServletBean(HttpServletStreamableServerTransportProvider transportProvider) {
+		return new ServletRegistrationBean<>(transportProvider, "/mcp/message", "/sse");
+	}
+}

src/main/java/ca/uhn/fhir/jpa/starter/mcp/RequestBuilder.java

@@ -0,0 +1,111 @@
+package ca.uhn.fhir.jpa.starter.mcp;
+
+import ca.uhn.fhir.context.FhirContext;
+import com.google.gson.Gson;
+import org.hl7.fhir.instance.model.api.IBaseResource;
+import org.springframework.mock.web.MockHttpServletRequest;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+
+public class RequestBuilder {
+
+	private final FhirContext fhirContext;
+	private final String resourceType;
+	private final Interaction interaction;
+	private final Map<String, Object> config;
+	/**
+	 * Constructs a RequestBuilder for a specific FHIR interaction.
+	 *
+	 * @param fhirContext the FHIR context
+	 * @param contextMap  a map containing configuration parameters, including 'resourceType'
+	 * @param interaction the type of interaction (e.g., SEARCH, READ, CREATE, etc.)
+	 */
+	public RequestBuilder(FhirContext fhirContext, Map<String, Object> contextMap, Interaction interaction) {
+		this.config = contextMap;
+		if (interaction == Interaction.TRANSACTION) this.resourceType = "";
+		else if (contextMap.get("resourceType") instanceof String rt && !rt.isBlank()) this.resourceType = rt;
+		else throw new IllegalArgumentException("Missing or invalid 'resourceType' in contextMap");
+
+		this.interaction = interaction;
+		this.fhirContext = fhirContext;
+	}
+
+	public MockHttpServletRequest buildRequest() {
+		String basePath = "/" + resourceType;
+		String method;
+		MockHttpServletRequest req;
+
+		switch (interaction) {
+			case SEARCH -> {
+				method = "GET";
+				req = new MockHttpServletRequest(method, basePath);
+				if (config.get("searchParams") instanceof Map<?, ?> sp) {
+					sp.forEach((k, v) -> req.addParameter(k.toString(), v.toString()));
+				}
+			}
+			case READ -> {
+				method = "GET";
+				String id = requireString();
+				req = new MockHttpServletRequest(method, basePath + "/" + id);
+			}
+			case CREATE, TRANSACTION -> {
+				method = "POST";
+				req = new MockHttpServletRequest(method, basePath);
+				applyResourceBody(req);
+			}
+			case UPDATE -> {
+				method = "PUT";
+				String id = requireString();
+				req = new MockHttpServletRequest(method, basePath + "/" + id);
+				applyResourceBody(req);
+			}
+			case DELETE -> {
+				method = "DELETE";
+				String id = requireString();
+				req = new MockHttpServletRequest(method, basePath + "/" + id);
+			}
+			case PATCH -> {
+				method = "PATCH";
+				String id = requireString();
+				req = new MockHttpServletRequest(method, basePath + "/" + id);
+				applyPatchBody(req);
+			}
+			default -> throw new IllegalArgumentException("Unsupported interaction: " + interaction);
+		}
+
+		req.setContentType("application/fhir+json");
+		req.addHeader("Accept", "application/fhir+json");
+		return req;
+	}
+
+	private void applyResourceBody(MockHttpServletRequest req) {
+		Object resourceObj = config.get("resource");
+		String json = new Gson().toJson(resourceObj, Map.class);
+		req.setContent(json.getBytes(StandardCharsets.UTF_8));
+	}
+
+	private void applyPatchBody(MockHttpServletRequest req) {
+		Object patchBody = config.get("patch");
+		if (patchBody == null) {
+			throw new IllegalArgumentException("Missing 'patch' for patch interaction");
+		}
+		String content;
+		if (patchBody instanceof String s) {
+			content = s;
+		} else if (patchBody instanceof IBaseResource r) {
+			content = fhirContext.newJsonParser().encodeResourceToString(r);
+		} else {
+			throw new IllegalArgumentException("Unsupported patch body type: " + patchBody.getClass());
+		}
+		req.setContent(content.getBytes(StandardCharsets.UTF_8));
+	}
+
+	private String requireString() {
+		Object val = config.get("id");
+		if (!(val instanceof String s) || s.isBlank()) {
+			throw new IllegalArgumentException("Missing or invalid '" + "id" + "'");
+		}
+		return s;
+	}
+}