Jina AI Remote MCP Server

Instructions

Implementation Reference

• src/utils/search.ts:137-166 (handler)

  Core handler function that executes the SSRN search by making an API call to Jina AI's search endpoint with domain 'ssrn'.

  export async function executeSsrnSearch(
      searchArgs: SearchSsrnArgs,
      bearerToken: string
  ): Promise<SearchResultOrError> {
      try {
          const response = await fetch('https://svip.jina.ai/', {
              method: 'POST',
              headers: {
                  'Accept': 'application/json',
                  'Content-Type': 'application/json',
                  'Authorization': `Bearer ${bearerToken}`,
              },
              body: JSON.stringify({
                  q: searchArgs.query,
                  domain: 'ssrn',
                  num: searchArgs.num || 30,
                  ...(searchArgs.tbs && { tbs: searchArgs.tbs })
              }),
          });
  
          if (!response.ok) {
              return { error: `SSRN search failed for query "${searchArgs.query}": ${response.statusText}` };
          }
  
          const data = await response.json() as any;
          return { query: searchArgs.query, results: data.results || [] };
      } catch (error) {
          return { error: `SSRN search failed for query "${searchArgs.query}": ${error instanceof Error ? error.message : String(error)}` };
      }
  }

• src/utils/search.ts:22-26 (schema)

  TypeScript interface defining the input schema for search_ssrn tool arguments.

  export interface SearchSsrnArgs {
      query: string;
      num?: number;
      tbs?: string;
  }

• src/tools/jina-tools.ts:437-490 (registration)

  MCP tool registration for 'search_ssrn', including Zod input schema validation, tool description, and async handler that supports single or parallel queries via executeSsrnSearch.

  if (isToolEnabled("search_ssrn")) {
  	server.tool(
  		"search_ssrn",
  		"Search academic papers and preprints on SSRN (Social Science Research Network). Perfect for finding research papers in social sciences, economics, law, finance, accounting, management, and humanities. Use this when researching social science topics, looking for working papers, or finding the latest research in business and economics fields.",
  		{
  			query: z.union([z.string(), z.array(z.string())]).describe("Academic search terms, author names, or research topics (e.g., 'corporate governance', 'behavioral finance', 'contract law'). Can be a single query string or an array of queries for parallel search."),
  			num: z.number().default(30).describe("Maximum number of academic papers to return, between 1-100"),
  			tbs: z.string().optional().describe("Time-based search parameter, e.g., 'qdr:h' for past hour, can be qdr:h, qdr:d, qdr:w, qdr:m, qdr:y")
  		},
  		async ({ query, num, tbs }: { query: string | string[]; num: number; tbs?: string }) => {
  			try {
  				const props = getProps();
  
  				const tokenError = checkBearerToken(props.bearerToken);
  				if (tokenError) {
  					return tokenError;
  				}
  
  				// Handle single query or single-element array
  				if (typeof query === 'string' || (Array.isArray(query) && query.length === 1)) {
  					const singleQuery = typeof query === 'string' ? query : query[0];
  					const searchResult = await executeSsrnSearch({ query: singleQuery, num, tbs }, props.bearerToken);
  
  					return {
  						content: formatSingleSearchResultToContentItems(searchResult),
  					};
  				}
  
  				// Handle multiple queries with parallel search
  				if (Array.isArray(query) && query.length > 1) {
  					const searches = query.map(q => ({ query: q, num, tbs }));
  
  					const uniqueSearches = searches.filter((search, index, self) =>
  						index === self.findIndex(s => s.query === search.query)
  					);
  
  					const ssrnSearchFunction = async (searchArgs: SearchSsrnArgs) => {
  						return executeSsrnSearch(searchArgs, props.bearerToken);
  					};
  
  					const results = await executeParallelSearches(uniqueSearches, ssrnSearchFunction, { timeout: 30000 });
  
  					return {
  						content: formatParallelSearchResultsToContentItems(results),
  					};
  				}
  
  				return createErrorResponse("Invalid query format");
  			} catch (error) {
  				return createErrorResponse(`Error: ${error instanceof Error ? error.message : String(error)}`);
  			}
  		},
  	);
  }