modelcontextprotocol/java-sdk
Watch
1
0
Fork
You've already forked java-sdk
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

break into multiple modules. The mcp module is the MCP implementation with minimal dependecies

Browse source
This commit is contained in:
Christian Tzolov 2024-12-09 18:48:51 +01:00
commit 1982c39bbc
8 changed files with 200 additions and 2858 deletions
Download patch file Download diff file Expand all files Collapse all files

2
mcp/src/main/java/spring/ai/mcp/client/McpAsyncClient.java
View file

@ -14,7 +14,7 @@ public class McpAsyncClient extends McpAsyncSession {
this(transport, Duration.ofSeconds(10), new ObjectMapper());
}
public McpAsyncClient(McpAsyncTransport transport, Duration requestTimeout, ObjectMapper objectMapper) {
public McpAsyncClient(McpAsyncTransport transport, Duration requestTimeout, ObjectMapper objectMapper) {
super(requestTimeout, objectMapper, transport);
}

37
mcp/src/main/java/spring/ai/mcp/client/McpAsyncSession.java
View file

@ -2,7 +2,6 @@ package spring.ai.mcp.client;
import java.time.Duration;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
@ -10,6 +9,7 @@ import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import reactor.core.publisher.Mono;
import reactor.core.publisher.MonoSink;
import spring.ai.mcp.client.util.Assert;
import spring.ai.mcp.spec.McpAsyncTransport;
import spring.ai.mcp.spec.McpSchema;
@ -25,9 +25,9 @@ public class McpAsyncSession {
public McpAsyncSession(Duration requestTimeout, ObjectMapper objectMapper, McpAsyncTransport transport) {
Objects.nonNull(requestTimeout);
Objects.nonNull(objectMapper);
Objects.nonNull(transport);
Assert.notNull(objectMapper, "The ObjectMapper can not be null");
Assert.notNull(requestTimeout, "The requstTimeout can not be null");
Assert.notNull(transport, "The transport can not be null");
this.requestTimeout = requestTimeout;
this.objectMapper = objectMapper;
@ -39,8 +39,7 @@ public class McpAsyncSession {
var sink = pendingResponses.remove(response.id());
if (sink == null) {
System.out.println("Unexpected response for unkown id " + response.id());
}
else {
} else {
sink.success(response);
}
}
@ -69,26 +68,23 @@ public class McpAsyncSession {
// TODO: This is non-blocking, but it's actually a synchronous call,
// perhaps there's no need to make it return Mono?
this.transport.sendMessage(jsonrpcRequest)
// TODO: It's most efficient to create a dedicated
// Subscriber here
.subscribe(v -> {
}, e -> {
this.pendingResponses.remove(requestId);
sink.error(e);
});
}
catch (Exception e) {
// TODO: It's most efficient to create a dedicated
// Subscriber here
.subscribe(v -> {
}, e -> {
this.pendingResponses.remove(requestId);
sink.error(e);
});
} catch (Exception e) {
sink.error(e);
}
}).timeout(this.requestTimeout).handle((jsonRpcResponse, s) -> {
if (jsonRpcResponse.error() != null) {
s.error(new McpError(jsonRpcResponse.error()));
}
else {
} else {
if (typeRef.getType().getTypeName().equals("java.lang.Void")) {
s.complete();
}
else {
} else {
s.next(this.objectMapper.convertValue(jsonRpcResponse.result(), typeRef));
}
}
@ -113,8 +109,7 @@ public class McpAsyncSession {
try {
// TODO: make it non-blocking
this.transport.sendMessage(jsonrpcNotification);
}
catch (Exception e) {
} catch (Exception e) {
return Mono.error(new McpError(e));
}
return Mono.empty();

4
mcp/src/main/java/spring/ai/mcp/client/McpSyncClient.java
View file

@ -1,8 +1,8 @@
package spring.ai.mcp.client;
import java.time.Duration;
import java.util.Objects;
import spring.ai.mcp.client.util.Assert;
import spring.ai.mcp.spec.McpSchema;
public class McpSyncClient implements AutoCloseable {
@ -15,7 +15,7 @@ public class McpSyncClient implements AutoCloseable {
McpAsyncClient delegate;
public McpSyncClient(McpAsyncClient delegate) {
Objects.nonNull(delegate);
Assert.notNull(delegate, "The delegate can not be null");
this.delegate = delegate;
}

46
mcp/src/main/java/spring/ai/mcp/client/stdio/StdioServerParameters.java
View file

@ -5,12 +5,10 @@ import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import com.fasterxml.jackson.annotation.JsonProperty;
import org.springframework.util.CollectionUtils;
import spring.ai.mcp.client.util.Assert;
/**
* Server parameters for stdio client.
@ -19,11 +17,11 @@ public class StdioServerParameters {
// Environment variables to inherit by default
private static final List<String> DEFAULT_INHERITED_ENV_VARS = System.getProperty("os.name")
.toLowerCase()
.contains("win")
? Arrays.asList("APPDATA", "HOMEDRIVE", "HOMEPATH", "LOCALAPPDATA", "PATH",
"PROCESSOR_ARCHITECTURE", "SYSTEMDRIVE", "SYSTEMROOT", "TEMP", "USERNAME", "USERPROFILE")
: Arrays.asList("HOME", "LOGNAME", "PATH", "SHELL", "TERM", "USER");
.toLowerCase()
.contains("win")
? Arrays.asList("APPDATA", "HOMEDRIVE", "HOMEPATH", "LOCALAPPDATA", "PATH",
"PROCESSOR_ARCHITECTURE", "SYSTEMDRIVE", "SYSTEMROOT", "TEMP", "USERNAME", "USERPROFILE")
: Arrays.asList("HOME", "LOGNAME", "PATH", "SHELL", "TERM", "USER");
@JsonProperty("command")
private String command;
@ -35,13 +33,13 @@ public class StdioServerParameters {
private Map<String, String> env;
private StdioServerParameters(String command, List<String> args, Map<String, String> env) {
Objects.nonNull(command);
Objects.nonNull(args);
Assert.notNull(command, "The command can not be null");
Assert.notNull(args, "The args can not be null");
this.command = command;
this.args = args;
this.env = new HashMap<>(getDefaultEnvironment());
if (!CollectionUtils.isEmpty(env)) {
if (env != null && !env.isEmpty()) {
this.env.putAll(env);
}
}
@ -71,38 +69,38 @@ public class StdioServerParameters {
private Map<String, String> env = new HashMap<>();
public Builder(String command) {
Objects.no.hasText(command, "Command must not be empty");
Assert.notNull(command, "The command can not be null");
this.command = command;
}
public Builder args(String... args) {
Assert.notNull(args, "Arguments must not be null");
Assert.notNull(args, "The args can not be null");
this.args = Arrays.asList(args);
return this;
}
public Builder args(List<String> args) {
Assert.notNull(args, "Arguments must not be null");
Assert.notNull(args, "The args can not be null");
this.args = new ArrayList<>(args);
return this;
}
public Builder arg(String arg) {
Assert.hasText(arg, "Argument must not be empty");
Assert.notNull(arg, "The arg can not be null");
this.args.add(arg);
return this;
}
public Builder env(Map<String, String> env) {
if (!CollectionUtils.isEmpty(env)) {
if (env != null && !env.isEmpty()) {
this.env.putAll(env);
}
return this;
}
public Builder addEnvVar(String key, String value) {
Assert.hasText(key, "Environment variable key must not be empty");
Assert.notNull(value, "Environment variable value must not be null");
Assert.notNull(key, "The key can not be null");
Assert.notNull(value, "The value can not be null");
this.env.put(key, value);
return this;
}
@ -119,12 +117,12 @@ public class StdioServerParameters {
*/
private static Map<String, String> getDefaultEnvironment() {
return System.getenv()
.entrySet()
.stream()
.filter(entry -> DEFAULT_INHERITED_ENV_VARS.contains(entry.getKey()))
.filter(entry -> entry.getValue() != null)
.filter(entry -> !entry.getValue().startsWith("()"))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
.entrySet()
.stream()
.filter(entry -> DEFAULT_INHERITED_ENV_VARS.contains(entry.getKey()))
.filter(entry -> entry.getValue() != null)
.filter(entry -> !entry.getValue().startsWith("()"))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
}
}

36
mcp/src/main/java/spring/ai/mcp/client/stdio/StdioServerTransport.java
View file

@ -5,20 +5,23 @@ import java.io.BufferedWriter;
import java.io.IOException;
import java.time.Duration;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.Executors;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import reactor.core.scheduler.Scheduler;
import reactor.core.scheduler.Schedulers;
import spring.ai.mcp.client.util.Assert;
import spring.ai.mcp.spec.DefaultMcpTransport;
import spring.ai.mcp.spec.McpSchema.JSONRPCMessage;
import spring.ai.mcp.spec.McpSchema.JSONRPCNotification;
import spring.ai.mcp.spec.McpSchema.JSONRPCRequest;
import spring.ai.mcp.spec.McpSchema.JSONRPCResponse;
import org.springframework.ai.model.ModelOptionsUtils;
import org.springframework.util.Assert;
/**
* Stdio client for communicating with a server process.
*/
@ -47,7 +50,7 @@ public class StdioServerTransport extends DefaultMcpTransport {
public StdioServerTransport(StdioServerParameters params, Duration writeTimeout) {
super(writeTimeout);
Assert.notNull(params, "Server parameters must not be null");
Assert.notNull(params, "The params can not be null");
this.params = params;
@ -135,19 +138,34 @@ public class StdioServerTransport extends DefaultMcpTransport {
});
}
private static ObjectMapper OBJECT_MAPPER = new ObjectMapper();
private static TypeReference<HashMap<String, Object>> MAP_TYPE_REF = new TypeReference<HashMap<String, Object>>() {
};
public static Map<String, Object> jsonToMap(String json) {
try {
return OBJECT_MAPPER.readValue(json, MAP_TYPE_REF);
}
catch (Exception e) {
throw new RuntimeException(e);
}
}
private JSONRPCMessage deserializeJsonRpcMessage(String jsonText) throws IOException {
var map = ModelOptionsUtils.jsonToMap(jsonText);
var map = jsonToMap(jsonText);
// Determine message type based on specific JSON structure
if (map.containsKey("method") && map.containsKey("id")) {
return ModelOptionsUtils.OBJECT_MAPPER.convertValue(map, JSONRPCRequest.class);
return OBJECT_MAPPER.convertValue(map, JSONRPCRequest.class);
}
else if (map.containsKey("method") && !map.containsKey("id")) {
return ModelOptionsUtils.OBJECT_MAPPER.convertValue(map, JSONRPCNotification.class);
return OBJECT_MAPPER.convertValue(map, JSONRPCNotification.class);
}
else if (map.containsKey("result") || map.containsKey("error")) {
return ModelOptionsUtils.OBJECT_MAPPER.convertValue(map, JSONRPCResponse.class);
return OBJECT_MAPPER.convertValue(map, JSONRPCResponse.class);
}
throw new IllegalArgumentException("Cannot deserialize JSONRPCMessage: " + jsonText);
@ -190,7 +208,7 @@ public class StdioServerTransport extends DefaultMcpTransport {
.handle((message, s) -> {
if (message != null) {
try {
this.processWriter.write(ModelOptionsUtils.toJsonString(message));
this.processWriter.write(OBJECT_MAPPER.writeValueAsString(message));
this.processWriter.newLine();
this.processWriter.flush();
s.next(message);

75
mcp/src/main/java/spring/ai/mcp/client/util/Assert.java Normal file
View file

@ -0,0 +1,75 @@
/*
* Copyright 2024 - 2024 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package spring.ai.mcp.client.util;
import reactor.util.annotation.Nullable;
/**
* @author Christian Tzolov
* @since 1.0.0
*/
public class Assert {
/**
* Assert that an object is not {@code null}.
*
* <pre class="code">
* Assert.notNull(clazz, "The class must not be null");
* </pre>
*
* @param object the object to check
* @param message the exception message to use if the assertion fails
* @throws IllegalArgumentException if the object is {@code null}
*/
public static void notNull(@Nullable Object object, String message) {
if (object == null) {
throw new IllegalArgumentException(message);
}
}
/**
* Assert that the given String contains valid text content; that is, it must not
* be {@code null} and must contain at least one non-whitespace character.
* <pre class="code">Assert.hasText(name, "'name' must not be empty");</pre>
* @param text the String to check
* @param message the exception message to use if the assertion fails
* @throws IllegalArgumentException if the text does not contain valid text content
* @see StringUtils#hasText
*/
public static void hasText(@Nullable String text, String message) {
if (!hasText(text)) {
throw new IllegalArgumentException(message);
}
}
/**
* Check whether the given {@code String} contains actual <em>text</em>.
* <p>More specifically, this method returns {@code true} if the
* {@code String} is not {@code null}, its length is greater than 0,
* and it contains at least one non-whitespace character.
* @param str the {@code String} to check (may be {@code null})
* @return {@code true} if the {@code String} is not {@code null}, its
* length is greater than 0, and it does not contain whitespace only
* @see #hasText(CharSequence)
* @see #hasLength(String)
* @see Character#isWhitespace
*/
public static boolean hasText(@Nullable String str) {
return (str != null && !str.isBlank());
}
}

21
mcp/src/main/java/spring/ai/mcp/spec/DefaultMcpTransport.java
View file

@ -20,6 +20,7 @@ import java.util.function.Consumer;
import reactor.core.publisher.Mono;
import reactor.core.publisher.Sinks;
import spring.ai.mcp.client.util.Assert;
import spring.ai.mcp.spec.McpSchema.JSONRPCMessage;
/**
@ -43,22 +44,22 @@ public class DefaultMcpTransport implements McpAsyncTransport {
public DefaultMcpTransport(Duration readTimeout) {
// TODO: consider the effects of buffering here -> the inter-process pipes are
// independent and the notifications can flood the client/server.
// Potentially, the interest in reading could be communicated from one party
// to the other so the Blocking IO Threads can pause consuming the stream
// buffers when there is no expectation for reading.
// independent and the notifications can flood the client/server.
// Potentially, the interest in reading could be communicated from one party
// to the other so the Blocking IO Threads can pause consuming the stream
// buffers when there is no expectation for reading.
this.errorSink = Sinks.many().unicast().onBackpressureBuffer();
this.inboundSink = Sinks.many().unicast().onBackpressureBuffer();
this.outboundSink = Sinks.many().unicast().onBackpressureBuffer();
this.writeTimeout = readTimeout;
this.writeTimeout = readTimeout;
this.handleIncomingMessages();
}
private void handleIncomingMessages() {
this.inboundSink.asFlux()
.subscribe(message -> this.messageReader.accept(message));
.subscribe(message -> this.messageReader.accept(message));
}
private void handleIncomingErrors() {
@ -104,10 +105,10 @@ public class DefaultMcpTransport implements McpAsyncTransport {
public Mono<Void> sendMessage(JSONRPCMessage message) {
if (this.outboundSink.tryEmitNext(message).isSuccess()) {
// TODO: essentially we could reschedule ourselves in some time and make
// another attempt with the already read data but pause reading until
// success
// In this approach we delegate the retry and the backpressure onto the
// caller. This might be enough for most cases.
// another attempt with the already read data but pause reading until
// success
// In this approach we delegate the retry and the backpressure onto the
// caller. This might be enough for most cases.
return Mono.empty();
} else {
return Mono.error(new RuntimeException("Failed to enqueue message"));

34
mcp/src/main/java/spring/ai/mcp/spec/McpSession.java
View file

@ -17,7 +17,6 @@ package spring.ai.mcp.spec;
import java.time.Duration;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
@ -25,6 +24,7 @@ import java.util.concurrent.TimeUnit;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import spring.ai.mcp.client.util.Assert;
import spring.ai.mcp.spec.McpSchema.JSONRPCNotification;
import spring.ai.mcp.spec.McpSchema.JSONRPCRequest;
import spring.ai.mcp.spec.McpSchema.JSONRPCResponse;
@ -41,9 +41,9 @@ public class McpSession implements AutoCloseable {
public McpSession(McpTransport transport, Duration readTimeout, ObjectMapper objectMapper) {
Objects.nonNull(transport);
Objects.nonNull(readTimeout);
Objects.nonNull(objectMapper);
Assert.notNull(transport, "The transport can not be null");
Assert.notNull(readTimeout, "The readTimeout can not be null");
Assert.notNull(objectMapper, "The objectMapper can not be null");
this.waitingForResponseStreams = new ConcurrentHashMap<>();
@ -55,15 +55,13 @@ public class McpSession implements AutoCloseable {
this.transport.setMessageHandler(message -> {
if (message instanceof JSONRPCResponse jsonRpcResponse) {
CompletableFuture<JSONRPCResponse> responseFuture = this.waitingForResponseStreams
.remove(jsonRpcResponse.id());
.remove(jsonRpcResponse.id());
if (responseFuture != null) {
responseFuture.complete(jsonRpcResponse);
}
}
else if (message instanceof JSONRPCRequest jsonRpcRequest) {
} else if (message instanceof JSONRPCRequest jsonRpcRequest) {
handleRequest(new RequestResponder<>(jsonRpcRequest.id(), jsonRpcRequest));
}
else if (message instanceof JSONRPCNotification jsonRpcNotification) {
} else if (message instanceof JSONRPCNotification jsonRpcNotification) {
handleNotification(jsonRpcNotification);
}
});
@ -85,19 +83,18 @@ public class McpSession implements AutoCloseable {
try {
this.transport.sendMessage(jsonrpcRequest);
}
catch (Exception e) {
} catch (Exception e) {
return CompletableFuture.failedFuture(new McpError(e));
}
return responseFuture.orTimeout(this.readTimeout.toMillis(), TimeUnit.MILLISECONDS)
.thenApply(jsonRpcResponse -> {
if (jsonRpcResponse.error() != null) {
throw new McpError(jsonRpcResponse.error());
}
.thenApply(jsonRpcResponse -> {
if (jsonRpcResponse.error() != null) {
throw new McpError(jsonRpcResponse.error());
}
return this.objectMapper.convertValue(jsonRpcResponse.result(), typeRef);
});
return this.objectMapper.convertValue(jsonRpcResponse.result(), typeRef);
});
}
public CompletableFuture<Void> sendNotification(String method) {
@ -108,8 +105,7 @@ public class McpSession implements AutoCloseable {
JSONRPCNotification jsonrpcNotification = new JSONRPCNotification(McpSchema.JSONRPC_VERSION, method, params);
try {
this.transport.sendMessage(jsonrpcNotification);
}
catch (Exception e) {
} catch (Exception e) {
return CompletableFuture.failedFuture(new McpError(e));
}
return CompletableFuture.completedFuture(null);