Reactome MCP Server

Instructions

Implementation Reference

• src/index.ts:458-534 (handler)

  Main execution logic for the get_pathway_details tool: validates args, resolves pathway ID, fetches basic info and additional data (components, participants) from Reactome API, formats response.

  private async handleGetPathwayDetails(args: any) {
    if (!isValidIdArgs(args)) {
      throw new McpError(ErrorCode.InvalidParams, 'Pathway ID is required');
    }
  
    try {
      // Resolve pathway ID if it's a name
      const pathwayId = await this.resolvePathwayId(args.id);
      if (!pathwayId) {
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify({
                error: `No pathway found for identifier: ${args.id}`,
                suggestion: 'Try using a Reactome stable identifier (e.g., R-HSA-1640170) or search for the pathway first'
              }, null, 2),
            },
          ],
          isError: true,
        };
      }
  
      // Get basic pathway information
      const basicInfo = await this.apiClient.get(`/data/query/${pathwayId}`);
  
      // Try to get additional pathway data using alternative endpoints
      let components = null;
      let participants = null;
  
      try {
        // Try the events endpoint
        const eventsResponse = await this.apiClient.get(`/data/events/${pathwayId}`);
        components = eventsResponse.data;
      } catch (e) {
        // Ignore component fetch errors
      }
  
      try {
        // Try the participants endpoint with different format
        const participantsResponse = await this.apiClient.get(`/data/participants/${pathwayId}`);
        participants = participantsResponse.data;
      } catch (e) {
        // Ignore participants fetch errors
      }
  
      const pathwayDetails = {
        id: pathwayId,
        originalQuery: args.id,
        basicInfo: basicInfo.data,
        components: components || 'Components data not available via API',
        participants: participants || 'Participants data not available via API',
        url: `https://reactome.org/content/detail/${pathwayId}`,
        diagramUrl: `https://reactome.org/PathwayBrowser/#/${pathwayId}`,
        note: 'Some detailed information may not be available through the current API endpoints'
      };
  
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify(pathwayDetails, null, 2),
          },
        ],
      };
    } catch (error) {
      return {
        content: [
          {
            type: 'text',
            text: `Error getting pathway details: ${error instanceof Error ? error.message : 'Unknown error'}`,
          },
        ],
        isError: true,
      };
    }
  }

• src/index.ts:236-246 (registration)

  Tool registration in ListToolsRequestSchema response, including name, description, and input schema definition.

  {
    name: 'get_pathway_details',
    description: 'Get comprehensive information about a specific pathway',
    inputSchema: {
      type: 'object',
      properties: {
        id: { type: 'string', description: 'Reactome pathway stable identifier (e.g., R-HSA-68886)' },
      },
      required: ['id'],
    },
  },

• src/index.ts:239-245 (schema)

  Input schema definition for get_pathway_details tool: requires 'id' string parameter.

  inputSchema: {
    type: 'object',
    properties: {
      id: { type: 'string', description: 'Reactome pathway stable identifier (e.g., R-HSA-68886)' },
    },
    required: ['id'],
  },

• src/index.ts:428-455 (helper)

  Helper function called by handler to resolve pathway name/identifier to stable Reactome ID.

  private async resolvePathwayId(identifier: string): Promise<string | null> {
    // If it's already a stable identifier, return it
    if (identifier.match(/^R-[A-Z]{3}-\d+$/)) {
      return identifier;
    }
  
    // Search for the pathway by name
    try {
      const searchResponse = await this.apiClient.get('/search/query', {
        params: {
          query: identifier,
          types: 'Pathway',
          cluster: true
        }
      });
  
      if (searchResponse.data.results &&
          searchResponse.data.results.length > 0 &&
          searchResponse.data.results[0].entries &&
          searchResponse.data.results[0].entries.length > 0) {
        const resolvedId = searchResponse.data.results[0].entries[0].stId;
        return resolvedId;
      }
    } catch (error) {
      // Silently handle pathway resolution errors
    }
  
    return null;

• src/index.ts:40-46 (helper)

  Input validation helper for ID arguments, used in get_pathway_details handler.

  const isValidIdArgs = (args: any): args is { id: string } => {
    return (
      typeof args === 'object' &&
      args !== null &&
      typeof args.id === 'string' &&
      args.id.length > 0
    );