MCP WordPress Server

Instructions

Implementation Reference

• src/tools/seo/SEOToolDefinitions.ts:120-161 (schema)

  Defines the Tool object for 'wp_seo_generate_schema' including name, description, and input schema validation.

  export const generateSchemaTool: Tool = {
    name: "wp_seo_generate_schema",
    description: "Generate JSON-LD structured data schema for enhanced search results",
    inputSchema: {
      type: "object",
      properties: {
        postId: {
          type: "number",
          description: "WordPress post ID",
        },
        schemaType: {
          type: "string",
          enum: [
            "Article",
            "Product",
            "FAQ",
            "HowTo",
            "Organization",
            "Website",
            "BreadcrumbList",
            "Event",
            "Recipe",
            "Course",
            "LocalBusiness",
            "Person",
            "Review",
            "VideoObject",
          ],
          description: "Type of schema.org structured data to generate",
        },
        customData: {
          type: "object",
          description: "Additional custom data for the schema",
        },
        site: {
          type: "string",
          description: "Site identifier for multi-site setups",
        },
      },
      required: ["postId", "schemaType"],
    },
  };

• src/tools/seo/SEOHandlers.ts:110-130 (handler)

  MCP handler function that extracts parameters from args and delegates to SEOTools.generateSchema.

  export async function handleGenerateSchema(client: WordPressClient, args: Record<string, unknown>): Promise<unknown> {
    const logger = LoggerFactory.tool("wp_seo_generate_schema");
  
    try {
      const seoTools = getSEOToolsInstance();
      const params: SEOToolParams = {
        postId: args.postId as number,
        schemaType: args.schemaType as SchemaType,
        site: args.site as string,
      };
  
      // Add custom data if provided
      if (args.customData) {
        params.customData = args.customData;
      }
  
      return await seoTools.generateSchema(params);
    } catch (error) {
      logger.error("Failed to generate schema", { error, args });
      throw error;
    }

• src/tools/seo/SEOTools.ts:378-399 (registration)

  Maps tool name 'wp_seo_generate_schema' to its handler function handleGenerateSchema in getHandlerForTool method, used by getTools() for MCP registration.

  private getHandlerForTool(toolName: string): unknown {
    const handlers: Record<string, unknown> = {
      wp_seo_analyze_content: handleAnalyzeContent,
      wp_seo_generate_metadata: handleGenerateMetadata,
      wp_seo_bulk_update_metadata: handleBulkUpdateMetadata,
      wp_seo_generate_schema: handleGenerateSchema,
      wp_seo_validate_schema: handleValidateSchema,
      wp_seo_suggest_internal_links: handleSuggestInternalLinks,
      wp_seo_site_audit: handlePerformSiteAudit,
      wp_seo_track_serp: handleTrackSERPPositions,
      wp_seo_keyword_research: handleKeywordResearch,
      wp_seo_test_integration: handleTestSEOIntegration,
      wp_seo_get_live_data: handleGetLiveSEOData,
    };
  
    return (
      handlers[toolName] ||
      (() => {
        throw new Error(`Unknown SEO tool: ${toolName}`);
      })
    );
  }

• src/tools/seo/SEOTools.ts:217-248 (handler)

  Core business logic for generating schema: handles caching, fetches post, calls SchemaGenerator via createSchema.

  async generateSchema(params: SEOToolParams): Promise<SchemaMarkup> {
    const siteLogger = LoggerFactory.tool("wp_seo_generate_schema", params.site);
  
    return await siteLogger.time("Generate schema markup", async () => {
      try {
        validateRequired(params, ["postId", "schemaType"]);
        const client = this.getSiteClient(params.site);
  
        // Check cache
        const cacheKey = `seo:schema:${params.site}:${params.postId as number}:${params.schemaType}`;
        const cached = await this.getCachedResult(cacheKey);
        if (cached) {
          return cached as SchemaMarkup;
        }
  
        // Generate schema (implementation in generators)
        const schema = await this.createSchema(client, params);
  
        // Cache for 24 hours
        await this.cacheResult(cacheKey, schema, 86400);
  
        return schema;
      } catch (_error) {
        handleToolError(_error, "generate schema", {
          site: params.site,
          postId: params.postId as number,
          schemaType: params.schemaType,
        });
        throw _error;
      }
    });
  }

• src/tools/seo/generators/SchemaGenerator.ts:151-214 (handler)

  Exact implementation: Generates JSON-LD schema markup based on schemaType using switch statement dispatching to type-specific generators and content extraction helpers.

  async generateSchema(post: WordPressPost, params: SEOToolParams, options: SchemaOptions = {}): Promise<SchemaMarkup> {
    this.logger.debug("Generating schema markup", {
      postId: post.id,
      schemaType: params.schemaType,
      title: post.title?.rendered?.substring(0, 50),
    });
  
    if (!params.schemaType) {
      throw new Error("Schema type is required for schema generation");
    }
  
    const baseSchema: SchemaMarkup = {
      "@context": "https://schema.org",
      "@type": params.schemaType,
    };
  
    // Generate schema based on type
    switch (params.schemaType) {
      case "Article":
        return this.generateArticleSchema(post, baseSchema, options);
  
      case "Product":
        return this.generateProductSchema(post, baseSchema, options);
  
      case "FAQ":
        return this.generateFAQSchema(post, baseSchema, options);
  
      case "HowTo":
        return this.generateHowToSchema(post, baseSchema, options);
  
      case "Organization":
        return this.generateOrganizationSchema(post, baseSchema, options);
  
      case "LocalBusiness":
        return this.generateLocalBusinessSchema(post, baseSchema, options);
  
      case "Website":
        return this.generateWebsiteSchema(post, baseSchema, options);
  
      case "BreadcrumbList":
        return this.generateBreadcrumbSchema(post, baseSchema, options);
  
      case "Event":
        return this.generateEventSchema(post, baseSchema, options);
  
      case "Recipe":
        return this.generateRecipeSchema(post, baseSchema, options);
  
      case "Course":
        return this.generateCourseSchema(post, baseSchema, options);
  
      case "VideoObject":
        return this.generateVideoSchema(post, baseSchema, options);
  
      case "Person":
        return this.generatePersonSchema(post, baseSchema, options);
  
      case "Review":
        return this.generateReviewSchema(post, baseSchema, options);
  
      default:
        throw new Error(`Unsupported schema type: ${params.schemaType}`);
    }
  }