# MetaEngine (npm · @metaengine/mcp-server)

Spec-first code generation: OpenAPI, GraphQL, Protobuf, and SQL to typed clients in 11 languages.

- Trust score: 68/100 (medium)
- Change this week: +19
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- npm · `@metaengine/mcp-server`: 68/100 (this document), [markdown](https://verifymcp.io/servers/eu-metaengine-mcp-server/metaengine-mcp-server.md), [page](https://verifymcp.io/servers/eu-metaengine-mcp-server/metaengine-mcp-server)

## Channel facts

- Registry: `npm`
- Package: `@metaengine/mcp-server`
- Version: `1.4.1`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 86/100
  - No malware found by supply-chain analysis.
  - Only part of the dependency tree could be resolved (94 of 98), so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (94 of 98), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 26 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 69/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 6103 tokens (~678/item across 9 items; 7 tools + 2 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add eu-metaengine-mcp-server -- npx -y @metaengine/mcp-server
```

### Codex

```bash
codex mcp add eu-metaengine-mcp-server -- npx -y @metaengine/mcp-server
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "eu-metaengine-mcp-server": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@metaengine/mcp-server"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add eu-metaengine-mcp-server --command npx --arg -y --arg @metaengine/mcp-server
```

### Hermes

```yaml
mcp_servers:
  eu-metaengine-mcp-server:
    command: "npx"
    args: ["-y", "@metaengine/mcp-server"]
```

### Other

```json
{
  "mcpServers": {
    "eu-metaengine-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "@metaengine/mcp-server"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 68, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-02 (score 67, +62)

- [security regression] Provenance: unverified → fail
- [security improvement] Install scripts: unverified → pass
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Malware scan: unverified → pass
- [functional improvement] License: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] Schema quality: unverified → good
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Stability: unverified → 0.23
- [functional] Licence: MIT

### 2026-08-01 (score 5, −26)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-31 (score 31, −18)

- [security regression] Malware scan: pass → unverified

### 2026-07-27 (score 49)

First indexed and scored.

## MCP tools (7)

### `load_spec_from_file` (~310 tokens)

Load Code Spec from File

Load code generation spec from a JSON file - Perfect for complex architectures and reusable templates!

Instead of constructing large JSON specs in memory, load them from version-controlled .json files.
All the same functionality as generate_code (outputPath, skipExisting, dryRun) but with zero memory overhead.

Benefits:
\- Drastically reduced AI context usage (just pass file path!)
\- Version control your architecture patterns
\- Reusable templates across projects
\- Supports complex multi-file generations without context bloat

Usage:
1\. Create a .json file with your spec (same structure as generate_code)
2\. Call this tool with the file path
3\. Optionally override outputPath, skipExisting, or dryRun

Example spec file (user-system.json):
{
  "language": "typescript",
  "classes": [{"name": "User", ...}],
  "interfaces": [{...}]
}

Then call: load_spec_from_file({specFilePath: "specs/user-system.json", outputPath: "src"})

Input parameters:

- `dryRun` (boolean): Preview mode - returns generated code without writing files. Overrides dryRun in spec file if provided.
- `outputPath` (string): Output directory path where files will be written. Overrides outputPath in spec file if provided.
- `skipExisting` (boolean): Skip writing files that already exist. Overrides skipExisting in spec file if provided.
- `specFilePath` (string, required): Path to the JSON spec file (absolute or relative to current directory)

### `metaengine_initialize` (~113 tokens)

Get Documentation & Patterns

Returns essential MetaEngine patterns and documentation resources.

This helper tool provides AI assistants with critical MetaEngine concepts:
\- The fundamental principle of generating related types in ONE call
\- Properties vs customCode distinction
\- Template references and type referencing patterns
\- Language-specific best practices

Returns links to comprehensive documentation with patterns and examples.
Call this when you need guidance or are generating code for the first time.

Input parameters:

- `language` (string): Optional: The primary language you'll be generating code for. If specified, returns language-specific patterns.

### `generate_code` (~3888 tokens)

Generate Multi-Language Code

Semantic code generation for TypeScript, Python, Go, C#, Java, Kotlin, Groovy, Scala, Swift, PHP, and Rust. Generates compilable source files with perfect imports and cross-references from structured JSON specs.

\# MetaEngine MCP — AI Code Generation Guide

MetaEngine is a semantic code generation system exposed via MCP. You describe types, relationships, and methods as structured JSON — MetaEngine produces compilable, correctly-imported source files for TypeScript, C#, Python, Go, Java, Kotlin, Groovy, Scala, Swift, and PHP. Unlike templates, it resolves cross-references, manages imports, and handles language idioms automatically. This matters for AI usage because a single well-formed JSON call replaces dozens of error-prone file writes.

\---

\## Critical Rules

These are the rules that cause the most failures when violated. Read them first.

\### 1. Generate ALL related types in ONE call

\`typeIdentifier` references only resolve within the current batch. If `UserService` references `User`, both must be in the same `generate_code` call.

\```jsonc
// ONE call with both types
{
  "classes": [
    {"name": "User", "typeIdentifier": "user", ...},
    {"name": "UserService", ...references "user"...}
  ]
}
\```

\### 2. Properties = type declarations. CustomCode = everything else.

\`properties[]` declares fields with types only. `customCode[]` handles methods, initialized fields, and any code with logic. One `customCode` item = exactly one member.

\```jsonc
// Property: type only, no initialization
"properties": [{"name": "id", "primitiveType": "String"}]

// CustomCode: method or initialized field
"customCode": [
  {"code": "private http = inject(HttpClient);"},
  {"code": "getAll(): T[] { return this.items; }"}
]
\```

\**Never put methods in properties.** Never put uninitialized type declarations in customCode.

\### 3. Use templateRefs for internal types in customCode

When customCode references a type from the same batch, use `$placeholder` syntax with `templateRefs`. Th…

Input parameters:

- `arrayTypes` (array): Array type definitions - creates IArrayType references (NO files generated). Use for reusable array definitions.
- `classes` (array): Class definitions (regular and generic class templates)
- `concreteGenericClasses` (array): Concrete generic implementations (Repository<User>) - creates inline type references, NO files generated
- `concreteGenericInterfaces` (array): Concrete generic interface implementations (IRepository<User>) - creates inline type references, NO files generated
- `customFiles` (array): Custom files (utility files, type aliases, barrel exports) - generates files WITHOUT class wrapper. Perfect for type aliases and utility functions.
- `dictionaryTypes` (array): Dictionary type definitions - creates IDictionaryType references (NO files generated). Supports all 4 combinations of primitive/custom for key/value.
- `dryRun` (boolean): Preview mode - returns generated code without writing files to disk. When true, file contents are returned in the response for review.
- `enums` (array): Enum definitions
- `initialize` (boolean): Whether to initialize properties with default values
- `interfaces` (array): Interface definitions (regular and generic interface templates)
- `language` (string, required): Target programming language
- `outputPath` (string): Output directory path where files will be written. Defaults to current directory.
- `packageName` (string): Package/module/namespace name for generated code. Defaults depend on language: Go='github.com/metaengine/demo', Java/Kotlin/Groovy='com.metaengine.generated'. For C#: when omitted or empty, no namesp…
- `skipExisting` (boolean): Skip writing files that already exist (useful for stub pattern). When true, only new files are created.

### `generate_openapi` (~541 tokens)

Generate HTTP Client from OpenAPI

Generate HTTP clients from OpenAPI specifications for 10 frameworks:
Angular, React, TypeScript Fetch, Go net/http, Java Spring, Python httpx, C# HttpClient, Kotlin Ktor, Rust Reqwest, Swift URLSession.

Provide an inline OpenAPI spec (YAML/JSON) or a URL, choose a framework, and get fully typed, production-ready HTTP client code with models, services, and error handling.

Input parameters:

- `angularOptions` (object): Options for Angular framework (only when framework=angular)
- `basicAuth` (object): Basic authentication configuration
- `bearerAuth` (object): Bearer authentication configuration
- `csharpOptions` (object): Options for C# HttpClient (namespaceName required)
- `customHeaders` (array): Custom HTTP headers
- `documentation` (boolean): Generate JSDoc/XML doc comments
- `dryRun` (boolean): Preview mode - returns generated code without writing files
- `errorHandling` (object): Error handling configuration
- `fetchOptions` (object): Options for TypeScript Fetch
- `framework` (string, required): Target framework for HTTP client generation
- `goOptions` (object): Options for Go net/http (moduleName and packageName required)
- `includeTags` (array): Only generate operations whose service tag matches one of these values (case-insensitive).
- `javaSpringOptions` (object): Options for Java Spring (packageName required)
- `kotlinOptions` (object): Options for Kotlin Ktor (packageName required)
- `openApiSpec` (string): Inline OpenAPI spec content (YAML or JSON). Either this or openApiSpecUrl is required.
- `openApiSpecUrl` (string): URL to fetch the OpenAPI spec from. Either this or openApiSpec is required.
- `optionsObjectThreshold` (number): Min params before grouping into options object
- `outputPath` (string): Output directory path where files will be written
- `pythonOptions` (object): Options for Python httpx
- `reactOptions` (object): Options for React framework
- `retries` (object): Retry configuration
- `rustOptions` (object): Options for Rust Reqwest
- `skipExisting` (boolean): Skip writing files that already exist
- `strictValidation` (boolean): Enable strict OpenAPI spec validation
- `swiftOptions` (object): Options for Swift URLSession
- `timeout` (object): Timeout configuration
- `typeMappings` (object): Override how spec types are emitted in code (e.g. {decimal: 'string'} to keep precision in JS). Keys are spec type names, values are target-language type names.

### `generate_graphql` (~438 tokens)

Generate HTTP Client from GraphQL

Generates a fully typed HTTP client from a GraphQL SDL schema. Supports Angular, React, TypeScript Fetch, Go, Java Spring, C#, Kotlin, Python, Rust, and Swift. Enable `fragments` to emit reusable named GraphQL fragments for object-type selections.

Input parameters:

- `angularOptions` (object): Angular-specific options
- `basicAuth` (object): Basic authentication configuration
- `bearerAuth` (object): Bearer authentication configuration
- `csharpOptions` (object): C#-specific options
- `customHeaders` (array): Custom HTTP headers
- `customScalars` (object): Map GraphQL custom scalars to target-language types (e.g. {DateTime: 'Date', UUID: 'string'}). Keys are scalar names, values are target-language type names.
- `documentation` (boolean): Generate documentation comments from schema descriptions
- `dryRun` (boolean): Preview mode - returns generated code without writing files to disk
- `errorHandling` (object): Error handling configuration
- `fetchOptions` (object): TypeScript Fetch-specific options
- `fragments` (boolean): Emit reusable named GraphQL fragments for object-type selections. Selections reference fragment spreads (`...TypeFields`) and fragment definitions are hoisted into a separate fragments file. Off by d…
- `framework` (string, required): Target framework for code generation
- `goOptions` (object): Go-specific options
- `graphQLSchema` (string, required): GraphQL SDL schema content
- `javaSpringOptions` (object): Java Spring-specific options
- `kotlinOptions` (object): Kotlin-specific options
- `optionsObjectThreshold` (number): Min params before grouping into options object
- `outputPath` (string): Output directory path where files will be written
- `pythonOptions` (object): Python-specific options
- `reactOptions` (object): React-specific options
- `retries` (object): Retry configuration
- `rustOptions` (object): Rust-specific options
- `skipExisting` (boolean): Skip writing files that already exist
- `swiftOptions` (object): Swift-specific options
- `timeout` (object): Timeout configuration

### `generate_protobuf` (~337 tokens)

Generate HTTP Client from Protobuf

Generates a fully typed HTTP client from Protocol Buffers (.proto) definitions. Supports Angular, React, TypeScript Fetch, Go, Java Spring, C#, Kotlin, Python, Rust, and Swift.

Input parameters:

- `angularOptions` (object): Angular-specific options
- `basicAuth` (object): Basic authentication configuration
- `bearerAuth` (object): Bearer authentication configuration
- `csharpOptions` (object): C#-specific options
- `customHeaders` (array): Custom HTTP headers
- `documentation` (boolean): Generate documentation comments from proto comments
- `dryRun` (boolean): Preview mode - returns generated code without writing files to disk
- `errorHandling` (object): Error handling configuration
- `fetchOptions` (object): TypeScript Fetch-specific options
- `framework` (string, required): Target framework for code generation
- `goOptions` (object): Go-specific options
- `javaSpringOptions` (object): Java Spring-specific options
- `kotlinOptions` (object): Kotlin-specific options
- `optionsObjectThreshold` (number): Min params before grouping into options object
- `outputPath` (string): Output directory path where files will be written
- `protoSource` (string, required): Protocol Buffers (.proto) definition content
- `pythonOptions` (object): Python httpx-specific options
- `reactOptions` (object): React-specific options
- `retries` (object): Retry configuration
- `rustOptions` (object): Rust-specific options
- `skipExisting` (boolean): Skip writing files that already exist
- `swiftOptions` (object): Swift-specific options
- `timeout` (object): Timeout configuration

### `generate_sql` (~438 tokens)

Generate Models from SQL DDL

Generates typed model classes from SQL DDL (CREATE TABLE statements). Supports TypeScript, C#, Go, Python, Java, Kotlin, Groovy, Scala, Swift, PHP, and Rust.

Input parameters:

- `csharpOptions` (object): C#-specific options
- `ddlSource` (string, required): SQL DDL source code (CREATE TABLE statements)
- `dryRun` (boolean): Preview mode - returns generated code without writing files to disk
- `generateInterfaces` (boolean): Emit interface-style output (interface/protocol/trait) instead of the default modern-idiomatic concrete shape (record/data class/case class/struct).
- `generateNavigationProperties` (boolean): Generate navigation properties for foreign key relationships
- `generateValidationAnnotations` (boolean): Generate validation annotations from column constraints
- `goOptions` (object): Go-specific options
- `groovyOptions` (object): Groovy-specific options
- `initializeProperties` (boolean): Initialize model properties with default values
- `javaOptions` (object): Java-specific options
- `jsonAs` (string): How JSON columns are typed: e.g. 'string' (raw), 'object' (parsed). Language-specific defaults apply if omitted.
- `kotlinOptions` (object): Kotlin-specific options
- `language` (string, required): Target programming language
- `outputPath` (string): Output directory path where files will be written
- `phpOptions` (object): PHP-specific options
- `precisionSafeDecimals` (boolean): Emit decimal/numeric columns as precision-safe types (e.g. string in JS) instead of float, preserving full precision.
- `pythonOptions` (object): Python-specific options
- `rustOptions` (object): Rust-specific options
- `scalaOptions` (object): Scala-specific options
- `schemaPrefix` (string): Prepend the SQL schema name to generated type names (e.g. 'Auth_User' instead of 'User').
- `singularTypeNames` (boolean): Singularize plural table names when emitting type names (e.g. table 'users' becomes type 'User').
- `skipExisting` (boolean): Skip writing files that already exist

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/eu-metaengine-mcp-server/metaengine-mcp-server#diagnostics

## Score history

- 2026-08-03: 68
- 2026-08-02: 67
- 2026-08-01: 5
- 2026-07-31: 31
- 2026-07-29: 49
- 2026-07-28: 49
- 2026-07-27: 49

## Links

- npm package: https://www.npmjs.com/package/@metaengine/mcp-server
- Socket report: https://socket.dev/npm/package/@metaengine/mcp-server
- Repository: https://github.com/meta-engine/mcp-server
- Website: https://www.metaengine.eu/mcp
- Changelog RSS feed: https://verifymcp.io/servers/eu-metaengine-mcp-server/metaengine-mcp-server/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/eu-metaengine-mcp-server/metaengine-mcp-server/changelog.json
- HTML version of this page: https://verifymcp.io/servers/eu-metaengine-mcp-server/metaengine-mcp-server