McpCoderServer mcpCoderServer = new McpCoderServer();
McpHandler mcpCoderHandler = new McpHandler(mcpCoderServer);
r.add("/mcp", mcpCoderHandler);

package nexus.io.kit.handler;

import java.util.Map;

import com.alibaba.fastjson2.util.TypeUtils;
import nexus.io.mcp.context.McpRequestContext;
import nexus.io.mcp.exception.McpRpcException;
import nexus.io.mcp.model.JsonRpcRequest;
import nexus.io.mcp.model.JsonRpcResponse;
import nexus.io.mcp.model.McpInitializeParams;
import nexus.io.mcp.model.McpInitializeResult;
import nexus.io.mcp.model.McpMethod;
import nexus.io.mcp.model.McpToolsCallParams;
import nexus.io.mcp.model.McpToolsCallResult;
import nexus.io.mcp.model.McpToolsListResult;
import nexus.io.mcp.model.RpcError;
import nexus.io.mcp.server.IMcpServer;
import nexus.io.tio.boot.http.TioRequestContext;
import nexus.io.tio.core.ChannelContext;
import nexus.io.tio.core.Tio;
import nexus.io.tio.http.common.HeaderName;
import nexus.io.tio.http.common.HeaderValue;
import nexus.io.tio.http.common.HttpMethod;
import nexus.io.tio.http.common.HttpRequest;
import nexus.io.tio.http.common.HttpResponse;
import nexus.io.tio.http.common.utils.HttpIpUtils;
import nexus.io.tio.http.server.handler.HttpRequestHandler;
import nexus.io.tio.http.server.util.SseEmitter;
import nexus.io.tio.utils.UUIDUtils;
import nexus.io.tio.utils.hutool.StrUtil;
import nexus.io.tio.utils.json.JsonUtils;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class McpHandler implements HttpRequestHandler {

  private IMcpServer mcpServer;

  public McpHandler(IMcpServer mcpServer) {
    this.mcpServer = mcpServer;
  }

  @Override
  public HttpResponse handle(HttpRequest httpRequest) {
    HttpResponse httpResponse = TioRequestContext.getResponse();
    ChannelContext channelContext = httpRequest.getChannelContext();

    String mcpSessionId = httpRequest.getHeader("mcp-session-id");
    String protocolVersion = httpRequest.getHeader("mcp-protocol-version");

    if (mcpSessionId == null) {
      mcpSessionId = UUIDUtils.random();
    }
    httpResponse.addHeader("mcp-session-id", mcpSessionId);

    String realIp = HttpIpUtils.getRealIp(httpRequest);
    Map<String, String> headers = httpRequest.getHeaders();

    if (httpRequest.getMethod().equals(HttpMethod.DELETE)) {
      McpRequestContext mcpRequestContext = new McpRequestContext(mcpSessionId, protocolVersion, realIp, headers);
      mcpServer.sessionClosed(mcpRequestContext);
      return httpResponse;
    }

    String bodyString = httpRequest.getBodyString();
    if (StrUtil.isBlank(bodyString)) {
      return httpResponse;
    }

    JsonRpcRequest rpcRequest = JsonUtils.parse(bodyString, JsonRpcRequest.class);
    if (rpcRequest == null) {
      return httpResponse;
    }
    String method = rpcRequest.getMethod();
    Object id = rpcRequest.getId();

    log.info("method:{}", method);
    if (McpMethod.INITIALIZE.equals(method)) {
      sendHttpResponseHeader(httpResponse, channelContext);
      Map<String, Object> params = rpcRequest.getParams();
      McpInitializeParams mcpInitializeParams = TypeUtils.cast(params, McpInitializeParams.class);
      if (protocolVersion == null) {
        protocolVersion = mcpInitializeParams.getProtocolVersion();
      }
      McpRequestContext mcpRequestContext = new McpRequestContext(mcpSessionId, protocolVersion, realIp, headers);

      McpInitializeResult initialize;
      try {
        initialize = mcpServer.initialize(mcpInitializeParams, mcpRequestContext);
        JsonRpcResponse<McpInitializeResult> resp = new JsonRpcResponse<>();
        resp.setId(id).setResult(initialize);
        sendSSEData(channelContext, resp);
      } catch (McpRpcException e) {
        log.error(e.getMessage(), e);
        JsonRpcResponse<?> resp = new JsonRpcResponse<>();
        RpcError rpcError = new RpcError();
        rpcError.setMessage(e.getMessage());
        resp.setId(id).setError(rpcError);
        sendSSEData(channelContext, resp);
      }

    } else if (McpMethod.NOTIFICATIONS_INITIALIZED.equals(method)) {
      McpRequestContext mcpRequestContext = new McpRequestContext(mcpSessionId, protocolVersion, realIp, headers);
      try {
        mcpServer.notificationsInitialized(mcpRequestContext);
        httpResponse.setStatus(202);
      } catch (McpRpcException e) {
        log.error(e.getMessage(), e);
        httpResponse.setStatus(500);
      }

    } else if (McpMethod.TOOLS_LIST.equals(method)) {
      sendHttpResponseHeader(httpResponse, channelContext);

      McpRequestContext mcpRequestContext = new McpRequestContext(mcpSessionId, protocolVersion, realIp, headers);
      McpToolsListResult result;
      try {
        result = mcpServer.listTools(mcpRequestContext);
        JsonRpcResponse<McpToolsListResult> resp = new JsonRpcResponse<>();
        resp.setId(id).setResult(result);
        sendSSEData(channelContext, resp);
      } catch (McpRpcException e) {
        log.error(e.getMessage(), e);
        JsonRpcResponse<?> resp = new JsonRpcResponse<>();
        RpcError rpcError = new RpcError();
        rpcError.setMessage(e.getMessage());
        resp.setId(id).setError(rpcError);
        sendSSEData(channelContext, resp);
      }

    } else if (McpMethod.TOOLS_CALL.equals(method)) {
      sendHttpResponseHeader(httpResponse, channelContext);

      McpRequestContext mcpRequestContext = new McpRequestContext(mcpSessionId, protocolVersion, realIp, headers);

      Map<String, Object> params = rpcRequest.getParams();
      McpToolsCallParams toolCallparams = TypeUtils.cast(params, McpToolsCallParams.class);
      McpToolsCallResult result;
      try {
        result = mcpServer.callTool(toolCallparams, mcpRequestContext);
        JsonRpcResponse<McpToolsCallResult> resp = new JsonRpcResponse<>();
        resp.setId(id).setResult(result);
        sendSSEData(channelContext, resp);
      } catch (McpRpcException e) {
        log.error(e.getMessage(), e);
        JsonRpcResponse<?> resp = new JsonRpcResponse<>();
        RpcError rpcError = new RpcError();
        rpcError.setMessage(e.getMessage());
        resp.setId(id).setError(rpcError);
        sendSSEData(channelContext, resp);
      }
    }
    return httpResponse;
  }

  private void sendSSEData(ChannelContext channelContext, JsonRpcResponse<?> resp) {
    String data = JsonUtils.toSkipNullJson(resp);
    // 发送数据
    SseEmitter.pushSSEChunk(channelContext, "message", data);
    // 手动移除连接
    // SseEmitter.closeChunkConnection(channelContext);
  }

  private void sendHttpResponseHeader(HttpResponse httpResponse, ChannelContext channelContext) {
    // 设置sse请求头
    httpResponse.addServerSentEventsHeader();
    httpResponse.addHeader(HeaderName.Transfer_Encoding, HeaderValue.from("chunked"));
    httpResponse.addHeader(HeaderName.Keep_Alive, HeaderValue.from("timeout=60"));
    // 手动发送消息到客户端,因为已经设置了sse的请求头,所以客户端的连接不会关闭
    Tio.bSend(channelContext, httpResponse);
    httpResponse.setSend(false);
  }
}

package nexus.io.kit.mcp;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import nexus.io.kit.service.GoogleGeminiSearchService;
import nexus.io.kit.utils.CmdInterpreterUtils;
import nexus.io.kit.utils.PythonInterpreterUtils;
import nexus.io.mcp.model.McpContent;
import nexus.io.mcp.model.McpServerInfo;
import nexus.io.mcp.server.McpToolRegistry;
import nexus.io.mcp.server.RegisteredTool;
import nexus.io.model.result.ResultVo;
import nexus.io.tio.utils.commandline.ProcessResult;
import nexus.io.tio.utils.json.JsonUtils;

import lombok.extern.slf4j.Slf4j;

/**
 * 的具体服务器：只需提供名称/版本。 如需添加或覆盖工具，可覆写 registerAdditionalTools() 或单独覆盖某个 handler。
 */
@Slf4j
public class McpCoderServer extends McpServer {

  private GoogleGeminiSearchService aiSearchService = new GoogleGeminiSearchService();

  public McpCoderServer() {
    super();
  }

  @Override
  protected McpServerInfo getMcpServerInfo() {
    return new McpServerInfo("Coder Server", "1.15.0");
  }

  @Override
  protected void registerTools() {
    // run_shell
    RegisteredTool runShell = McpToolRegistry.builder("run_shell").title("run shell")
        .description("执行 Linux Shell 命令并返回 stdout/stderr/exit_code,支持联网").addStringProperty("command", "Command", true)
        .addIntegerProperty("timeout", "Timeout", 30, false).addNullableProperty("cwd", "Cwd", "string", null, false)
        .addNullableObjectProperty("env", "Env", true, null, false).handler(this::handleRunShell).build();
    registry.register(runShell);

    // run_python
    RegisteredTool runPython = McpToolRegistry.builder("run_python").title("run python")
        .description("在子进程中执行一段 donghua代码，返回 stdout/stderr/exit_code,支持联网").addStringProperty("code", "Code", true)
        .addIntegerProperty("timeout", "Timeout", 30, false)
        .addNullableProperty("stdin", "Stdin", "string", null, false)
        .addBooleanProperty("use_isolated", "Use Isolated", true, false).handler(this::handleRunPython).build();
    registry.register(runPython);

    // ai_search（留一个简单的缺省实现，子类可覆盖 handler 或重载注册）
    RegisteredTool aiSearch = McpToolRegistry.builder("ai_search").title("AI Search")
        .description("智能搜索服务。会将问题拆分成多个关键字，通过 Google 搜索获取数据，然后结合模型进行回答,延迟20s.")
        //
        .addStringProperty("question", "Question", true).handler(this::handleAiSearch).build();
    registry.register(aiSearch);

  }

  /** 公共：run_shell 处理逻辑 */
  protected List<McpContent> handleRunShell(Map<String, Object> args) {
    List<McpContent> contents = new ArrayList<>();
    Object command = args.get("command");
    if (command instanceof String) {
      ProcessResult result = CmdInterpreterUtils.executeCmd((String) command);
      String text = JsonUtils.toSkipNullJson(result);
      contents.add(McpContent.buildText(text));
    } else {
      String json = JsonUtils.toSkipNullJson(ResultVo.fail("command must be a string"));
      contents.add(McpContent.buildText(json));
    }
    return contents;
  }

  /** 公共：run_python 处理逻辑 */
  protected List<McpContent> handleRunPython(Map<String, Object> args) {
    List<McpContent> contents = new ArrayList<>();
    Object code = args.get("code");
    if (code instanceof String) {
      ProcessResult result = PythonInterpreterUtils.executeCode((String) code);
      String text = JsonUtils.toSkipNullJson(result);
      contents.add(McpContent.buildText(text));
    } else {
      String json = JsonUtils.toSkipNullJson(ResultVo.fail("code must be a string"));
      contents.add(McpContent.buildText(json));
    }
    return contents;
  }

  /** 公共：ai_search 的缺省实现（示例占位，可被子类替换） */
  protected List<McpContent> handleAiSearch(Map<String, Object> args) {
    List<McpContent> contents = new ArrayList<>();
    Object question = args.get("question");
    if (question instanceof String) {
      log.info("keyword: {}", question);
      try {
        String text = JsonUtils.toSkipNullJson(aiSearchService.search((String) question));
        contents.add(McpContent.buildText(text));
      } catch (Exception e) {
        log.error(e.getMessage(), e);
        String json = JsonUtils.toSkipNullJson(ResultVo.fail(e.getMessage()));
        contents.add(McpContent.buildText(json));
      }

    } else {
      String json = JsonUtils.toSkipNullJson(ResultVo.fail("question must be a string"));
      contents.add(McpContent.buildText(json));
    }
    return contents;
  }
}

      McpCoderServer mcpCoderServer = new McpCoderServer();
      McpHandler mcpCoderHandler = new McpHandler(mcpCoderServer);
      r.add("/mcp", mcpCoderHandler);