The schema-gen-mcp server enables AI assistants to generate and validate Schema.org JSON-LD structured data markup for SEO optimization.
Generate structured data for 12 Schema.org types: Create JSON-LD markup for Person, Organization, Product, FAQPage, Article, LocalBusiness, Event, WebSite, BreadcrumbList, HowTo, Review, and VideoObject by providing a type and key-value field pairs
List supported schema types: Retrieve all supported schema types with their available fields and descriptions
Quickly generate common schemas:
Person — name, job title, email, image, social profiles, organization, birth date, nationality
Product — pricing, currency, brand, SKU, availability, image, description
FAQPage — from an array of question-and-answer pairs
Article — headline, author, publisher, publication/modified date
Organization — name, URL, logo, founder, founding date, description, social profiles
Validate existing JSON-LD: Check markup for errors, missing required fields, improper @context, invalid @type, and other common issues
Google Rich Results compatibility: Output validated against Google's structured data requirements for rich snippets
Generates Schema.org JSON-LD structured data markup that is validated against Google's structured data requirements to support Rich Results such as Knowledge Panels, FAQ results, and Product snippets.
:sparkles: 12 Schema Types — Person, Organization, Product, FAQ, Article, LocalBusiness, Event, WebSite, BreadcrumbList, HowTo, Review, VideoObject
:eyes: Live JSON-LD Preview — See your structured data rendered in real-time as you fill in fields
:clipboard: One-Click Copy — Copy generated JSON-LD to clipboard instantly
:white_check_mark: Google Rich Results Ready — Output is validated against Google's structured data requirements
:robot: MCP Server — Use with Claude Desktop, Cursor, or any MCP-compatible AI assistant
:shield: Schema Validation — Validate existing JSON-LD for errors and warnings
:zap: No Dependencies — Clean, standalone web app with zero external runtime dependencies
Related MCP server: indexnow-mcp
Type | Description | Google Rich Result |
Person | People, professionals, public figures | :white_check_mark: Knowledge Panel |
Organization | Companies, non-profits, institutions | :white_check_mark: Logo, Knowledge Panel |
Product | Products with pricing and reviews | :white_check_mark: Product Rich Snippet |
FAQPage | Frequently asked questions | :white_check_mark: FAQ Rich Result |
Article | Blog posts, news articles | :white_check_mark: Article Rich Result |
LocalBusiness | Physical stores, restaurants, services | :white_check_mark: Local Business Panel |
Event | Concerts, conferences, meetups | :white_check_mark: Event Rich Result |
WebSite | Websites with search functionality | :white_check_mark: Sitelinks Search Box |
BreadcrumbList | Navigation breadcrumb trails | :white_check_mark: Breadcrumb Rich Result |
HowTo | Step-by-step instructions | :white_check_mark: How-to Rich Result |
Review | Product or service reviews | :white_check_mark: Review Snippet |
VideoObject | Videos with metadata | :white_check_mark: Video Rich Result |
Screenshots coming soon.
# Clone the repository
git clone https://github.com/sharozdawa/schema-gen.git
cd schema-gen
# Install dependencies
npm install
# Start the development server
npm run devOpen http://localhost:3000 in your browser.
The MCP server lets AI assistants generate Schema.org markup directly. Install it in your preferred AI tool:
Add to your claude_desktop_config.json:
{
"mcpServers": {
"schema-gen": {
"command": "npx",
"args": ["-y", "schema-gen-mcp"]
}
}
}Add to .cursor/mcp.json:
{
"mcpServers": {
"schema-gen": {
"command": "npx",
"args": ["-y", "schema-gen-mcp"]
}
}
}Tool | Description |
| Generate JSON-LD for any of the 12 schema types |
| List all supported types with their fields |
| Quick Person schema generation |
| Quick Product schema with pricing |
| Quick FAQ schema from Q&A pairs |
| Quick Article schema for blog posts |
| Quick Organization schema |
| Validate existing JSON-LD markup |
{
"@context": "https://schema.org",
"@type": "Person",
"name": "Jane Doe",
"jobTitle": "Software Engineer",
"url": "https://janedoe.com",
"worksFor": {
"@type": "Organization",
"name": "Acme Corp"
},
"sameAs": [
"https://twitter.com/janedoe",
"https://linkedin.com/in/janedoe"
]
}Feature | schema-gen | TechnicalSEO.com | Merkle Schema Generator |
Schema types | 12 | 8 | 6 |
Live preview | Yes | Yes | No |
MCP Server | Yes | No | No |
Self-hostable | Yes | No | No |
Open source | Yes | No | No |
Price | Free | Free | Free |
Tool | Description |
Curated list of SEO MCP servers and agent skills | |
Visual robots.txt manager for AI crawlers | |
Instant URL indexing via IndexNow | |
AI brand visibility tracker |
MIT
Generate an Article JSON-LD schema for blog posts, news articles, or other written content.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | URL of the article | |
| image | No | Article image URL | |
| author | No | Author name | |
| headline | Yes | Title of the article | |
| publisher | No | Publisher organization name | |
| description | No | Article summary or excerpt | |
| dateModified | No | Last modified date (ISO 8601 format) | |
| datePublished | No | Publication date (ISO 8601 format) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It fails to disclose what the tool returns (e.g., a JSON-LD string or object), whether it is read-only, or any prerequisites. Only states the action without behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence front-loading the main purpose. No unnecessary words; every word contributes to clarity. Highly effective for quick understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple nature of the tool and complete input schema, the description is adequate but lacks explanation of output format or how to use the generated schema. No annotations to fill gaps. Misses opportunity to fully inform the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with each parameter described. Description adds no additional meaning beyond the schema, so baseline of 3 is appropriate. There is no elaboration on parameter relationships or usage context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool generates an Article JSON-LD schema for blog posts, news articles, or other written content. The verb 'Generate' and resource 'Article JSON-LD schema' are specific, and the scope differentiates it from siblings like generate_faq_schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for articles by specifying content types. While it doesn't explicitly say when not to use it or direct to alternatives, the sibling tool names and the description make the intended use clear. Slight lack of explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a FAQPage JSON-LD schema from a list of question-answer pairs.
| Name | Required | Description | Default |
|---|---|---|---|
| questions | Yes | Array of question-answer pairs |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, and the description does not disclose behavioral traits such as side effects, permissions, rate limits, or output format. Since there is no output schema, the description could have explained what the generated schema looks like.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, straightforward sentence with no unnecessary words. It is efficiently front-loaded with the key action and result.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (one parameter), but the description lacks explanation of the output or any constraints. Given no output schema, more detail would improve completeness. Still, it is minimally adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%; the input schema already describes the 'questions' parameter and its items. The description does not add additional meaning beyond the schema, so baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Generate'), the resource ('FAQPage JSON-LD schema'), and the input ('list of question-answer pairs'). It is distinct from sibling tools which generate other schema types or validate/list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives (e.g., other generate_* tools) or when not to use it. The description only states the function without context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate an Organization JSON-LD schema for companies, non-profits, or other organizations.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | Official website URL | |
| logo | No | Logo image URL | |
| name | Yes | Organization name | |
| sameAs | No | Array of social profile URLs | |
| founder | No | Founder name | |
| description | No | Brief description of the organization | |
| foundingDate | No | Founding date (YYYY-MM-DD) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It only states the purpose without disclosing any behavioral traits such as validation, side effects, or output format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that front-loads the purpose without any extraneous content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 7 parameters, no output schema, and no annotations, the description is minimal. It adequately states the tool's function but lacks detail on output format or usage context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so all 7 parameters are described in the input schema. The description adds no additional meaning beyond the schema, meeting the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Generate', the resource 'Organization JSON-LD schema', and the target audience 'companies, non-profits, or other organizations'. It distinguishes from sibling tools like 'generate_person_schema' and 'generate_product_schema'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. The sibling tool list is external but not referenced in the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a Person JSON-LD schema with common fields like name, job title, social profiles, and more.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | Personal website or profile URL | |
| name | Yes | Full name of the person | |
| No | Email address | ||
| image | No | URL to an image of the person | |
| sameAs | No | Array of social profile URLs (LinkedIn, Twitter, etc.) | |
| jobTitle | No | Job title or role | |
| worksFor | No | Organization name | |
| birthDate | No | Date of birth (YYYY-MM-DD) | |
| description | No | Short bio or description | |
| nationality | No | Nationality |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. The description indicates a generative action with no hints of side effects, but it does not specify if the output is a schema definition or an instance, nor any authentication or rate-limiting details. It adds some value by listing common fields.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence of 16 words, conveying the essential idea without any redundant information. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 10 parameters and no output schema, the description does not clarify the output format (e.g., JSON-LD schema vs. instance) or provide usage context. The schema coverage compensates partially, but additional detail on return value would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema already documents all parameters. The description merely restates 'common fields like name, job title, social profiles, and more', adding no deeper semantic meaning beyond what the schema provides. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool generates a 'Person JSON-LD schema', specifying the verb and resource. It distinguishes from sibling tools like 'generate_organization_schema' by focusing on person-specific fields.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for creating a person schema but does not provide explicit guidance on when to use it versus alternatives like 'generate_organization_schema'. No when-not-to-use or exclusion criteria are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a Product JSON-LD schema with pricing, brand, availability, and other product details.
| Name | Required | Description | Default |
|---|---|---|---|
| sku | No | Stock Keeping Unit identifier | |
| url | No | Product page URL | |
| name | Yes | Product name | |
| brand | No | Brand name | |
| image | No | Product image URL | |
| price | No | Price of the product | |
| description | No | Product description | |
| availability | No | Product availability status | |
| priceCurrency | No | Currency code (e.g., USD, EUR, GBP) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It only states the output type (JSON-LD schema) but lacks details on side effects, required permissions, output format, or whether it validates or generates a file.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that conveys the purpose efficiently. However, it could include a bit more structure, such as listing key parameters, without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having 9 parameters and no output schema, the description provides minimal context. It does not explain the tool's return value, usage scope, or how it integrates with other schema tools, making it insufficiently complete given the complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage, the baseline is 3. The description mentions pricing, brand, and availability, but these are already evident from parameter names and schema descriptions; no additional meaning is added.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool generates a Product JSON-LD schema, specifying details like pricing, brand, availability, which distinguishes it from sibling tools like generate_article_schema or generate_faq_schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for product schemas but does not explicitly state when to prefer this over the generic generate_schema tool or provide exclusions for other product-related schemas.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate JSON-LD structured data for any Schema.org type. Provide the schema type and a set of key-value field pairs.
| Name | Required | Description | Default |
|---|---|---|---|
| type | Yes | The Schema.org type to generate | |
| fields | Yes | Key-value pairs of schema fields and their values |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. The description explains the tool generates JSON-LD, but does not disclose any behavioral traits like validation, side effects, or permissions. Adequate for a generation tool but lacks extra context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the main action, and contains no extraneous words. It is appropriately concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (2 params, no output schema), the description covers the purpose and inputs. However, it lacks guidance on field validity per type and does not reference sibling tools, which could help completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%. The description repeats the information in the schema (type and fields), adding no new semantic meaning beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it generates JSON-LD structured data for any Schema.org type, using a type and key-value pairs. It distinguishes from siblings (e.g., generate_article_schema) by being generic.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly state when to use this tool versus the specific siblings (e.g., generate_article_schema). Usage is implied: for types not covered by siblings, but no exclusions or alternatives mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all supported Schema.org types with their available fields and descriptions.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and description only states basic purpose. No disclosure of output format, limits, or side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, clear and direct, no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Simple tool with no parameters, description adequate. Could specify output format, but not required for basic completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters, so description need not add param info. Baseline 4 applies with 100% schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool lists all supported Schema.org types with fields and descriptions. It distinguishes from sibling generate/validate tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied (explore types before generating/validating) but no explicit when-to-use or alternatives guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Validate an existing JSON-LD schema. Checks for required fields, proper @context, valid @type, and common issues.
| Name | Required | Description | Default |
|---|---|---|---|
| json | Yes | JSON-LD string to validate |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the checks performed (required fields, @context, @type, common issues) but does not explicitly state that the tool is read-only or non-destructive, nor does it describe the output format or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with two sentences, front-loaded with the action and followed by specific details. Every word contributes meaning without repetition or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (single param, no output schema, no annotations), the description covers the core purpose and checks. However, it lacks details on the return value or result format, which could be important for an AI agent to interpret validation results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers 100% of the parameter and its description. The tool description adds value by listing what the validation checks, which gives context beyond the parameter type. This enhances understanding of how the parameter is used.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool validates an existing JSON-LD schema, specifying the verb 'validate' and the resource. It lists specific checks (required fields, @context, @type, common issues), distinguishing it from sibling generator tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly provide usage guidelines or contrast with alternatives. However, the sibling tools are all generators, so the validation purpose is implicitly clear, but lacking explicit when-to-use or when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.1generate_article_schemagenerate_faq_schemagenerate_organization_schemagenerate_person_schemagenerate_product_schemagenerate_schemalist_schema_typesvalidate_schemav1.0.0generate_article_schema1 field changedInput schema / additionalPropertiesAdded value: +falsegenerate_faq_schema2 fields changedInput schema / additionalPropertiesAdded value: +falseInput schema / properties / questions / items / additionalPropertiesAdded value: +falsegenerate_organization_schema1 field changedInput schema / additionalPropertiesAdded value: +falsegenerate_person_schema1 field changedInput schema / additionalPropertiesAdded value: +falsegenerate_product_schema1 field changedInput schema / additionalPropertiesAdded value: +falsegenerate_schema2 fields changedInput schema / additionalPropertiesAdded value: +falseInput schema / properties / fields / propertyNamesRemoved value: -{
- "type": "string"
-}validate_schema1 field changedInput schema / additionalPropertiesAdded value: +falsev0.1.0generate_article_schemagenerate_faq_schemagenerate_organization_schemagenerate_person_schemagenerate_product_schemagenerate_schemalist_schema_typesvalidate_schemaEach tool targets a distinct schema type or function (generation for specific types, generic generation, listing, validation) with no overlapping purposes, making it easy for an agent to select the correct tool.
All tool names follow a consistent verb_noun snake_case pattern (e.g., generate_article_schema, list_schema_types, validate_schema), ensuring predictability and readability.
With 8 tools, the set is well-scoped for generating, listing, and validating JSON-LD schemas; it covers essential functionality without being bloated or insufficient.
The tool surface provides generation for common schema types, a generic generator for any type, type listing, and validation—covering the full lifecycle of creating and checking schemas with no obvious gaps.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Generate 18 AI readiness files (llms.txt, ai.txt, RAG indexes, schema) for any website.
Audit a store's product page and get the JSON-LD Product markup it is missing. No account.
JSON Schema catalog (SchemaStore.org)
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/sharozdawa/schema-gen'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
