DocsFetcher MCP Server

Implementation Reference

• src/index.ts:287-390 (handler)

  The primary handler implementation for the 'fetch-multilingual-docs' tool. This inline function within the server.tool registration fetches package documentation across multiple languages, handles errors per language, selects the best result, and formats a summary with the content.

  server.tool(
    "fetch-multilingual-docs",
    {
      packageName: z
        .string()
        .describe("Name of the package to fetch documentation for"),
      languages: z
        .array(z.string())
        .describe(
          "List of programming languages or repository types to check (e.g., javascript, python, java)"
        ),
    },
    async ({ packageName, languages }) => {
      console.error(
        `Fetching documentation for package: ${packageName} across languages: ${languages.join(
          ", "
        )}`
      );
  
      const results: Record<string, any> = {};
      let hasSuccessfulFetch = false;
  
      for (const language of languages) {
        try {
          console.error(`Trying ${language} repository...`);
          const packageUrl = getPackageUrl(packageName, language);
  
          const documentationContent =
            await scraperService.fetchLibraryDocumentation(packageUrl);
  
          results[language] = {
            url: packageUrl,
            success: true,
            content: documentationContent,
          };
  
          hasSuccessfulFetch = true;
        } catch (error) {
          console.error(`Error fetching ${language} documentation:`, error);
          results[language] = {
            success: false,
            error: error instanceof Error ? error.message : String(error),
          };
        }
      }
  
      if (!hasSuccessfulFetch) {
        return {
          content: [
            {
              type: "text",
              text: `Failed to fetch documentation for ${packageName} in any of the requested languages: ${languages.join(
                ", "
              )}.`,
            },
          ],
          isError: true,
        };
      }
  
      // Format the successful results
      const bestLanguage =
        Object.keys(results).find((lang) => results[lang].success) ||
        languages[0];
      const bestContent = results[bestLanguage].content;
  
      // Include a summary of all language results
      const summaryLines = [
        `## Documentation Search Results for '${packageName}'`,
      ];
      summaryLines.push("");
  
      for (const language of languages) {
        const result = results[language];
        if (result.success) {
          summaryLines.push(
            `✅ **${language}**: Successfully fetched documentation from ${result.url}`
          );
        } else {
          summaryLines.push(`❌ **${language}**: Failed - ${result.error}`);
        }
      }
  
      summaryLines.push("");
      summaryLines.push(`---`);
      summaryLines.push("");
      summaryLines.push(
        `# Documentation Content (from ${bestLanguage} repository)`
      );
      summaryLines.push("");
  
      const summary = summaryLines.join("\n");
      const completeContent = summary + bestContent;
  
      return {
        content: [
          {
            type: "text",
            text: completeContent,
          },
        ],
      };
    }
  );