Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

CE-RISE Digital Passport Engineering Assistant

The CE-RISE Digital Passport Engineering Assistant is a stdio MCP server for AI-assisted reuse of existing CE-RISE Digital Passport assets.

Its purpose is to help users discover CE-RISE components, understand how they fit together, map engineering goals to available capabilities, plan implementation steps, and assess readiness before moving into more specific CE-RISE tools or deployment workflows.

It does not replace CE-RISE services, schemas, methods, documentation, or deployment assets. It guides users toward them.

CE-RISE provides interoperable building blocks, not a required closed stack. Users can select individual CE-RISE components and models and combine them with external alternatives. The assistant preserves declared choices and offers CE-RISE patterns as optional references. It reviews only supported CE-RISE configuration; it does not classify external components as missing or certify their interoperability.

The main product workflow is general Digital Passport adoption. The assistant should help an organization clarify compliance drivers, value-chain information flows, implementation readiness, and value opportunities from shared information. This workflow is not tied to a company-size label.

Initial Scope

The first implementation is intentionally small and deterministic:

  • a local CE-RISE capability and component catalog;
  • a curated connected-source manifest for CE-RISE repositories, documentation, model assets, and service references;
  • a read-only live service connection manifest for health, readiness, version, and OpenAPI probes;
  • a deployment artifact manifest for Compose and Kubernetes starter outputs derived from the CE-RISE GitOps template;
  • a reference-example manifest that treats the local demonstrator as an example to generalize from, not a mandatory target architecture;
  • an update channel manifest for optional current release, tag, documentation, and artifact metadata checks;
  • MCP tools for discovery, architecture guidance, adoption context assessment, value-chain flow mapping, value-opportunity identification, implementation planning, and readiness checks;
  • MCP tools for listing, checking, inspecting, and snapshotting connected CE-RISE sources;
  • MCP tools for read-only live service discovery;
  • MCP tools for planning, generating, and readiness-checking deployment artifact outputs;
  • static consistency review of supplied Compose or Kubernetes configuration, including service connections, ports, model catalogs, and authentication;
  • MCP tools for listing reference examples and generalizing reusable workflow patterns from them;
  • MCP tools for optional update-aware context over configured CE-RISE upstream channels;
  • MCP resources exposing the catalog, source manifest, live service manifest, deployment artifact manifest, reference-example manifest, update channel manifest, and core scope rule;
  • a first design workflow example under examples/01-design-workflow/;
  • local validation and smoke scripts;
  • release-side metadata for OCI image publication and MCP registry publication from the GitHub mirror.

The first server connects to curated CE-RISE repositories and documentation references. It can inspect local sibling repositories when they are available, optionally check remote repository/documentation URL availability, and probe read-only live service discovery endpoints.

It can also return Docker Compose and Kubernetes starter file contents for planning deployment handover. These outputs are derived from the existing CE-RISE GitOps template and are not a replacement deployment framework.

Supported calculation services are RE Indicators and SEE Impacts, selected independently or together. SEE integration covers the Product System and LCI Dataset inputs, the functional unit, and the complete Integrated LCA result with all 25 configured environmental impact indicators. The assistant can generate the deployment configuration and inspect the service’s read-only endpoints; the SEE service performs the calculation. The PV demonstrator is one example of this product-neutral workflow.

It does not call live CE-RISE business operations such as record creation, validation, query, indicator computation, or registry refresh.

Compliance-oriented outputs are planning aids only. They are not legal certification or legal advice.

Main Reference

The human-facing CE-RISE solution entry point remains:

  • https://solution.ce-rise.eu/

Local Commands

Install the runtime dependencies into the Python environment used by the MCP server:

python -m pip install -r requirements.txt
./scripts/run-local.sh
./scripts/smoke-mcp.sh
./scripts/smoke-container.sh
./scripts/validate-local.sh

Repository

The canonical repository is maintained on Codeberg:

  • https://codeberg.org/CE-RISE-software/dp-engineering-assistant

The published documentation for this MCP server is:

  • https://ce-rise-software.codeberg.page/dp-engineering-assistant/

The GitHub mirror is used for release automation, OCI image publication, MCP registry publication, and Zenodo integration.

After release, MCP clients can discover the server through the MCP Registry identity io.github.CE-RISE-software/dp-engineering-assistant. When the server is registered behind the CE-RISE MCPO gateway, HTTP/OpenAPI clients can reach it through the gateway endpoint published in this documentation.


Funded by the European Union under Grant Agreement No. 101092281 - CE-RISE.

Views and opinions expressed are those of the author(s) only and do not necessarily reflect those of the European Union or the granting authority (HADEA). Neither the European Union nor the granting authority can be held responsible for them.

CE-RISE logo

(c) 2026 CE-RISE consortium.

Licensed under the European Union Public Licence v1.2 (EUPL-1.2).

Attribution: CE-RISE project (Grant Agreement No. 101092281) and the individual authors/partners as indicated.

NILU logo

Developed by NILU (Riccardo Boero - ribo@nilu.no) within the CE-RISE project.

MCP Server

The repository ships a thin stdio MCP server in server/mcp_server.py.

Design Rule

The server is an assistant over existing CE-RISE assets. It must guide discovery, configuration, planning, and readiness assessment without substituting for CE-RISE components.

Components and models can be selected independently and mixed with external implementations. The assistant preserves those choices and limits its checks to the supplied, supported CE-RISE configuration. Reference patterns are optional; external parts are not missing dependencies and their implementation or compatibility is not assessed.

The runtime is repo-native, with PyYAML for reading supplied configuration documents and the Python standard library for the remaining server functions. Dependencies are declared in requirements.txt; the server is not packaged as an installable Python project.

Runtime Shape

  • local entry point: ./scripts/run-local.sh
  • transport: stdio
  • message framing: newline-delimited JSON-RPC 2.0
  • exposed MCP capabilities: tools, resources
  • catalog source: data/solution_catalog.json
  • connected-source manifest: data/connected_sources.json
  • live service connection source: data/live_service_connections.json
  • deployment artifact source: data/deployment_artifacts.json
  • reference example source: data/reference_examples.json
  • update channel source: data/update_channels.json

Tools

MCP toolResult typePurpose
list_solution_capabilitiessolution_capabilities_resultList CE-RISE capability families from the local catalog.
list_solution_componentssolution_components_resultList existing CE-RISE components and assistant reuse roles.
map_user_goal_to_ce_rise_capabilitiesgoal_mapping_resultMap a user goal to CE-RISE capabilities and suggested components.
recommend_passport_architecturepassport_architecture_recommendation_resultRecommend a reuse-oriented Digital Passport architecture pattern.
generate_implementation_planimplementation_plan_resultGenerate ordered implementation steps over existing CE-RISE assets.
assess_implementation_readinessimplementation_readiness_resultCheck whether enough project context is available to proceed.
assess_adoption_contextadoption_context_assessment_resultAssess scope, drivers, value-chain role, shared information, data readiness, and value goals.
map_value_chain_flowsvalue_chain_flow_mapping_resultMap Digital Passport information flows across value-chain actors.
identify_value_opportunitiesshared_information_value_opportunities_resultIdentify practical value opportunities from shared passport information.
recommend_adoption_pathadoption_path_recommendation_resultRecommend a general CE-RISE reuse-oriented adoption path.
generate_implementation_roadmapimplementation_roadmap_resultGenerate a phased adoption and implementation roadmap.
list_deployment_artifact_templatesdeployment_artifact_templates_resultList Compose/Kubernetes starter artifact profiles derived from the CE-RISE GitOps template.
generate_deployment_artifact_plandeployment_artifact_plan_resultMap deployment choices to recommended artifact profiles and files.
generate_deployment_artifactsdeployment_artifact_generation_resultReturn Docker Compose and/or Kubernetes starter file contents, with optional checked version context.
assess_deployment_artifact_readinessdeployment_artifact_readiness_resultCheck whether deployment decisions are complete enough before using generated artifacts.
review_configuration_consistencyconfiguration_consistency_review_resultCheck supplied resolved Compose or rendered Kubernetes contents for port, service URL, model catalog, and authentication inconsistencies.
list_reference_examplesreference_examples_resultList curated CE-RISE examples that can be generalized.
generalize_reference_examplereference_example_generalization_resultExtract reusable workflow patterns from a reference example for a declared context.
list_update_channelsupdate_channels_resultList configured read-only update channels.
check_update_channelsupdate_channel_check_resultFetch current metadata from configured repository, release, tag, documentation, or artifact channels.
build_update_aware_solution_contextupdate_aware_solution_context_resultCombine stable catalog guidance with optional current upstream metadata.
discover_model_repositoriesmodel_repository_discovery_resultDiscover CE-RISE model repositories under the configured namespace and propose update channels for newly available models.
list_connected_sourcesconnected_sources_resultList curated CE-RISE repositories, documentation sites, model assets, and service references.
check_connected_sourcesconnected_source_availability_resultCheck local and optionally remote availability for connected CE-RISE sources.
inspect_connected_sourceconnected_source_inspection_resultInspect curated key files from one connected CE-RISE source.
build_connected_solution_snapshotconnected_solution_snapshot_resultBuild a source-grounded snapshot linking catalog components to connected sources.
list_live_service_connectionslive_service_connections_resultList curated read-only live service discovery connections.
probe_live_servicelive_service_probe_resultProbe curated read-only GET endpoints for one live service connection.
inspect_live_service_openapilive_service_openapi_inspection_resultFetch and summarize a live service OpenAPI document.
build_live_service_readiness_snapshotlive_service_readiness_snapshot_resultBuild a read-only reachability/readiness snapshot across live service connections.

Resources

URIPurpose
ce-rise://solution/catalogExposes the deterministic local CE-RISE capability catalog.
ce-rise://solution/scopeExposes the core non-substitution scope rule.
ce-rise://sources/manifestExposes the connected CE-RISE source manifest.
ce-rise://services/live-connectionsExposes the read-only live service connection manifest.
ce-rise://deployment/artifact-templatesExposes the deployment artifact template manifest.
ce-rise://examples/reference-generalizationExposes the reference-example generalization manifest.
ce-rise://updates/channelsExposes the update channel manifest.

Result Contract

Tool results use a deterministic envelope:

  • result_type
  • inputs
  • content
  • diagnostics

MCP tool responses include the same payload in both content[0].text and structuredContent.

Compliance-oriented outputs are planning aids only. They do not provide legal certification or legal advice.

Adoption, value-chain, architecture, and roadmap tools include grounding fields where relevant:

  • source_references: curated CE-RISE repositories, documentation sites, and model assets related to the recommendation;
  • live_service_connections: read-only service discovery connections related to the selected components.

Connected Sources

The connection layer is curated through data/connected_sources.json.

The server can:

  • list connected CE-RISE repositories, documentation sites, model assets, and service references;
  • inspect local sibling repositories when they are available in the same workspace;
  • extract Markdown headings from curated key files;
  • check remote repository and documentation URLs when check_remote is explicitly enabled.

It does not automatically call live CE-RISE business services in this first connected version.

Reference Examples

The reference-example layer is curated through data/reference_examples.json.

The local demonstrator is treated as an illustrative workflow. The server can generalize reusable patterns from it, such as scope declaration, service selection, registry adaptation, representative payload design, lifecycle operations, and operational checks.

The examples cover the chair passport, laptop RE indicators, and PV environmental impacts. The PV workflow demonstrates one calculation request returning all configured indicators, with live input/output model validation, numerical comparison, and persistence. It is not a restriction on the products that SEE can assess.

The server should not treat demonstrator-specific products, payloads, no-auth settings, ports, or local persistence decisions as defaults for other adopters.

Update Awareness

The update-awareness layer is curated through data/update_channels.json.

Stable tools remain deterministic by default, but component-aware outputs include an update_awareness block so users are not expected to know on their own when upstream changes may matter. When current upstream metadata is needed, clients can call:

  • list_update_channels to discover configured release, tag, documentation, and artifact channels;
  • check_update_channels to fetch current metadata from selected channels;
  • build_update_aware_solution_context to combine stable catalog components with optional remote update checks;
  • discover_model_repositories to check the configured CE-RISE model repository namespace and propose channels for model repositories that are not yet explicitly tracked.

Generation tools can also include update checks directly when they expose check_remote_updates. In that mode, generated outputs include version_context and a generated VERSION-CONTEXT.md file.

This avoids needing a new MCP server release for every upstream model, component, or example update. It also keeps network access explicit instead of making every planning call depend on remote availability.

Discovered model repositories are treated as candidates. A generated artifact should only use a model version after an explicit model tag channel exists and has been checked.

Deployment Artifact Outputs

The deployment artifact layer is curated through data/deployment_artifacts.json.

The server can return starter file contents for:

  • Docker Compose baseline with HEX Core Service, a local registry catalog, and an external IO adapter URL;
  • optional Compose profiles for the internal adapter, RE Indicators, and SEE Impacts;
  • Kubernetes base, development overlay, production overlay, and optional RE Indicators and SEE Impacts extensions;
  • SEE-only overlays and combined calculation overlays when both services are selected.

generate_deployment_artifact_plan and generate_deployment_artifacts accept include_see_impacts. It defaults to whether see_impacts_calculation_service appears in selected_components; an explicit boolean overrides that selection. The RE Indicators option remains independent. Generated files use the pinned GitOps images and register Product System, LCI Dataset, and Integrated LCA models. SEE’s HEX Core token and calculation/workspace settings are explicit operator configuration. See Deployment Artifacts.

When selected_components is supplied, only selected supported CE-RISE parts are generated. Selecting a calculator without hex_core_service produces standalone fragments, without a local core, registry, or core-specific overlays. hex_core_base_url specifies its chosen validation endpoint. External choices remain in declared_components and outside_generation_scope without being generated or labelled missing. An external-only selection returns not_applicable and no files. Omitting the selection requests the optional HEX Core reference baseline.

recommend_passport_architecture also accepts selected_components, and generate_implementation_plan preserves the known_components selection. Both retain external labels and expose CE-RISE patterns as optional_reference_components. Adoption paths and roadmaps use adoption_context.selected_components in the same way. Readiness results describe the supplied planning context, not the completeness of a CE-RISE stack.

The generated outputs are intended for planning, review, and handover into the canonical dp-system-gitops-template workflow. The server does not write files to disk and does not deploy anything.

Users must still review secrets, image tags, domains, registry entries, authentication mode, resource settings, and environment overlays against the existing CE-RISE template and component documentation.

Use review_configuration_consistency to check the configuration contents themselves after rendering Compose variables or Kubernetes overlays. It complements the declaration-based readiness check. The tool returns field-specific findings and distinguishes consistent, inconsistent, incomplete, and not_applicable results for its CE-RISE review scope. External components and endpoints appear in out_of_scope and do not make that review incomplete. It reads only the supplied contents, not the supplied path labels, and performs no network or command execution. See Configuration Consistency Review.

Live Service Discovery

The live service layer is curated through data/live_service_connections.json.

The server can probe:

  • HEX Core Service: GET /admin/health, GET /admin/ready, GET /admin/version, GET /admin/models/count, GET /openapi.json
  • Digital Passport JSON DB Storage Service: GET /health, GET /ready, GET /openapi.json
  • RE Indicators Calculation Service: GET /health, GET /openapi.json
  • SEE Impacts Calculation Service: GET /health, GET /capabilities, GET /methods, GET /openapi.json (default base URL http://127.0.0.1:8084)

The server intentionally does not call write or domain-operation endpoints such as:

  • record creation or query;
  • model validation, create, or query operations;
  • indicator computation;
  • registry refresh.

Local URL overrides are restricted to localhost addresses.

Local Use

Install requirements.txt into the server’s Python environment first:

python -m pip install -r requirements.txt
./scripts/run-local.sh
./scripts/smoke-mcp.sh
./scripts/smoke-container.sh
./scripts/validate-local.sh

Minimal local MCP client configuration:

{
  "mcpServers": {
    "dp-engineering-assistant": {
      "command": "/home/riccardo/code/CE-RISE-software/dp-engineering-assistant/scripts/run-local.sh"
    }
  }
}

Publication

Project documentation is published at:

  • https://ce-rise-software.codeberg.page/dp-engineering-assistant/

The MCP registry identity is declared in server.json:

  • io.github.CE-RISE-software/dp-engineering-assistant

Once a release is published, MCP clients can discover the stdio server through the MCP Registry identity and run the published OCI package:

  • ghcr.io/ce-rise-software/dp-engineering-assistant-mcp:<release-version>

When the server is registered behind the CE-RISE MCPO gateway, HTTP/OpenAPI clients can reach the same MCP tools through the gateway endpoint published in the project documentation. That MCPO/OpenAPI URL is deployment metadata, so it is documented when provisioned rather than embedded in the server code.

The GitHub mirror workflow .github/workflows/publish-mcp.yml is responsible for:

  • validating the local server;
  • updating server.json for the release version;
  • building and pushing ghcr.io/ce-rise-software/dp-engineering-assistant-mcp:<release-version>;
  • publishing the server metadata to the MCP Registry using GitHub OIDC.

Solution Catalog

The initial MCP server is backed by data/solution_catalog.json.

The catalog is deliberately small and deterministic. It is not a source of truth replacing CE-RISE documentation or services. It is an assistant-facing routing layer that helps agents point users toward existing CE-RISE assets.

The connected-source layer is backed by data/connected_sources.json. It records curated links to CE-RISE repositories, documentation sites, model assets, and service references that ground the assistant’s guidance.

The live service discovery layer is backed by data/live_service_connections.json. It records read-only GET probes for health, readiness, version, OpenAPI discovery, and SEE capabilities and assessment methods.

The deployment artifact layer is backed by data/deployment_artifacts.json. It records Compose and Kubernetes starter artifact profiles derived from the existing CE-RISE GitOps deployment template.

The reference-example layer is backed by data/reference_examples.json. It records illustrative CE-RISE workflows and the reusable patterns that can be generalized from them.

The update-awareness layer is backed by data/update_channels.json. It records read-only release, tag, repository-discovery, documentation, and generated-artifact metadata channels that can be checked at tool-call time.

Catalog Sections

  • capabilities: assistant-facing CE-RISE capability families.
  • components: existing CE-RISE assets and their intended reuse role.
  • composition_policy: independent component/model selection, mixed architectures, and the CE-RISE-only assessment boundary.
  • architecture_patterns: reusable Digital Passport implementation paths.
  • adoption_context_fields: fields used to assess general Digital Passport adoption context.
  • compliance_drivers: broad planning drivers for compliance-oriented adoption, without legal certification.
  • value_chain_flow_types: information flow categories across value-chain actors.
  • value_opportunity_patterns: practical value opportunities from shared information.
  • adoption_paths: phased CE-RISE reuse paths for adoption workflows.
  • readiness_fields: fields used by readiness assessment.
  • deployment_artifacts: generated through a separate manifest for Compose/Kubernetes artifact profiles and readiness fields.
  • reference_examples: generated through a separate manifest for illustrative examples, reusable patterns, non-assumptions, and adaptation questions.
  • update_channels: generated through a separate manifest for version-sensitive upstream metadata checks.

Current Component Coverage

The initial catalog includes:

  • CE-RISE Solution Portal
  • HEX Core Service
  • Digital Passport JSON DB Storage Service
  • Digital Passport System Local Demonstrator
  • Digital Passport System GitOps Template
  • CE-RISE Models
  • RE Indicators Calculation Service
  • SEE Impacts Calculation Service

Environmental footprint guidance connects the SEE service to the published Product System, LCI Dataset, and Integrated LCA model repositories. Its deployment catalog pins these models to 0.0.1, 0.0.1, and 0.2.0, respectively; explicit remote update checks can resolve newer published artifact versions for review. SEE’s service description distinguishes its shared BONSAI background and fixed EF 3.1 methods from the adopter’s foreground inputs and functional unit.

This list is expected to grow as the server is connected to more detailed CE-RISE documentation and workflows.

Maintenance Rule

Catalog entries should stay factual, conservative, and reuse-oriented. When a workflow needs implementation detail, the assistant should point to the relevant CE-RISE component or documentation rather than duplicating or replacing it.

CE-RISE patterns are optional examples, not complete-system requirements. Explicit user selections are preserved, including external or uncatalogued component labels. Those labels do not acquire invented capabilities, release channels, or a compatibility assessment. An external alternative is not a missing CE-RISE component. Required settings and model contracts are checked only within the supplied CE-RISE configuration and explicitly connected CE-RISE interfaces.

Adoption and compliance entries should remain general planning guidance. They should not assert legal compliance or imply certification.

Connected-source entries should stay curated and explicit. The assistant should only inspect listed files from listed sources, and live service calls should be introduced separately with clear scope and tests.

Live service entries must stay read-only unless the project explicitly expands scope. Domain operations such as record creation, validation, query, computation, and registry refresh are intentionally excluded from the initial service connection layer.

Deployment artifact entries must stay grounded in the canonical dp-system-gitops-template repository. Generated artifacts are starter outputs for planning and review; they should not drift into a parallel deployment framework.

Reference-example entries must distinguish concrete demo details from reusable patterns. The assistant should generalize from examples, not imply that the example product, payload, auth mode, storage, or local stack is mandatory.

Update-channel entries must stay read-only and explicit. Stable architecture and scope guidance should remain in the local catalog; version-sensitive facts should come from update checks when current metadata is needed. Repository-discovery channels may propose new model update channels, but the server should not silently turn unknown repositories into generated deployment inputs. Model artifact channels should use model_artifact_version; model architecture documentation and model templates should use separate update roles.

Reference Examples

The server can use CE-RISE examples as examples, then generalize from them.

The first curated reference example is the Digital Passport System Local Demonstrator. It is useful because it shows existing CE-RISE components working together locally, but its concrete products, payloads, local no-auth settings, storage choices, and ports are not defaults for adopters.

Its component set is not a required architecture. Adopters can reuse individual CE-RISE services or models alongside external components and choose another deployment workflow. Only the selected CE-RISE interfaces are within the assistant’s assessment scope.

Its three commands demonstrate different workflows:

Command in the demonstrator repositoryWorkflow
make demoChair passport validation, persistence, read-back, and invalid-input rejection
make demo-re-indicatorsAll five published laptop RE indicators and invalid-input rejection
make demo-see-impactsPV input validation, one calculation returning all 25 indicators, numerical comparison, and validation/persistence/read-back of the complete Integrated LCA output

The separate make validate-see-impacts command checks readiness, input schemas, a saved output, and invalid-input rejection. It does not run the calculation or persist records.

For another product, reuse the validation, calculation, comparison, and persistence sequence with that product’s foreground records and functional unit. SEE uses its released image’s shared background and methods; the PV example does not require an adopter to prepare a product-specific Brightway project.

Use generalize_reference_example to extract reusable patterns such as:

  • declaring the adopter’s scope and value-chain roles;
  • selecting required CE-RISE services and optional services;
  • adapting the model registry catalog;
  • preparing adopter-specific valid and invalid payloads;
  • exercising the intended record lifecycle;
  • turning demo checks into environment-appropriate operational checks.

The result separates:

  • reusable pattern;
  • contextualized action for the declared adoption context;
  • CE-RISE assets to reuse;
  • assumptions from the example that should not be carried over.

This keeps the demonstrator useful without making it a hidden architecture mandate.

Update Awareness

The server separates stable guidance from version-sensitive facts.

Stable guidance lives in the local catalog:

  • scope rules;
  • non-substitution boundaries;
  • component roles;
  • architecture and adoption patterns;
  • reference-example generalization;
  • deployment artifact shape.

Version-sensitive facts live in configured update channels:

  • repository releases;
  • repository tags;
  • repository discovery;
  • documentation availability;
  • generated artifact availability.

Use list_update_channels to inspect the configured channels, then check_update_channels when current metadata is needed. Use build_update_aware_solution_context when a workflow should combine stable component guidance with optional current upstream metadata.

Configured channels include SEE Impacts releases and published artifact tags for Product System, LCI Dataset, and Integrated LCA. Generated files use pinned GitOps service images; release checks provide metadata for the operator’s review without automatically changing those image tags.

Generation tools can also carry this context directly. For deployment artifact generation, pass check_remote_updates: true to generate_deployment_artifact_plan or generate_deployment_artifacts. The result includes version_context, and generated artifact sets include VERSION-CONTEXT.md. Where a checked model_artifact_version tag maps cleanly to registry catalog fields, the generated registry catalog uses the checked version. Model template and architecture/documentation channels are included in version context but excluded from registry catalog entries.

See examples/03-update-aware-generation for a request and expected response shape.

Use discover_model_repositories when the current question is whether the CE-RISE model namespace contains additional model repositories that are not yet explicitly tracked. The tool checks the configured CE-RISE model repository root and returns candidate gitea_tags update channels for new repositories. Those candidates are review inputs; generated artifacts should use a newly discovered model only after it has an explicit model-artifact update channel. Template and architecture/documentation repositories can still be tracked for version awareness, but they are not treated as data model artifact inputs.

Normal workflow tools also include an update_awareness field whenever they select or expose CE-RISE services, models, examples, deployment templates, or source references. That field is deliberately non-blocking:

  • it says whether current metadata was checked;
  • it lists the configured update channels relevant to the selected components;
  • it recommends build_update_aware_solution_context or check_update_channels before implementation, deployment, or detailed technical decisions.

Remote checks are explicit. The server does not silently call upstream repositories from every planning tool, because deterministic behavior and offline use are still important.

This means the MCP server does not need a new release just because a CE-RISE model, service, example, or deployment template publishes a new version. A new MCP release is needed only when the stable guidance, tool behavior, manifests, generated artifact logic, or supported update channels themselves change.

Deployment Artifacts

The server can return starter deployment files through generate_deployment_artifacts.

These outputs are derived from the existing CE-RISE Digital Passport System GitOps Template:

  • optional Docker Compose reference baseline with hex-core-service;
  • optional Compose profiles for the internal adapter, RE Indicators, and SEE Impacts;
  • Kubernetes base aligned with the existing template’s overlay workflow;
  • development and production overlays;
  • optional Kubernetes extensions for RE Indicators and SEE Impacts, with individual and combined overlays.

The generated files are returned as structured MCP content:

  • path: relative file path, such as compose/docker-compose.yml;
  • mime_type: content type hint;
  • description: short file purpose;
  • content: complete file content.

generate_deployment_artifact_plan and generate_deployment_artifacts accept check_remote_updates. When this is true, the same generation call checks configured update channels and returns a version_context. Generated artifact sets also include VERSION-CONTEXT.md. Checked model_artifact_version tags are used where they map cleanly to generated registry catalog entries. Model architecture documentation and model template channels remain visible in version context but are not emitted as registry catalog model entries.

The server does not write these files to disk and does not deploy anything.

Both deployment tools accept include_see_impacts, independently of include_re_indicators. If omitted, each option follows the corresponding service in selected_components. An explicit false excludes that service. SEE generation includes:

  • the see-impacts Compose profile, exposing the service on 127.0.0.1:8084 by default;
  • Product System 0.0.1, LCI Dataset 0.0.1, and Integrated LCA 0.2.0 registry entries when HEX Core is selected;
  • HEX Core connection and bearer-token settings, request/calculation timeouts, and concurrency;
  • a writable Brightway workspace, service probes, and a cluster-local Kubernetes Service;
  • dev-see-impacts and prod-see-impacts overlays when HEX Core is selected;
  • dev-calculations and prod-calculations overlays when HEX Core and RE Indicators are also selected.

An explicit selected_components list is the user’s composition, not a request to complete a CE-RISE stack. Selecting only SEE produces its Compose profile and Kubernetes extension without a local HEX Core, model registry, or namespace/overlay structure. Configure hex_core_base_url with the chosen validation endpoint; an external implementation must satisfy the interface used by the selected CE-RISE service, but this tool does not verify that implementation.

External or unsupported component labels remain in declared_components and outside_generation_scope. They are not generated or treated as missing. An external-only selection returns generation_status: not_applicable and no files. Without selected_components, the generator offers the optional HEX Core GitOps reference baseline. Standalone Kubernetes extensions can be incorporated into the adopter’s own overlays and namespace workflow.

Service image defaults match the GitOps template: HEX Core v0.0.9, JSONDB storage v0.0.1, RE Indicators v0.0.1, and SEE Impacts v0.0.1. Remote release checks report current metadata; they do not automatically replace these image pins. Checked model artifact tags can update the generated registry entries.

When HEX Core requires authentication, configure SEE_IMPACTS_HEX_CORE_BEARER_TOKEN for Compose, or supply a see-impacts-auth Secret containing HEX_CORE_BEARER_TOKEN in the Kubernetes namespace. The Secret is operator-managed and is not generated with credentials.

  1. Use generate_deployment_artifact_plan to map the adoption context and selected CE-RISE services to artifact profiles.
  2. Use assess_deployment_artifact_readiness to check whether runtime, service, adapter, registry, auth, overlay, and operational-check decisions are declared.
  3. Use generate_deployment_artifacts to return starter files.
  4. Review the selected CE-RISE fragments against their component documentation and integrate them into the adopter’s chosen deployment workflow; the GitOps template is an optional reference.

The scenarios in examples/02-deployment-artifacts show RE Indicators and SEE Impacts selections for Compose and Kubernetes, including the combined calculation overlays.

Configuration Consistency Review

review_configuration_consistency reviews the supplied configuration contents. Unlike the readiness checklist, it checks relationships between the actual settings:

  • CE-RISE container ports and listening ports, including conflicting bindings that affect a CE-RISE service; external-only conflicts are outside scope;
  • calculation-service URLs and the supplied HEX Core service or Kubernetes Service ports;
  • model registrations for explicitly connected CE-RISE calculator/HEX Core pairs: re-indicators-specification for RE Indicators, and product-system, lci-dataset, and integrated-lca for SEE; no such catalog requirement is inferred for an external endpoint;
  • duplicate model/version entries, missing artifact URLs, allowed hosts, HTTPS policy, and mismatches between catalog identities and versioned CE-RISE artifact URLs;
  • HEX Core authentication settings, explicit local no-auth permission, production no-auth configuration, and the SEE-to-HEX Core token setting;
  • Kubernetes Service targets, named ports, probes, and supplied ConfigMap/Secret references.

Pass the inputs as an MCP tool call:

ArgumentContent
targetcompose or kubernetes
filesArray of objects with path and JSON/YAML content; paths identify findings and are not opened
environmentlocal (default), dev, or prod
model_catalogOptional catalog object or array when the referenced catalog contents are not included in files

Supply the output of docker compose config or kubectl kustomize, rather than unevaluated variables or overlay sources. For example, render the selected configuration in your deployment workspace:

docker compose -f "$PWD/compose/docker-compose.yml" --env-file "$PWD/compose/.env" --profile see-impacts config > /tmp/ce-rise-compose.yaml
kubectl kustomize k8s/overlays/dev-see-impacts > /tmp/ce-rise-kubernetes.yaml

The MCP client passes the chosen rendered file’s contents in files, along with any referenced catalog file. A mounted or inline catalog takes precedence over model_catalog. Review one Kubernetes environment at a time. The tool supports at most 100 supplied files and 2 MB of contents.

Rendered configuration can contain credentials. Replace real secret values with non-empty redacted values while preserving their keys and references. For Kubernetes, Secret.stringData can carry those redacted values. The report does not echo environment or credential values.

The result contains findings with a code, severity, field path, explanation, and recommended correction, plus unchecked items for missing context. For example, a calculation container configured with HEX_CORE_BASE_URL=http://localhost:8080 while HEX Core runs in a different container produces a container_localhost_core finding and recommends using the service address.

consistent means no inconsistency was found in the supported CE-RISE static checks; it is not a judgment on the complete mixed system. inconsistent means a CE-RISE configuration error was found. incomplete means some supplied CE-RISE settings could not be checked because their catalog contents, variable values, or referenced configuration were not supplied. not_applicable means no supported CE-RISE component was supplied.

External components and validation endpoints are reported in out_of_scope, not in unchecked. They do not make a CE-RISE review incomplete or imply that another CE-RISE component must be added. For example, SEE configured with a valid external validation URL can be reviewed without including a HEX Core deployment or model catalog. Conversely, if SEE explicitly points to a supplied HEX Core instance, the checker can compare that declared connection’s model registrations. HEX Core catalogs can contain external models, subject to HEX Core’s configured artifact policies.

The tool does not fetch artifacts, validate records, verify credentials, execute deployment commands, or establish operational readiness.

Boundary

Deployment artifacts are optional CE-RISE configuration fragments, not a required complete architecture. They support independent reuse and mixed systems without replacing or assessing the adopter’s external components, models, or deployment workflow.