Add lookup MCP tool

Author: dimitrov-d

src/mcp-server.ts

@@ -11,6 +11,7 @@ import pkg from '../package.json';
 import { initializePaymentMiddleware, PAYWALLED_TOOLS } from './lib/x402';
 import { analyzeHandler, analyzeTool } from './tools/analyze';
 import { fetchHandler, fetchTool } from './tools/fetch';
+import { lookupHandler, lookupTool } from './tools/lookup';
 import { notesHandler, notesTool } from './tools/notes';
 import { publishHandler, publishTool } from './tools/publish';
 import { queryHandler, queryTool } from './tools/query';
@@ -31,16 +32,12 @@ const registerWorkflowTools = (
   const register = server.registerTool.bind(server);
 
   register('fetch', fetchTool, async (input) => await fetchHandler(input));
-
   register('analyze', analyzeTool, async (input) => await analyzeHandler(input, logger));
-
   register('notes', notesTool, async (input) => await notesHandler(input));
-
   register('publish', publishTool, async (input) => await publishHandler(input));
-
   register('query', queryTool, async (input) => await queryHandler(input));
-
   register('show', showTool, async (input) => await showHandler(input));
+  register('lookup', lookupTool, async (input) => await lookupHandler(input));
 };
 
 const PORT = Number(process.env.GWALN_MCP_PORT ?? process.env.PORT ?? 3233);

src/tools/lookup.ts

@@ -0,0 +1,127 @@
+/**
+ * @file src/tools/lookup.ts
+ * @description MCP tool for looking up topics in the catalog and searching APIs.
+ */
+
+import { z } from 'zod';
+import { addTopicToCatalog, runLookupWorkflow } from '../workflows/lookup-workflow';
+import { textContent } from './utils';
+
+export const LookupInputSchema = z
+  .object({
+    query: z.string(),
+    searchApis: z.boolean().optional(),
+    limit: z.number().min(1).max(20).optional(),
+    action: z.enum(['search', 'add']).optional(),
+    title: z.string().optional(),
+    wikipediaSlug: z.string().optional(),
+    grokipediaSlug: z.string().optional(),
+  })
+  .refine(
+    (value) => {
+      if (value.action === 'add') {
+        return Boolean(value.title && value.wikipediaSlug && value.grokipediaSlug);
+      }
+      return true;
+    },
+    {
+      message: 'When action is "add", title, wikipediaSlug, and grokipediaSlug are required.',
+      path: ['action'],
+    },
+  );
+
+export const lookupTool = {
+  title: 'Lookup topics',
+  description:
+    'Searches for topics in the local catalog and optionally searches Grokipedia and Wikipedia APIs. Can also add topics to the catalog.',
+  inputSchema: LookupInputSchema,
+};
+
+const normalizeGrokSlug = (slug: string): string => {
+  if (!slug.startsWith('page/')) {
+    return `page/${slug}`;
+  }
+  return slug;
+};
+
+export const lookupHandler = async (input: z.infer<typeof LookupInputSchema>) => {
+  const { query, searchApis = false, limit = 5, action = 'search' } = input;
+
+  if (action === 'add') {
+    if (!input.title || !input.wikipediaSlug || !input.grokipediaSlug) {
+      throw new Error(
+        'Missing required fields for adding topic: title, wikipediaSlug, grokipediaSlug',
+      );
+    }
+
+    const grokSlug = normalizeGrokSlug(input.grokipediaSlug);
+    const newTopic = addTopicToCatalog({
+      title: input.title,
+      wikipediaSlug: input.wikipediaSlug,
+      grokipediaSlug: grokSlug,
+    });
+
+    return {
+      content: textContent(
+        `[lookup] Added topic "${newTopic.title}" to catalog (ID: ${newTopic.id})`,
+      ),
+      structuredContent: {
+        action: 'add',
+        topic: newTopic,
+      },
+    };
+  }
+
+  // Search action
+  const result = await runLookupWorkflow({
+    query,
+    searchApis: searchApis ?? false,
+    limit,
+  });
+
+  if (result.found && result.topic) {
+    return {
+      content: textContent(
+        `[lookup] Found topic "${result.topic.title}" in local catalog (ID: ${result.topic.id})`,
+      ),
+      structuredContent: {
+        action: 'search',
+        found: true,
+        topic: result.topic,
+        searchResults: null,
+      },
+    };
+  }
+
+  if (result.searchResults) {
+    const { grokipedia, wikipedia } = result.searchResults;
+    const hasResults = grokipedia.length > 0 || wikipedia.length > 0;
+
+    return {
+      content: textContent(
+        hasResults
+          ? `[lookup] Found ${grokipedia.length} Grokipedia and ${wikipedia.length} Wikipedia results for "${query}"`
+          : `[lookup] No results found for "${query}"`,
+      ),
+      structuredContent: {
+        action: 'search',
+        found: false,
+        topic: null,
+        searchResults: {
+          grokipedia,
+          wikipedia,
+        },
+      },
+    };
+  }
+
+  return {
+    content: textContent(`[lookup] Topic "${query}" not found in local catalog`),
+    structuredContent: {
+      action: 'search',
+      found: false,
+      topic: null,
+      searchResults: null,
+    },
+  };
+};