project_info

Instructions

Implementation Reference

• src/services/project.service.ts:44-81 (handler)

  The getProject method in ProjectService is the actual handler that executes the tool logic. It fetches project details from the Railway API, formats environments/services info, and returns a success response with formatted text and raw data.

    async getProject(projectId: string): Promise<CallToolResult> {
      try {
        const project = await this.client.projects.getProject(projectId);
  
        if (!project) {
          return createErrorResponse("Project not found.");
        }
  
        const environments = project.environments?.edges?.map(edge => edge.node) || [];
        const services = project.services?.edges?.map(edge => edge.node) || [];
  
        const environmentList = environments.map(env => 
          `  🌍 ${env.name} (ID: ${env.id})`
        ).join('\n');
  
        const serviceList = services.map(svc =>
          `  🚀 ${svc.name} (ID: ${svc.id})`
        ).join('\n');
  
        const info = `📁 Project: ${project.name} (ID: ${project.id})
  Description: ${project.description || 'No description'}
  Created: ${new Date(project.createdAt).toLocaleString()}
  Subscription: ${project.subscriptionType || 'Free'}
  
  Environments:
  ${environmentList || '  No environments'}
  
  Services:
  ${serviceList || '  No services'}`;
  
        return createSuccessResponse({
          text: info,
          data: { project, environments, services }
        });
      } catch (error) {
        return createErrorResponse(`Error getting project details: ${formatError(error)}`);
      }
    }

• src/tools/project.tool.ts:44-45 (schema)

  The input schema for project_info: requires a 'projectId' string parameter describing the project ID to get information about.

    projectId: z.string().describe("ID of the project to get information about")
  },

• src/tools/project.tool.ts:27-49 (registration)

  The tool registration for 'project_info' using createTool with the name, formatted description, Zod schema, and async handler that calls projectService.getProject().

  createTool(
    "project_info",
    formatToolDescription({
      type: 'API',
      description: "Get detailed information about a specific Railway project",
      bestFor: [
        "Viewing project details and status",
        "Checking environments and services",
        "Project configuration review"
      ],
      relations: {
        prerequisites: ["project_list"],
        nextSteps: ["service_list", "variable_list"],
        related: ["project_update", "project_delete"]
      }
    }),
    {
      projectId: z.string().describe("ID of the project to get information about")
    },
    async ({ projectId }) => {
      return projectService.getProject(projectId);
    }
  ),

• src/tools/index.ts:16-37 (registration)

  The registerAllTools function iterates all tools (including projectTools) and registers them with the MCP server via server.tool().

  export function registerAllTools(server: McpServer) {
    // Collect all tools
    const allTools = [
      ...databaseTools,
      ...deploymentTools,
      ...domainTools,
      ...projectTools,
      ...serviceTools,
      ...tcpProxyTools,
      ...variableTools,
      ...configTools,
      ...volumeTools,
      ...templateTools,
    ] as Tool[];
  
    // Register each tool with the server
    allTools.forEach((tool) => {
      server.tool(
        ...tool
      );
    });
  } 

• src/utils/tools.ts:33-80 (helper)

  The formatToolDescription helper used to generate the human-readable description string for the tool, including type, best for, relations (prerequisites, next steps, related).

  export const formatToolDescription = ({
    type,
    description,
    bestFor = [],
    notFor = [],
    relations = {},
  }: {
    type: ToolType;
    description: string;
    bestFor?: string[];
    notFor?: string[];
    relations?: ToolRelations;
  }) => {
    const sections = [
      `[${type}] ${description}`,
      
      // Best For section
      bestFor.length > 0 && [
        '⚡️ Best for:',
        ...bestFor.map(b => `  ✓ ${b}`)
      ].join('\n'),
      
      // Not For section
      notFor.length > 0 && [
        '⚠️ Not for:',
        ...notFor.map(n => `  × ${n}`)
      ].join('\n'),
      
      // Prerequisites section
      relations?.prerequisites?.length! > 0 &&
        `→ Prerequisites: ${relations?.prerequisites?.join(', ')}`,
      
      // Alternatives section
      relations?.alternatives?.length! > 0 &&
        `→ Alternatives: ${relations?.alternatives?.join(', ')}`,
      
      // Next Steps section
      relations?.nextSteps?.length! > 0 &&
        `→ Next steps: ${relations?.nextSteps?.join(', ')}`,
      
      // Related section
      relations?.related?.length! > 0 &&
        `→ Related: ${relations?.related?.join(', ')}`
    ];
  
    // Filter out falsy values and join with newlines
    return sections.filter(Boolean).join('\n\n');
  };