Paper Search MCP

Instructions

Implementation Reference

• src/mcp/handleToolCall.ts:325-345 (handler)

  The handler function for the 'search_sciencedirect' tool. It validates the Elsevier API key, calls the ScienceDirect searcher's search method with provided parameters, and returns a formatted JSON response with search results.

  case 'search_sciencedirect': {
    const { query, maxResults, year, author, journal, openAccess } = args;
    if (!process.env.ELSEVIER_API_KEY) {
      throw new Error('Elsevier API key not configured. Please set ELSEVIER_API_KEY environment variable.');
    }
    const results = await searchers.sciencedirect.search(query, {
      maxResults,
      year,
      author,
      journal,
      openAccess
    });
  
    return jsonTextResponse(
      `Found ${results.length} ScienceDirect papers.\n\n${JSON.stringify(
        results.map((paper: Paper) => PaperFactory.toDict(paper)),
        null,
        2
      )}`
    );
  }

• src/mcp/schemas.ts:148-157 (schema)

  Zod schema definition for validating input arguments to the search_sciencedirect tool.

  export const SearchScienceDirectSchema = z
    .object({
      query: z.string().min(1),
      maxResults: z.number().int().min(1).max(100).optional().default(10),
      year: z.string().optional(),
      author: z.string().optional(),
      journal: z.string().optional(),
      openAccess: z.boolean().optional()
    })
    .strip();

• src/mcp/tools.ts:367-389 (registration)

  Tool registration entry in the tools array, defining name, description, and input schema for the MCP tool.

    name: 'search_sciencedirect',
    description: 'Search academic papers from Elsevier ScienceDirect database (requires API key)',
    inputSchema: {
      type: 'object',
      properties: {
        query: { type: 'string', description: 'Search query string' },
        maxResults: {
          type: 'number',
          minimum: 1,
          maximum: 100,
          description: 'Maximum number of results to return'
        },
        year: { type: 'string', description: 'Year filter (e.g., "2023", "2020-2023")' },
        author: { type: 'string', description: 'Author name filter' },
        journal: { type: 'string', description: 'Journal name filter' },
        openAccess: {
          type: 'boolean',
          description: 'Filter for open access articles only'
        }
      },
      required: ['query']
    }
  },

• src/platforms/ScienceDirectSearcher.ts:104-168 (helper)

  Core implementation of the search functionality in ScienceDirectSearcher class, handling API requests to Elsevier's ScienceDirect, parsing responses, and creating Paper objects.

  async search(query: string, options: SearchOptions = {}): Promise<Paper[]> {
    const customOptions = options as any;
    if (!this.apiKey) {
      throw new Error('ScienceDirect API key is required');
    }
  
    const maxResults = Math.min(options.maxResults || 10, 100);
    const papers: Paper[] = [];
  
    try {
      // Use PUT method with new API format (matching Python implementation)
      const requestBody: any = {
        qs: query
      };
  
      // Add year filter
      if (options.year) {
        if (options.year.includes('-')) {
          const [startYear, endYear] = options.year.split('-');
          requestBody.date = endYear ? `${startYear}-${endYear}` : startYear;
        } else {
          requestBody.date = options.year;
        }
      }
  
      // Add author filter
      if (options.author) {
        requestBody.authors = options.author;
      }
  
      // Display options
      requestBody.display = {
        offset: 0,
        show: maxResults,
        sortBy: options.sortBy === 'date' ? 'date' : 'relevance'
      };
  
      await this.rateLimiter.waitForPermission();
  
      const response = await this.client.put('/content/search/sciencedirect', requestBody, {
        headers: {
          'Content-Type': 'application/json'
        }
      });
  
      const results = response.data?.results || [];
  
      for (const result of results) {
        const paper = this.parseNewApiResult(result);
        if (paper) {
          papers.push(paper);
        }
      }
  
      // Enrich with abstracts if requested
      if (customOptions.includeAbstract && papers.length > 0) {
        const enrichedPapers = await this.enrichPapersWithAbstracts(papers);
        return enrichedPapers;
      }
  
      return papers;
    } catch (error: any) {
      this.handleHttpError(error, 'search');
    }
  }

• src/mcp/searchers.ts:51-80 (registration)

  Instantiation and registration of the ScienceDirectSearcher instance in the global searchers object, using the ELSEVIER_API_KEY environment variable.

  const scienceDirectSearcher = new ScienceDirectSearcher(process.env.ELSEVIER_API_KEY);
  const springerSearcher = new SpringerSearcher(
    process.env.SPRINGER_API_KEY,
    process.env.SPRINGER_OPENACCESS_API_KEY
  );
  const wileySearcher = new WileySearcher(process.env.WILEY_TDM_TOKEN);
  const scopusSearcher = new ScopusSearcher(process.env.ELSEVIER_API_KEY);
  const crossrefSearcher = new CrossrefSearcher(process.env.CROSSREF_MAILTO);
  
  searchers = {
    arxiv: arxivSearcher,
    webofscience: wosSearcher,
    pubmed: pubmedSearcher,
    wos: wosSearcher,
    biorxiv: biorxivSearcher,
    medrxiv: medrxivSearcher,
    semantic: semanticSearcher,
    iacr: iacrSearcher,
    googlescholar: googleScholarSearcher,
    scholar: googleScholarSearcher,
    scihub: sciHubSearcher,
    sciencedirect: scienceDirectSearcher,
    springer: springerSearcher,
    wiley: wileySearcher,
    scopus: scopusSearcher,
    crossref: crossrefSearcher
  };
  
  logDebug('Searchers initialized successfully');
  return searchers;