Search Papers by Venue

Instructions

Implementation Reference

• src/index.ts:74-110 (registration)

  Full registration of the MCP tool 'search_papers_by_venue', including input schema (Zod validation) and inline handler function that delegates to AminerClient.

  server.registerTool(
    "search_papers_by_venue",
    {
      title: "Search Papers by Venue",
      description: "Search papers published in a specific venue/journal",
      inputSchema: {
        venue: z.string().describe("Venue/journal name"),
        page: z.number().min(0).default(0).describe("Page number, starting from 0"),
        size: z.number().min(1).max(10).default(10).describe("Number of papers per page, maximum 10"),
        order: z.enum(["year", "n_citation"]).optional().describe("Sort order: year (by publication year) or n_citation (by citation count)")
      }
    },
    async ({ venue, page, size, order }) => {
      try {
        const result = await aminerClient.searchByVenue(venue, page, size, order);
        const formattedResult = aminerClient.formatSearchResults(result);
        
        return {
          content: [{
            type: "text",
            text: JSON.stringify(formattedResult, null, 2)
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: "text",
            text: JSON.stringify({
              error: "Search failed",
              message: error instanceof Error ? error.message : 'Unknown error'
            }, null, 2)
          }],
          isError: true
        };
      }
    }
  );

• src/index.ts:86-109 (handler)

  The MCP tool handler function: extracts parameters, calls AminerClient.searchByVenue, formats results with formatSearchResults, returns JSON or error.

  async ({ venue, page, size, order }) => {
    try {
      const result = await aminerClient.searchByVenue(venue, page, size, order);
      const formattedResult = aminerClient.formatSearchResults(result);
      
      return {
        content: [{
          type: "text",
          text: JSON.stringify(formattedResult, null, 2)
        }]
      };
    } catch (error) {
      return {
        content: [{
          type: "text",
          text: JSON.stringify({
            error: "Search failed",
            message: error instanceof Error ? error.message : 'Unknown error'
          }, null, 2)
        }],
        isError: true
      };
    }
  }

• src/index.ts:79-84 (schema)

  Zod input schema defining validation for tool parameters: venue (required string), page/size (numbers), order (enum).

  inputSchema: {
    venue: z.string().describe("Venue/journal name"),
    page: z.number().min(0).default(0).describe("Page number, starting from 0"),
    size: z.number().min(1).max(10).default(10).describe("Number of papers per page, maximum 10"),
    order: z.enum(["year", "n_citation"]).optional().describe("Sort order: year (by publication year) or n_citation (by citation count)")
  }

• src/aminer-client.ts:106-108 (helper)

  AminerClient.searchByVenue method: wrapper that calls the core searchPapers with venue parameter.

  async searchByVenue(venue: string, page = 0, size = 10, order?: 'year' | 'n_citation'): Promise<SearchResult> {
    return this.searchPapers({ venue, page, size, order });
  }

• src/aminer-client.ts:27-94 (helper)

  Core searchPapers helper: builds query params including venue, makes authenticated GET request to AMiner API, processes response into SearchResult.

  async searchPapers(params: SearchParams): Promise<SearchResult> {
    // Validate required parameters
    if (!params.keyword && !params.venue && !params.author) {
      throw new Error('At least one of keyword, venue, or author must be provided');
    }
  
    if (params.size > 10) {
      throw new Error('Size parameter cannot exceed 10');
    }
  
    // Build query parameters
    const searchParams = new URLSearchParams();
    if (params.keyword) searchParams.append('keyword', params.keyword);
    if (params.venue) searchParams.append('venue', params.venue);
    if (params.author) searchParams.append('author', params.author);
    searchParams.append('page', params.page.toString());
    searchParams.append('size', params.size.toString());
    if (params.order) searchParams.append('order', params.order);
  
    const url = `${this.config.baseUrl}?${searchParams.toString()}`;
  
    try {
      const response = await fetch(url, {
        method: 'GET',
        headers: {
          'Authorization': this.config.apiKey,
          'Content-Type': 'application/json',
        },
      });
  
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }
  
      const data = await response.json() as AminerSearchResponse;
  
      // Add detailed response data check
      if (!data) {
        throw new Error('API returned empty response');
      }
  
      if (!data.success) {
        throw new Error(`API Error (${data.code}): ${data.msg}`);
      }
  
      // Check the completeness of the response data
      if (typeof data.total !== 'number') {
        console.warn('API response missing or invalid total field, defaulting to 0');
      }
  
      // Ensure data.data is not null, if it is null, use an empty array
      const papers = data.data || [];
      const total = data.total || 0;
  
      return {
        papers,
        total,
        page: params.page,
        size: params.size,
        hasMore: (params.page + 1) * params.size < total,
      };
    } catch (error) {
      if (error instanceof Error) {
        throw new Error(`Failed to search papers: ${error.message}`);
      }
      throw new Error('Unknown error occurred while searching papers');
    }
  }