Kagi Summarizer

Instructions

Implementation Reference

• src/tools/summarizer.js:28-111 (handler)

  The main handler function `kagiSummarizer` that implements the tool logic. It takes URL, summary_type, and target_language arguments, calls the `kagi-ken` summarize() function, extracts the summary text from the response, and returns an MCP-formatted content response.

  export async function kagiSummarizer(
    { url, summary_type = "summary", target_language },
  ) {
    try {
      if (!url) {
        throw new Error("Summarizer called with no URL.");
      }
  
      const { token, engine } = getEnvironmentConfig();
  
      // Validate summary type
      if (!["summary", "takeaway"].includes(summary_type)) {
        throw new Error(
          `Invalid summary_type: ${summary_type}. Must be 'summary' or 'takeaway'.`,
        );
      }
  
      // Set default language if not provided
      const language = target_language || "EN";
  
      // Validate language if provided
      if (
        target_language && SUPPORTED_LANGUAGES &&
        !SUPPORTED_LANGUAGES.includes(language)
      ) {
        console.warn(
          `Warning: Language '${language}' may not be supported. Supported languages: ${
            SUPPORTED_LANGUAGES.join(", ")
          }`,
        );
      }
  
      // Note about engine compatibility
      if (engine && engine !== "default") {
        console.warn(
          `Note: Engine selection (${engine}) from KAGI_SUMMARIZER_ENGINE may not be supported by kagi-ken. Using default behavior.`,
        );
      }
  
      // Prepare options for kagi-ken
      const options = {
        type: summary_type,
        language: language,
        isUrl: true,
      };
  
      // Call kagi-ken summarize function
      const result = await summarize(url, token, options);
  
      // Extract the summary text from the result
      // The structure may vary, so we'll try different possible response formats
      let summaryText;
      if (typeof result === "string") {
        summaryText = result;
      } else if (result && result.summary) {
        summaryText = result.summary;
      } else if (result && result.data && result.data.output) {
        summaryText = result.data.output;
      } else if (result && result.output) {
        summaryText = result.output;
      } else {
        // Fallback: stringify the result if it's not in expected format
        summaryText = JSON.stringify(result, null, 2);
      }
  
      return {
        content: [
          {
            type: "text",
            text: summaryText,
          },
        ],
      };
    } catch (error) {
      return {
        content: [
          {
            type: "text",
            text: formatError(error),
          },
        ],
      };
    }
  }

• src/tools/summarizer.js:8-16 (schema)

  Input validation schema `summarizerInputSchema` using Zod, defining url (string.url), summary_type (enum: summary/takeaway, default: summary), and target_language (optional string).

  export const summarizerInputSchema = {
    url: z.string().url().describe("A URL to a document to summarize."),
    summary_type: z.enum(["summary", "takeaway"]).default("summary").describe(
      "Type of summary to produce. Options are 'summary' for paragraph prose and 'takeaway' for a bulleted list of key points.",
    ),
    target_language: z.string().optional().describe(
      "Desired output language using language codes (e.g., 'EN' for English). If not specified, the document's original language influences the output.",
    ),
  };

• src/tools/summarizer.js:116-123 (registration)

  Tool registration configuration `summarizerToolConfig` with name 'kagi_summarizer', description, and inputSchema reference.

  export const summarizerToolConfig = {
    name: "kagi_summarizer",
    description: `
      Summarize content from a URL using the Kagi.com Summarizer API. The Summarizer can summarize any
      document type (text webpage, video, audio, etc.)
      `.replace(/\s+/gs, " ").trim(),
    inputSchema: summarizerInputSchema,
  };

• src/index.js:43-52 (registration)

  Registration of the summarizer tool in the MCP server via `this.server.registerTool()` with the name 'kagi_summarizer', title, description, inputSchema, and the handler callback that awaits `kagiSummarizer(args)`.

  // Register summarizer tool
  this.server.registerTool(
    summarizerToolConfig.name,
    {
      title: "Kagi Summarizer",
      description: summarizerToolConfig.description,
      inputSchema: summarizerToolConfig.inputSchema,
    },
    async (args) => await kagiSummarizer(args),
  );

• src/utils/formatting.js:78-86 (helper)

  Helper function `getEnvironmentConfig()` that resolves the Kagi session token via `resolveToken()` and reads the engine from the `KAGI_SUMMARIZER_ENGINE` environment variable.

  export function getEnvironmentConfig() {
    const token = resolveToken();
  
    // Note: kagi-ken might not support engine selection like the official API
    // We'll keep this for compatibility but may not use it
    const engine = process.env.KAGI_SUMMARIZER_ENGINE || "default";
  
    return { token, engine };
  }