Error: Tool not found: search_paper
Available tools: search_papers, get_paper, ...

"description": "Searches papers"

@Component
public class McpDiscoveryFilter implements OncePerRequestFilter {

    private final List<ToolDefinition> tools;
    private final FuzzyMatcher fuzzyMatcher;

    public McpDiscoveryFilter(List<ToolDefinition> tools) {
        this.tools = tools;
        this.fuzzyMatcher = new FuzzyMatcher();
    }

    @Override
    protected void doFilterInternal(
        HttpServletRequest request,
        HttpServletResponse response,
        FilterChain filterChain
    ) throws ServletException, IOException {

        // Only intercept tools/call
        if (!request.getRequestURI().equals("/mcp/tools/call")) {
            filterChain.doFilter(request, response);
            return;
        }

        // Read the body
        var body = request.getReader().lines().collect(Collectors.joining());
        var callRequest = objectMapper.readValue(body, CallToolRequest.class);

        String requestedName = callRequest.getName();
        Optional<ToolDefinition> exactMatch = findExactMatch(requestedName);

        if (exactMatch.isPresent()) {
            // Exact match found, proceed normally
            proceedWithRequest(request, response, filterChain, body, exactMatch.get());
            return;
        }

        // No exact match — try fuzzy match
        List<MatchResult> matches = fuzzyMatcher.findBestMatches(requestedName, tools);

        if (matches.isEmpty() || matches.get(0).getScore() < 0.7) {
            // Still no good — return helpful error
            writeHelpfulError(response, requestedName, matches);
            return;
        }

        // We found a close match — rewrite the request and proceed!
        ToolDefinition bestMatch = matches.get(0).getTool();
        logger.info("Fuzzy matched: {} -> {} (score: {})", 
            requestedName, bestMatch.getName(), matches.get(0).getScore());

        // Rewrite with correct name and proceed
        callRequest.setName(bestMatch.getName());
        String rewrittenBody = objectMapper.writeValueAsString(callRequest);
        proceedWithRewrittenBody(request, response, filterChain, rewrittenBody, bestMatch);
    }

    private Optional<ToolDefinition> findExactMatch(String name) {
        return tools.stream()
            .filter(t -> t.getName().equals(name))
            .findFirst();
    }

    private void writeHelpfulError(
        HttpServletResponse response,
        String requestedName,
        List<MatchResult> matches
    ) throws IOException {
        Map<String, Object> error = new HashMap<>();
        error.put("result", null);
        error.put("error", Map.of(
            "message", String.format("Tool '%s' not found. Did you mean one of these? %s",
                requestedName,
                matches.stream()
                    .limit(3)
                    .map(m -> m.getTool().getName())
                    .collect(Collectors.joining(", "))
            ),
            "code", "TOOL_NOT_FOUND"
        ));
        response.setStatus(HttpStatus.OK.value());
        response.setContentType("application/json");
        objectMapper.writeValue(response.getWriter(), error);
    }
}

public class FuzzyMatcher {

    public List<MatchResult> findBestMatches(String input, List<ToolDefinition> tools) {
        return tools.stream()
            .map(tool -> {
                int distance = levenshteinDistance(input.toLowerCase(), tool.getName().toLowerCase());
                double score = 1.0 - (double) distance / Math.max(input.length(), tool.getName().length());
                return new MatchResult(tool, score);
            })
            .filter(mr -> mr.getScore() > 0.5)
            .sorted((a, b) -> Double.compare(b.getScore(), a.getScore()))
            .collect(Collectors.toList());
    }

    private int levenshteinDistance(String s1, String s2) {
        int[][] dp = new int[s1.length() + 1][s2.length() + 1];

        for (int i = 0; i <= s1.length(); i++) {
            dp[i][0] = i;
        }
        for (int j = 0; j <= s2.length(); j++) {
            dp[0][j] = j;
        }

        for (int i = 1; i <= s1.length(); i++) {
            for (int j = 1; j <= s2.length(); j++) {
                int cost = (s1.charAt(i - 1) == s2.charAt(j - 1)) ? 0 : 1;
                dp[i][j] = Math.min(
                    Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1),
                    dp[i - 1][j - 1] + cost
                );
            }
        }

        return dp[s1.length()][s2.length()];
    }
}

public record MatchResult(ToolDefinition tool, double score) {}

{
  "name": "search_papers",
  "description": "Searches papers"
}

{
  "name": "search_papers",
  "description": "Search my personal knowledge base for papers and notes by semantic similarity. Use this when you need to find information I've previously saved that's relevant to the current conversation. Returns the most relevant papers with their content. Parameters: query (string) - the search query based on the current context."
}

public class ParameterAliasResolver {
    private final Map<String, String> aliases = new HashMap<>();

    public ParameterAliasResolver() {
        // Common aliases for common parameter names
        aliases.put("question", "query");
        aliases.put("search", "query");  
        aliases.put("search_term", "query");
        aliases.put("id", "paper_id");
        aliases.put("paperId", "paper_id");
        aliases.put("key", "api_key");
        aliases.put("token", "api_key");
    }

    public void addAlias(String alias, String correctName) {
        aliases.put(alias.toLowerCase(), correctName);
    }

    public String resolve(String paramName) {
        return aliases.getOrDefault(paramName.toLowerCase(), paramName);
    }

    public void resolveAll(Map<String, Object> params) {
        List<String> keysToRemove = new ArrayList<>();
        Map<String, Object> toAdd = new HashMap<>();

        for (Map.Entry<String, Object> entry : params.entrySet()) {
            String resolved = resolve(entry.getKey());
            if (!resolved.equals(entry.getKey())) {
                keysToRemove.add(entry.getKey());
                toAdd.put(resolved, entry.getValue());
            }
        }

        keysToRemove.forEach(params::remove);
        params.putAll(toAdd);
    }
}

public CallToolResult callTool(String name, Map<String, Object> args) {
    parameterAliasResolver.resolveAll(args);
    // proceed with correct parameter names
}

@Configuration
public class ToolRegistryConfiguration {

    @Bean
    public ToolRegistry toolRegistry(List<McpTool> tools) {
        ToolRegistry registry = new ToolRegistry();
        tools.forEach(registry::register);
        return registry;
    }
}

public interface McpTool {
    ToolDefinition getDefinition();
    Object call(Map<String, Object> args) throws ToolException;
}

public class ToolRegistry {
    private final Map<String, McpTool> tools = new HashMap<>();
    private final ParameterAliasResolver aliasResolver = new ParameterAliasResolver();

    public void register(McpTool tool) {
        ToolDefinition def = tool.getDefinition();
        tools.put(def.getName(), tool);

        // Register aliases from the definition if provided
        if (def.getAliases() != null) {
            for (String alias : def.getAliases()) {
                aliasResolver.addAlias(alias, def.getName());
            }
        }
    }

    // ... fuzzy matching logic here
}