Markdownify MCP Server - UTF-8 Enhanced

Instructions

Implementation Reference

• src/server.ts:47-58 (handler)

  Handler logic for the 'bing-search-to-markdown' tool. It is grouped with other URL-based tools (YouTube, webpage). Validates the URL input and calls Markdownify.toMarkdown to perform the conversion.

  case tools.YouTubeToMarkdownTool.name:
  case tools.BingSearchResultToMarkdownTool.name:
  case tools.WebpageToMarkdownTool.name:
    if (!validatedArgs.url) {
      throw new Error("URL is required for this tool");
    }
    result = await Markdownify.toMarkdown({
      url: validatedArgs.url,
      projectRoot: validatedArgs.projectRoot,
      uvPath: validatedArgs.uvPath || process.env.UV_PATH,
    });
    break;

• src/tools.ts:34-47 (schema)

  Defines the ToolSchema for 'bing-search-to-markdown', including name, description, and input schema requiring a 'url' parameter for the Bing search results page.

  export const BingSearchResultToMarkdownTool = ToolSchema.parse({
    name: "bing-search-to-markdown",
    description: "Convert a Bing search results page to markdown",
    inputSchema: {
      type: "object",
      properties: {
        url: {
          type: "string",
          description: "URL of the Bing search results page",
        },
      },
      required: ["url"],
    },
  });

• src/server.ts:31-35 (registration)

  Registers all tools from the tools module (including bing-search-to-markdown) in the MCP server's listTools request handler.

  server.setRequestHandler(ListToolsRequestSchema, async () => {
    return {
      tools: Object.values(tools),
    };
  });

• src/Markdownify.ts:51-92 (helper)

  Core helper function that handles URL inputs by fetching HTML content, saving to a temporary file, converting it to markdown using the markitdown tool, and returning the markdown text and output path.

  static async toMarkdown({
    filePath,
    url,
    projectRoot = path.resolve(__dirname, ".."),
    uvPath = "~/.local/bin/uv",
  }: {
    filePath?: string;
    url?: string;
    projectRoot?: string;
    uvPath?: string;
  }): Promise<MarkdownResult> {
    try {
      let inputPath: string;
      let isTemporary = false;
  
      if (url) {
        const response = await fetch(url);
        const content = await response.text();
        inputPath = await this.saveToTempFile(content);
        isTemporary = true;
      } else if (filePath) {
        inputPath = filePath;
      } else {
        throw new Error("Either filePath or url must be provided");
      }
  
      const text = await this._markitdown(inputPath, projectRoot, uvPath);
      const outputPath = await this.saveToTempFile(text);
  
      if (isTemporary) {
        fs.unlinkSync(inputPath);
      }
  
      return { path: outputPath, text };
    } catch (e: unknown) {
      if (e instanceof Error) {
        throw new Error(`Error processing to Markdown: ${e.message}`);
      } else {
        throw new Error("Error processing to Markdown: Unknown error occurred");
      }
    }
  }