{
  jsonrpc: "2.0",
  id: number | string,
  method: string,
  params?: object
}

{
  jsonrpc: "2.0",
  id: number | string,
  result?: object,
  error?: {
    code: number,
    message: string,
    data?: unknown
  }
}

@Override
public <T> Mono<T> sendRequest(String method, Object requestParams, TypeReference<T> typeRef) {
  String requestId = this.generateRequestId();

return Mono.<McpSchema.JSONRPCResponse>create(sink -> {
   this.pendingResponses.put(requestId, sink);
   // 構(gòu)建json-rpc請(qǐng)求
   McpSchema.JSONRPCRequest jsonrpcRequest = new McpSchema.JSONRPCRequest(McpSchema.JSONRPC_VERSION, method,requestId, requestParams);
            // 發(fā)送請(qǐng)求
   this.transport.sendMessage(jsonrpcRequest)
    .subscribe(v -> {}, error -> {
     this.pendingResponses.remove(requestId);
     sink.error(error);
    });
  }).timeout(this.requestTimeout).handle((jsonRpcResponse, sink) -> {
            // 省略異常處理
  });
 }

/** 構(gòu)建根據(jù)城市獲取天氣的tool
     * @param city 城市名稱
     * @return 天氣信息
     */
    @Tool(name = "getWeather", description = "根據(jù)城市獲取天氣")
    public String getWeather(String city) {
        return new String((city).getBytes(), StandardCharsets.UTF_8) + " 天氣為晴天 25℃";
    }

spring:
  ai:
    mcp:
      client:
        sse:
          connections:
            server1: # sse服務(wù)端
              url: http://127.0.0.1:8080

@Bean
    public CommandLineRunner callToolByLLM(ChatClient.Builder chatClientBuilder,
                                                 ToolCallbackProvider toolCallbackProvider,
                                                 ConfigurableApplicationContext context) {

        return args -> {
            System.out.println("基于spring-ai，llm調(diào)用方法------");
            Gson gson = new Gson();
            // 模擬用戶輸入的信息，并把工具列表傳給LLM
            String userInput = "獲取北京的天氣";
            System.out.println("用戶問(wèn): " + userInput);
            var chatClient = chatClientBuilder
                    .defaultUser("獲取北京的天氣")
                    .defaultTools(toolCallbackProvider)
                    .build();
            // 包裝請(qǐng)求LLM
            String content = chatClient.prompt(userInput).call().content();
            System.out.println("AI回答: " + gson.toJson(content));
            // 結(jié)束會(huì)話
            context.close();
        };
    }

public class SyncMcpToolCallbackProvider implements ToolCallbackProvider {
    @Override
    public ToolCallback[] getToolCallbacks() {

        var toolCallbacks = new ArrayList<>();

        this.mcpClients.stream().forEach(mcpClient -> {
            // mcpClient.listTools()
            toolCallbacks.addAll(mcpClient.listTools()
                    .tools()
                    .stream()
                    .filter(tool -> toolFilter.test(mcpClient, tool))
                    .map(tool -> new SyncMcpToolCallback(mcpClient, tool))
                    .toList());
        });
        var array = toolCallbacks.toArray(new ToolCallback[0]);
        validateToolCallbacks(array);
        return array;
    }
}

public Mono<McpSchema.ListToolsResult> listTools(String cursor) {
    return this.withInitializationCheck("listing tools", initializedResult -> {
        if (this.serverCapabilities.tools() == null) {
            return Mono.error(new McpError("Server does not provide tools capability"));
        }
        return this.mcpSession.sendRequest(McpSchema.METHOD_TOOLS_LIST, new McpSchema.PaginatedRequest(cursor),
                LIST_TOOLS_RESULT_TYPE_REF);
    });
}

public ChatResponse internalCall(Prompt prompt, ChatResponse previousChatResponse) {

        // 構(gòu)建提示詞、工具
        ChatCompletionRequest request = createRequest(prompt, false);
        // 構(gòu)建要調(diào)用的大模型信息
        ChatModelObservationContext observationContext = ChatModelObservationContext.builder()
                .prompt(prompt)
                .provider(OpenAiApiConstants.PROVIDER_NAME)
                .requestOptions(prompt.getOptions())
                .build();

        ChatResponse response = ChatModelObservationDocumentation.CHAT_MODEL_OPERATION
                .observation(this.observationConvention, DEFAULT_OBSERVATION_CONVENTION, () -> observationContext,
                        this.observationRegistry)
                .observe(() -> {
                    // post請(qǐng)求大模型Api
                    ResponseEntity<ChatCompletion> completionEntity = this.retryTemplate
                            .execute(ctx -> this.openAiApi.chatCompletionEntity(request, getAdditionalHttpHeaders(prompt)));
                    // 解析結(jié)果省略步驟 ...
                    return chatResponse;
                });

        // 判斷是否是工具調(diào)用
        if (toolExecutionEligibilityPredicate.isToolExecutionRequired(prompt.getOptions(), response)) {
            var toolExecutionResult = this.toolCallingManager.executeToolCalls(prompt, response);
            // 判斷是否返回結(jié)果
            if (toolExecutionResult.returnDirect()) {
                // Return tool execution result directly to the client.
                return ChatResponse.builder()
                        .from(response)
                        .generations(ToolExecutionResult.buildGenerations(toolExecutionResult))
                        .build();
            }
            else {
                // 帶著工具結(jié)果直接調(diào)用
                returnthis.internalCall(new Prompt(toolExecutionResult.conversationHistory(), prompt.getOptions()),response);
            }
        }
        return response;
    }

[
    {
        "assistantMessage": {
            "toolCalls": [
                {
                    "id": "call_b4a9cb0f04a3495d941b71",
                    "type": "function",
                    "name": "spring_ai_mcp_client_server1_getWeather",
                    "arguments": "{\"city\": \"北京\"}"
                }
            ],
        // 中間內(nèi)容省略...
        "chatGenerationMetadata": {
            "metadata": {},
            "finishReason": "TOOL_CALLS",
            "contentFilters": []
        }
    }
]

public Mono<McpSchema.CallToolResult> callTool(McpSchema.CallToolRequest callToolRequest) {
  return this.withInitializationCheck("calling tools", initializedResult -> {
   if (this.serverCapabilities.tools() == null) {
    return Mono.error(new McpError("Server does not provide tools capability"));
   }
   return this.mcpSession.sendRequest(McpSchema.METHOD_TOOLS_CALL, callToolRequest, CALL_TOOL_RESULT_TYPE_REF);
  });
 }