Markdownify MCP Server

Instructions

Implementation Reference

• src/server.ts:48-70 (handler)

  Handler logic for URL-based tools including 'bing-search-to-markdown'. Validates URL, checks safety, and delegates to Markdownify.toMarkdown for conversion.

  switch (name) {
    case tools.YouTubeToMarkdownTool.name:
    case tools.BingSearchResultToMarkdownTool.name:
    case tools.WebpageToMarkdownTool.name:
      if (!validatedArgs.url) {
        throw new Error("URL is required for this tool");
      }     
      
      const parsedUrl = new URL(validatedArgs.url);
      if (!["http:", "https:"].includes(parsedUrl.protocol)) {
        throw new Error("Only http: and https: schemes are allowed.");
      }
      
      if (is_ip_private(parsedUrl.hostname)) {
        throw new Error(`Fetching ${validatedArgs.url} is potentially dangerous, aborting.`);
      }
  
      result = await Markdownify.toMarkdown({
        url: validatedArgs.url,
        projectRoot: validatedArgs.projectRoot,
        uvPath: validatedArgs.uvPath || process.env.UV_PATH,
      });
      break;

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

  Tool schema defining name, description, and input requirements (URL) for 'bing-search-to-markdown'.

  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:33-37 (registration)

  Registers all tools from tools.ts, including 'bing-search-to-markdown', in the MCP listTools handler.

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

• src/Markdownify.ts:74-124 (helper)

  Implements the core markdown conversion for URLs (including Bing search pages) by fetching content, saving to temp file, executing markitdown via uv, and returning markdown text.

  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);
  
        let extension = null;
  
        if (url.endsWith(".pdf")) {
          extension = "pdf";
        }
  
        const arrayBuffer = await response.arrayBuffer();
        const content = Buffer.from(arrayBuffer);
  
        inputPath = await this.saveToTempFile(content, extension);
        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");
      }
    }
  }