Start with a single module for your application. Add transformation, storage, workflow, or agent capabilities as you need them.
Use the protomolt-bom to align Maven dependency versions, then add the
modules you need under the ai.pipestream group. The
repository's getting-started guide
has the current dependency setup. The directory names below locate source code; the
protomolt- names are the artifact IDs.
Reference: the Gradle project index also covers applications, services, adapters, schemas, tests, and build tooling.
142 entries
No matching libraries. Try a broader term or clear the search.
Provides a small Agent Client Protocol runtime and blocking JSON-RPC client over stdio.
Use it when: A Java process must host or call an ACP agent without a reactive runtime.
Pair it with an ACP agent implementation for your application.
Implementation Related guidecore/acp
Provides shared CEL environments, compilation, and evaluation over protobuf descriptors and messages without mapping dependencies.
Use it when: Validation, quality scoring, projection, metric filtering, or mapping needs CEL evaluation over protobuf descriptors.
Implementation Related guidecore/cel
Runs bundled protoc generators through WebAssembly to produce client stubs.
Use it when: A Java tool needs protoc plugin output without a host-native protoc installation.
Generator targets are the bundled protoc plugins.
Implementation Related guidecore/codegen
Computes typed protobuf schema changes and evaluates Confluent-style compatibility policies.
Use it when: You want to check compatibility before accepting a schema change in a registry or CI gate.
Compatibility policy is distinct from compiling a schema successfully.
Implementation Related guidecore/compat
Registers and resolves protobuf message descriptors, including nested and well-known types.
Use it when: Your application must create or inspect messages from descriptors rather than generated Java classes.
Use fully qualified names when simple message names collide.
Implementation Related guidecore/descriptors
Dependency-free parsers for common identifiers, link relations, and internet-format strings.
Use it when: Validation or application code needs email, hostname, IP, URI, date, encoding, link-relation, or trade-item checks.
The facade returns booleans; callers supply their own field-specific error policy.
Implementation Related guidecore/formats
Descriptor-aware helpers for Any values, type conversion, field paths, diffs, and schema hygiene.
Use it when: Dynamic protobuf code needs safe packing, unpacking, conversion, or field inspection.
Implementation Related guidecore/helpers
Models and compiles a set of .proto sources into linked descriptors and a descriptor set in memory.
Use it when: Schemas arrive as source text and must be compiled without installing protoc.
Uses Square Wire and preserves linked custom options through a repair pass.
Implementation Related guidecore/sources
Defines descriptor annotations for field and message instructions used in structured prompting.
Use it when: A protobuf form needs instructions that a prompt renderer can read.
The prompt library renders these annotations into model instructions.
Implementation Related guideprotobuf/llm
Defines and reads descriptor metadata such as descriptions, owners, labels, JSON names, and sensitivity classes.
Use it when: Fields need machine-readable governance metadata alongside their wire type.
Metadata records declarations; downstream modules decide how to act on them.
Implementation Related guideprotobuf/metadata
Defines metric and aggregate descriptor options.
Use it when: Authoring schemas that must declare measures, dimensions, filters, and calculated members.
This module provides the wire vocabulary; metric execution lives elsewhere.
Implementation Related guideprotobuf/metric
Renders a message descriptor, constraints, metadata, and instructions into a form-filling prompt packet.
Use it when: A model must return one typed protobuf-shaped answer rather than free text.
It renders instructions and schema; generation and validation are separate steps.
Implementation Related guideprotobuf/prompt
Scores descriptor-declared quality dimensions with CEL and weights them into a result.
Use it when: A schema needs explicit measurable quality dimensions for a message.
Quality dimensions are CEL expressions combined using declared weights.
Implementation Related guideprotobuf/quality
Provides structured search metadata protobuf types with metadata, validation, and indexing annotations.
Use it when: Modeling SEO-style entities as governed protobuf messages.
Implementation Related guideprotobuf/seo
Defines reusable range, path, taxonomy, SKOS-style concept scheme, screening, postal, and access-policy protobuf types and rules.
Use it when: A schema needs structural ranges, tree paths, taxonomies, concept schemes, or access-policy types with declared validation rules.
Includes ConceptScheme, Concept, and ConceptRef with ConceptSchemeRules validation alongside DateRange, LongRange, and DoubleRange.
Implementation Related guideprotobuf/types
Validates protobuf messages from descriptor-declared validate.v1 rules and CEL constraints.
Use it when: A schema should carry its structural and cross-field data rules with it.
Use ProtoValidator directly or install it at the application boundary you want to enforce.
Implementation Related guideprotobuf/validation
Adapts ProtoValidator to the protovalidate conformance harness protocol.
Use it when: Validating compatibility work against the upstream conformance runner.
Use protobuf-validation for application validation; this module runs compatibility checks.
Implementation Related guideprotobuf/validation-conformance
Implements the Buf Protovalidate annotation vocabulary in ProtoMolt's Java runtime validation engine.
Use it when: Adopting schemas already annotated for the protovalidate dialect.
Its rule reader is discovered through ServiceLoader. ProtoMolt evaluates the rules in Java; Buf's schema definition is vendored with attribution.
Implementation Related guideprotobuf/validation-protovalidate
Implements a bidirectional worker task lifecycle with admission, evidence candidates, reviews, and transcripts.
Use it when: Work must remain pending until a coordinator explicitly accepts or revises a candidate.
It is an in-process coordinator library; applications mount its transport and authorization boundary.
Implementation Related guidetransform/delegation
Validates delegation messages, review records, and caller-defined typed deliverables without coordinator or persistence dependencies.
Use it when: Checking delegation requests or candidate deliverables against a declared protobuf contract in isolation.
Implementation Related guidetransform/delegation/contract
Replays delegation task lifecycles offline and defines the transcript storage interface.
Use it when: Reducing delegation events into task state or implementing a custom transcript repository.
Implementation Related guidetransform/delegation/lifecycle
Projects delegation transcripts into canonical signed-work-record manifests.
Use it when: Exporting a completed delegation task transcript as a verifiable receipt.
Pair with protomolt-receipt to sign or verify the resulting manifest.
Implementation Related guidetransform/delegation/receipt
Persists encrypted delegation transcripts through the repository document service.
Use it when: Saving and restoring delegation transcripts in repository storage with client-side AES-256-GCM encryption.
Requires a reachable repository service and an encryption key resolver.
Implementation Related guidetransform/delegation/repository
Reads and writes descriptor paths and parses a compact text mapping rule language.
Use it when: Use for direct message-to-message field copies, appends, removals, and Any-aware path access.
It reports absent optional paths differently from invalid paths.
Implementation Related guidetransform/mapper/core
Applies CEL filters and selectors through the protobuf field mapper.
Use it when: A field mapping rule needs a CEL filter or selector over protobuf descriptors and messages.
Shared CEL compilation and evaluation live in protomolt-cel; strict and try-map operations handle CEL failures differently.
Implementation Related guidetransform/mapper/cel
Extracts runtime metadata from message contents using named CEL selectors.
Use it when: Content-derived metadata must be selected and type-checked separately from descriptor annotations.
It complements meta.v1 metadata rather than replacing it.
Implementation Related guidetransform/mapper/metadata
Compiles typed workflow edges into a streaming-aware pipeline and runs them in process.
Use it when: A checked workflow needs execution across unary and streaming gRPC shapes.
External-completion pipeline steps are refused by the in-process executor.
Implementation Related guidetransform/pipeline
Builds target DynamicMessages from descriptor-declared source paths, CEL expressions, literals, and defaults.
Use it when: A target schema should own the provenance of each projected field.
Map target fields are explicitly unsupported; CEL source masks are lower bounds.
Implementation Related guidetransform/projection
Creates and verifies canonical signed work-record manifests with detached Ed25519 signatures.
Use it when: A workflow result needs portable evidence that can be verified offline.
The signature binds the issuer to the recorded manifest; the verifier applies the supplied trust policy.
Implementation Related guidetransform/receipt
Screens message fields selected by meta.v1 sensitivity classes and applies a declared outcome policy.
Use it when: Sensitive content must be masked, tagged, or refused before a downstream step.
Detection depends on the configured screening engine and policy.
Implementation Related guidetransform/screening
Infers schemas, merges schemas, joins messages, and synthesizes derived protobuf shapes.
Use it when: Integration output needs to become a real protobuf type instead of an untyped map.
The generated output is .proto source that can be compiled and governed.
Implementation Related guidetransform/shapes
Compiles and runs checked serial gRPC workflows with joins, deadlines, records, and replay support.
Use it when: A multi-call integration needs descriptor-checked edges and a recorded run.
A workflow is a composition library; choosing and operating remote services remains application work.
Implementation Related guidetransform/workflow
Coordinates validated workflow authoring tasks, candidate preparation, review, and recoverable launch of accepted workflows.
Use it when: An agent or caller authors a workflow under a deliverable contract and prepares it for authorized execution.
Implementation Related guidetransform/workflow/authoring
Defines the schema registry store SPI and in-memory store for versioned protobuf schemas, references, descriptor sets, and compatibility modes.
Use it when: Embedding an in-memory schema registry or implementing a custom registry storage provider.
The Git-backed store lives in protomolt-schema-registry-git; serving the registry over HTTP is the service module's role.
Implementation Related guideschema/registry/core
Defines the protobuf contract for content-addressed descriptor-set exchange.
Use it when: Generating clients or implementing a peer-to-peer descriptor exchange transport.
This module is contract-only; the registry's ordinary API is HTTP.
Implementation Related guideschema/registry/proto
Provides Apicurio descriptor loading and schema publishing for Quarkus applications.
Use it when: A Quarkus application uses Apicurio Registry as a descriptor source or publisher.
The deployment module supplies Quarkus build-time wiring.
Implementation Related guideschema/apicurio/runtime
Registers the Apicurio runtime integration with Quarkus at build time.
Use it when: Use with the Apicurio runtime module in a Quarkus extension build.
Include through the Quarkus extension to enable its build-time integration.
Implementation Related guideschema/apicurio/deployment
Loads protobuf descriptors from and publishes schemas to Confluent-compatible registry APIs.
Use it when: An application must exchange protobuf schemas with an existing Confluent registry.
Requires a reachable registry when resolving or publishing remote schemas.
Implementation Related guideschema/confluent
Implements the Git-backed schema registry store, pull-only remote federation, and workflow version repository.
Use it when: Persisting registered protobuf schemas, compatibility settings, and promoted workflows as commits in a local Git repository.
Discovered via SchemaRegistryStoreProvider; HTTP serving lives in protomolt-registry-service.
Implementation Related guideschema/registry/git
Implements the inference provider SPI against OpenAI-compatible chat-completions endpoints.
Use it when: A catalog model is served by a compatible HTTP API.
It is a chat provider and inherits the SPI's request and streaming contract.
Implementation Related guideinference/openai
Implements the inference provider SPI for OpenVINO-backed chat generation.
Use it when: A catalog model is reachable through the OpenVINO transport implementation.
The representative evidence is an opt-in live integration test.
Implementation Related guideinference/openvino
Supplies the model catalog, credential resolver, provider interface, and dispatch facade for chat generation.
Use it when: Adding a provider or invoking a cataloged model from Java.
Provider implementations support unary and streaming generation.
Implementation Related guideinference/spi
Coordinates model generation into one validated DynamicMessage with bounded repair attempts and provenance.
Use it when: A cataloged model must fill a descriptor-defined protobuf form.
It validates syntax and descriptor rules, while task-specific semantic acceptance still belongs to the caller or reviewer.
Implementation Related guideinference/structured
Routes characterized assets to transformations that derive useful renditions, including container member lists and dataset schemas.
Use it when: You want to inspect archive contents or derive a schema from supported delimited, NDJSON, or Avro data.
A format may declare an applicable transformation that the current engine cannot execute; engine lookup distinguishes the two.
Implementation Related guideasset/bridge
Adapts parser extraction into document-text and OCR-text renditions, with declared quality measurements for recovered text.
Use it when: You already have a ParserPluginService and want its output represented as an asset rendition.
Text extraction is supplied by the parser; this adapter does not bundle an OCR model.
Implementation Related guideasset/bridge-parse
Projects an archive entry and its version manifest into a flat catalog row annotated for search and metrics.
Use it when: You want to query stored classification, rendition counts, content classes, and measured quality without opening every asset.
Unmeasured quality is represented separately from a measured score of zero.
Implementation Related guideasset/catalog
Identifies formats from bounded byte windows, container contents, filenames, and published signature definitions, retaining the observed evidence.
Use it when: You need to distinguish a declared format from the format supported by the content.
Identification can remain unresolved when available evidence is insufficient.
Implementation Related guideasset/characterize
Defines typed file formats, content profiles, derived renditions, and classification states with validation annotations.
Use it when: You need to represent what an asset claims to be, what its bytes indicate, and whether those findings agree.
This module defines the contract; asset-characterize implements identification.
Implementation Related guideasset/proto
An in-memory cluster directory with optional persistent event records and delegation advertisements.
Use it when: You need processor discovery, capacity, heartbeat, and lease information for local or remote endpoints.
The directory runs in process; a host exposes its actions and supplies persistence.
Implementation Related guidemesh/cluster
Validation and schema-identity utilities for mesh envelopes.
Use it when: You need a gate before accepting or forwarding an envelope whose descriptor identity and integrity must be checked.
Implementation Related guidemesh/contracts
Protobuf contracts for mesh envelopes, headers, schema references, claim checks, and processing options.
Use it when: Defining data that can be validated and described consistently between mesh components.
Implementation Related guidemesh/proto
Configurable text chunking with sentence-aware packing and extension points for chunking strategies.
Use it when: You need a gate before embedding or indexing document text in smaller retrieval units.
Implementation Related guidesearch/chunk
An embedding-provider SPI and a mapper that chooses text fields from an indexing plan.
Use it when: You want to add vectors to documents without hard-coding field selection.
Implementation Related guidesearch/embedding/core
A comparison harness for checking cosine similarity across two embedding providers for the same model.
Use it when: You want to evaluate whether two serving paths produce comparable vectors.
Implementation Related guidesearch/embedding/harness
An embedding provider backed by OpenNLP Model2Vec models.
Use it when: Embeddings should run in the Java process from a compatible Model2Vec model.
Implementation Related guidesearch/embedding/model2vec
An embedding provider for OpenVINO Model Server through KServe v2 gRPC.
Use it when: Embeddings are served by OpenVINO Model Server.
Implementation Related guidesearch/embedding/ovms
An embedding provider for a Hugging Face Text Embeddings Inference gRPC service.
Use it when: Embeddings are served by TEI.
Implementation Related guidesearch/embedding/tei
A Lucene mapper that turns descriptor index hints into fields and indexed documents.
Use it when: Use it for the built-in Lucene search role or direct Lucene indexing.
Implementation Related guidesearch/index/lucene
A descriptor-aware NDJSON writer for indexing documents outside the built-in search role.
Use it when: You want to export protobuf messages as newline-delimited JSON for another indexing system.
Implementation Related guidesearch/index/ndjson
An OpenSearch mapper and client-side search helpers for descriptor-driven documents.
Use it when: OpenSearch is the chosen external index.
The mapper is available; full platform write wiring is still in progress.
Implementation Related guidesearch/index/opensearch
A descriptor indexer that produces indexing plans and validates protobuf payloads against declared rules.
Use it when: You want to convert a protobuf schema and message into a portable search representation.
Implementation Related guidesearch/index/protobuf
A Qdrant point mapper, schema generator, and gRPC sink for vector documents.
Use it when: You want to map vectors and metadata to a Qdrant collection.
The mapper is available; full platform write wiring is still in progress.
Implementation Related guidesearch/index/qdrant
A Solr mapper and schema generator for descriptor-driven documents.
Use it when: You want to generate Solr fields and map documents from protobuf schemas.
The mapper is available; full platform write wiring is still in progress.
Implementation Related guidesearch/index/solr
Descriptor-driven indexing contracts and ServiceLoader extension points for search backends.
Use it when: Adding an index mapper or translating protobuf schemas into search fields.
Implementation Related guidesearch/index/spi
A ServiceLoader SPI for reranking a query and a candidate list.
Use it when: You want to add a reranker behind a common Java interface.
The mounted Lucene search service does not call a rerank provider; the OpenSearch adapter's RerankedSemanticSearch composes one over its query results.
Implementation Related guidesearch/rerank/core
A comparison harness for measuring agreement between two reranking providers.
Use it when: You want to evaluate rerankers serving the same model.
Implementation Related guidesearch/rerank/harness
A reranking provider for an OpenVINO Model Server REST endpoint.
Use it when: Reranking is exposed by OpenVINO Model Server.
Implementation Related guidesearch/rerank/ovms
A reranking provider for Hugging Face Text Embeddings Inference gRPC.
Use it when: A TEI service supplies a reranking endpoint.
Implementation Related guidesearch/rerank/tei
An S3-backed snapshot store for Lucene search indexes.
Use it when: A search role needs to save or restore index snapshots in S3-compatible storage.
Snapshot storage is experimental.
Implementation Related guidesearch/snapshot-s3
Runs compiled aggregate queries over Iceberg-backed Parquet through DuckDB and provides rollup writing.
Use it when: Metrics live in Iceberg tables rather than the interactive search index.
Tables with delete files are refused.
Implementation Related guidemetric/iceberg
Builds descriptor-declared metric mappings and checks aggregate queries before an engine runs them.
Use it when: You want to add a metric backend or validate a metric query in process.
It is an SPI, so an executor is required to return results.
Implementation Related guidemetric/spi
Writes validated bundles of named files to a directory or deterministic in-memory ZIP.
Use it when: A renderer has produced files that must be delivered as one checked bundle.
Built-in delivery targets include local directories and in-memory ZIP archives; use protomolt-emit-git for Git repository delivery.
Implementation Related guidesink/emit/core
Delivers validated file bundles as commits to a Git repository.
Use it when: A rendered bundle of files should be committed directly to a Git branch.
Extends protomolt-emit with JGit-backed repository delivery.
Implementation Related guidesink/emit/git
Renders descriptors or a registry into an Open Knowledge Format Markdown bundle.
Use it when: You want to publish a human-readable schema catalogue from protobuf descriptors.
It is a renderer; choose a bundle sink separately.
Implementation Related guidesink/emit/okf
Writes protobuf messages as descriptor-driven Parquet without generated message classes.
Use it when: You want to create Parquet files from dynamic protobuf messages.
It writes files; storage is supplied by another module.
Implementation Related guidesink/emit/parquet
Uploads ProtoMolt Parquet output to S3-compatible object storage.
Use it when: Parquet output must be written directly to an S3-compatible endpoint.
Requires S3 endpoint and credentials from the host application.
Implementation Related guidesink/emit/parquet-s3
Creates descriptor-driven Iceberg schemas and appends ProtoMolt Parquet data to tables.
Use it when: You want to make typed protobuf records available as Iceberg table snapshots.
Equality deletes and variant columns are not supported.
Implementation Related guidesink/iceberg
Configures Iceberg catalog access through S3-compatible storage.
Use it when: An Iceberg catalog stores table data in S3-compatible object storage.
Pair with the Iceberg sink to write records into the configured catalog.
Implementation Related guidesink/iceberg-s3
Supplies Kafka Connect source and sink connectors plus protobuf-aware validation, mapping, redaction, and CEL transforms.
Use it when: You want to move Kafka topic records into gRPC services or feed a topic from a gRPC server stream.
The source connector owns durable resume-token handling.
Implementation Related guidesink/kafka/connect
Provides a Kafka Connect sink that writes topic batches as Iceberg snapshots.
Use it when: Kafka records should land in Iceberg through the Connect runtime.
Delivery is at least once.
Implementation Related guidesink/kafka/connect-iceberg
Provides a Kafka Connect sink that maps topic records into OpenSearch documents.
Use it when: You want to index validated protobuf topic records in OpenSearch.
It relies on the search-index mapping SPI.
Implementation Related guidesink/kafka/connect-opensearch
Provides a Kafka protobuf serde that checks declared schema rules when writing records.
Use it when: Use it for Kafka producers, consumers, or Streams that need Confluent framing and protobuf validation.
A schema registry endpoint is required for schema-id resolution.
Implementation Related guidesink/kafka/serde
Exports Kafka protobuf serde measurements through Micrometer.
Use it when: A host already uses Micrometer and needs serde counters and timing.
It is an observability binding for the serde SPI.
Implementation Related guidesink/kafka/serde-micrometer
Encodes and decodes the Confluent protobuf wire frame.
Use it when: Integrating a protobuf producer or consumer with Confluent-framed Kafka records.
Pair with the serde library for registry lookup and record serialization.
Implementation Related guidesink/kafka/wire
Defines the action catalog, request contracts, scopes, budgets, and one dispatch path.
Use it when: You want to expose a descriptor-backed operation consistently to MCP, HTTP, CLI, and gRPC hosts.
A host supplies callers, authorization, and the action set.
Implementation Related guidesurface/actions
Contributes index-mapping rendering actions to a ProtoMolt action catalog.
Use it when: A host wants catalog actions that render search index mappings from descriptors.
Discovered through ActionProvider when present on the classpath.
Implementation Related guidesurface/actions/index
Supplies schema-source resolution and action contract providers for action callers.
Use it when: Catalog actions need to compile or resolve schema sources supplied in action requests.
Discovered through ActionContractProvider and SchemaResolverProvider.
Implementation Related guidesurface/actions/schema
Contributes core protobuf compilation, validation, mapping, diff, and shape actions to an action catalog.
Use it when: A host wants the standard protobuf toolkit verbs registered in its action catalog.
Discovered through ActionProvider when present on the classpath.
Implementation Related guidesurface/actions/toolkit
Loads access policies and resolves callers from stored credentials or OIDC introspection.
Use it when: A host needs policy-backed caller identity and console sessions.
The host decides which resolver chain to install.
Implementation Related guidesurface/authz
Applies callers, scopes, and budgets to gRPC services through an interceptor.
Use it when: You want to enforce ProtoMolt access policy on a gRPC server.
Scope assignments are host policy.
Implementation Related guidesurface/authz-grpc
Stores authorization principals in PostgreSQL for deployments without an identity provider.
Use it when: A deployment wants database-backed API credentials and principals.
Requires PostgreSQL and Flyway-managed tables.
Implementation Related guidesurface/authz-jdbc
Exposes a supplied action catalog as a descriptor-driven gRPC service without full platform assembly.
Use it when: Mounting an action catalog on a gRPC server with custom service descriptors.
Implementation Related guidesurface/grpc/adapter
Checks outbound gRPC targets, TLS, deadlines, and concurrency against host policy.
Use it when: You want to constrain dynamic outbound gRPC calls in a running host.
It does not impose payload limits or recheck resolved addresses.
Implementation Related guidesurface/grpc/channel-policy
Calls and reflects gRPC services dynamically from protobuf descriptors, including streaming methods.
Use it when: A client must inspect or call a gRPC service without generated stubs.
A host chooses the channel and endpoint policy.
Implementation Related guidesurface/grpc/invoke
Compiles the descriptor-defined ProtoMolt service contract at class load for servers and clients to share.
Use it when: Embedding the typed ProtoMolt service definition without also running its server.
It is a contract library; a separate host serves the methods.
Implementation Related guidesurface/grpc/service-contract
Stores gRPC service profiles and content-addressed descriptor artifacts for workflow work.
Use it when: Workflows need a saved, named service contract and endpoint profile.
Credential and trust reference fields are not implemented for transport.
Implementation Related guidesurface/grpc/service-profile
Registers, inspects, refreshes, and invokes reflected gRPC services as catalog actions.
Use it when: You want to turn a reachable reflected gRPC service into typed tools for a caller or agent.
Registers reflected services and their method descriptions for subsequent calls.
Implementation Related guidesurface/grpc/service-workspace
Provides client and server gRPC interceptors that enforce declared protobuf rules at call boundaries.
Use it when: You want to reject invalid protobuf requests or responses at a gRPC boundary.
Rules come from the message descriptors on the application classpath.
Implementation Related guidesurface/grpc/validation
Exports gRPC validation measurements through Micrometer.
Use it when: Use it with the gRPC validation interceptor in a Micrometer-enabled host.
It is an optional metrics implementation.
Implementation Related guidesurface/grpc/validation-micrometer
Defines descriptor-grounded workflow, artifact, and run-evidence contracts with filesystem repositories.
Use it when: Embedding the workflow contract and its evidence storage outside a server.
Use the workflow runtime to execute the stored definitions.
Implementation Related guidesurface/grpc/workflow
Serves the Connect protocol with binary protobuf over in-process gRPC services on the JDK HTTP server.
Use it when: Browser or HTTP clients need unary and server-streaming Connect binary protobuf calls against in-process gRPC services.
Supports binary protobuf message framing; Connect error and end-of-stream frames use the protocol's standard JSON envelopes.
Implementation Related guidesurface/http/connect
Transcodes protobuf messages to and from typed or dynamic JSON.
Use it when: An HTTP or tool host needs protobuf JSON conversion.
Implementation Related guidesurface/http/json
Generates JSON Schema draft 2020-12 from descriptors and recognized constraints.
Use it when: A JSON caller needs the same basic bounds a protobuf contract declares.
It does not model oneofs or emit meta.v1 descriptions.
Implementation Related guidesurface/http/jsonschema
Generates OpenAPI 3 documents from service descriptors.
Use it when: You want to publish an OpenAPI description for mechanically exposed service methods.
It does not read validation rules and uses proto2 required labels only.
Implementation Related guidesurface/http/openapi
Provides a framework-neutral REST gateway with token requirements and shared error mapping.
Use it when: You want to mount selected gRPC methods as REST endpoints in a host.
REST exposure is selected by Java annotation, not by a protobuf option.
Implementation Related guidesurface/http/rest
Implements MCP JSON-RPC session handling, workspace resources, and stdio transport over a supplied action catalog.
Use it when: Exposing a custom action catalog over MCP without bundling the full platform toolset.
Implementation Related guidesurface/mcp/transport
Confluence content model and crawler that emit document changes to a supplied sink.
Use it when: You want to collect a defined Confluence content tree into an intake pipeline.
The crawler covers selected Confluence content types and writes to a caller-supplied sink.
Implementation Related guideacquire/confluence
A bounded source SPI for consuming gRPC streams and Kafka topics into a synchronous pipeline.
Use it when: Documents arrive continuously rather than through a batch pull.
Implementation Related guideacquire/connector
An SPI for gathering .proto files from filesystems and JARs before compiling them.
Use it when: Schemas come from local source trees or packaged artifacts.
Implementation Related guideacquire/gather/core
A Git-backed .proto gatherer that clones or updates a repository and stages its schemas.
Use it when: You want to compile schemas kept in a Git repository.
Implementation Related guideacquire/gather/git
A Maven-backed .proto gatherer that resolves an artifact and extracts schemas from its JAR.
Use it when: Schemas are published as Maven artifacts.
Implementation Related guideacquire/gather/maven
A JDBC pull connector that turns rows from a watermark query into stable JSON documents for intake.
Use it when: You want to import a table or query result from a JDBC source.
Implementation Related guideacquire/jdbc
A Microsoft Graph client and content model for collecting selected Microsoft 365 resources.
Use it when: Building a Graph-backed connector or crawler.
Incremental checkpoints and some content types are still in progress.
Implementation Related guideacquire/msgraph
Shared pull-connector support that assigns stable document identities and submits documents to intake.
Use it when: Writing an S3, JDBC, or similar batch connector.
Implementation Related guideacquire/pull
An S3 pull connector that detects new or changed objects using a watermark and submits them to intake.
Use it when: You want to import a bounded S3 bucket scan into a document pipeline.
Implementation Related guideacquire/s3
Typed document, page, layout, and text projections, including a Docling-compatible projection.
Use it when: A parser needs to return a structured document result.
Implementation Related guideparse/document
Implements the parts-based repository v2 DocumentService save, read, link, stream, upload, and outbox handlers over stacks and the catalog.
Use it when: Running or embedding the v2 DocumentService over write-once stacks and the PostgreSQL catalog.
Composes protomolt-repo-admission, protomolt-repo-stack, and protomolt-repo-catalog.
Implementation Related guiderepo/accession
Validates repository document schemas and payloads, extracting typed document links and SKOS concept references without storage or transport dependencies.
Use it when: Checking document schemas, link fields (link = 59100551), and concept references before admitting a document revision.
Implementation Related guiderepo/admission
Implements ArchiveService and ArchiveMutationService over v2 repository documents: archive definitions, stats, entry and rendition calls read and write through DocumentService.
Use it when: Serving archive entry and rendition operations backed by the v2 parts-based document store.
In-tree library and gRPC service implementation. Archive definitions are CORE-only v2 documents in the archive-def:<account_id> graph, and GetArchiveStats scans live documents for exact counts. ClassifyEntry, BridgeEntry and the ListEntries classification_state filter run over classification stored in each entry's CORE. DeleteRendition and PruneVersions are refused with FAILED_PRECONDITION under keep-forever retention after the archive and live entry are found. Stock hosts mount DocumentArchiveGrpcService and DocumentArchiveMutationGrpcService on gRPC, and POST /v1/archive:upload writes through the same DocumentArchive.
Implementation Related guiderepo/archive
Decorates a BlobStore with read-through and write-through caching while forwarding streamed reads to the backing store.
Use it when: Pairing S3 object storage with a bounded Redis cache for repository blobs.
Implementation Related guiderepo/blob/cache
Implements the repository BlobStore SPI over Redis with configurable TTL and object size bounds.
Use it when: Using Redis as a cache tier behind CachingBlobStore or for bounded non-streamed blob storage.
Standalone Redis blob storage does not implement streamed reads required by v2 stacks; use s3-redis-cache for v2.
Implementation Related guiderepo/blob/redis
Implements the repository BlobStore SPI over S3-compatible object storage with verified writes, bounded reads, and exact-version reclamation.
Use it when: Storing repository document parts, raw blobs, and archive objects in S3-compatible storage.
Implementation Related guiderepo/blob/s3
Defines provider-neutral byte storage, capability, namespace provisioning, and reclamation contracts without SDK dependencies.
Use it when: Implementing or consuming a repository byte storage backend.
Implementation Related guiderepo/blob/spi
Stores parts-based repository v2 document revisions, part references, links, concept tags, outcomes, and transactional outbox events in PostgreSQL.
Use it when: Managing the PostgreSQL catalog for the v2 parts-based document store.
Implementation Related guiderepo/catalog
Splits protobuf documents into descriptor-driven parts (CORE, BLOBS, CHUNKS, PARSED) and reassembles them without storage provider dependencies.
Use it when: Encoding, decoding, or inspecting document parts and segmentation digests in memory.
Implementation Related guiderepo/codec
Provides the PostgreSQL drive, reader-host, and managed-backend storage ledger for repository operations.
Use it when: Managing drive records, reader-host registration, or managed-backend ledger state in PostgreSQL.
Document part encoding lives in protomolt-repo-codec, and byte storage providers live in protomolt-repo-blob-spi and its adapters.
Implementation Related guiderepo/container
Implements drive operations and provisioning over the container ledger and selected byte storage, plus archive read and write admission, independent of transport.
Use it when: Running repository drive operations or archive admission without coupling to a specific gRPC server.
Implementation Related guiderepo/engine
Resolves and caches descriptor sets from a schema registry for repository document admission.
Use it when: Connecting repository schema admission to a versioned schema registry store.
Implementation Related guiderepo/schema/registry
Defines repository caller identity, access policy, credential binding, and archive/drive repository interfaces.
Use it when: Implementing repository storage adapters or enforcing caller access policies.
Implementation Related guiderepo/spi
Implements write-once stacks over BlobStore with streamed puts that return a StackRef and verified streamed reads.
Use it when: Writing and reading immutable content-verified part stacks for the v2 document store.
Implementation Related guiderepo/stack
Loads typed configuration documents and swaps only validated updates into a live host.
Use it when: You want to make access policy, trust, taxonomy, or postal data reloadable without restarting a host.
A ConfigSource supplies updates.
Implementation Related guidehost/config
Reads typed configuration documents from a compacted Kafka topic.
Use it when: Configuration changes are distributed through Kafka rather than registry polling.
Requires Kafka, the house serde, and a schema registry.
Implementation Related guidehost/config-kafka
Reads typed configuration documents from the Git-backed registry HTTP API.
Use it when: A registry commit should be the versioned source of host configuration.
Requires a reachable registry service.
Implementation Related guidehost/config-registry
Account messages, account lifecycle RPCs, and account-event payloads.
Use it when: Build a client for account creation, listing, or activation.
Contract definitions and generated types; the running service is a separate module.
Implementation Related guideaccount/proto
Defines delegation task, offer, candidate, review, and action protobuf contracts.
Use it when: Sharing delegation wire messages and generated Java types without coordinator dependencies.
Contract definitions and generated types; lifecycle and coordinator logic live in sibling modules.
Implementation Related guidetransform/delegation/proto
Generation, model discovery, capability, usage, and structured-result messages for inference clients and providers.
Use it when: Share typed model requests and responses without depending on an inference server implementation.
Contract definitions and generated types; the running service is a separate module.
Implementation Related guideinference/proto
Document-ingest requests and responses, including the framed client-streaming ingestion contract.
Use it when: Submit documents to an intake service using a generated protobuf client.
Contract definitions and generated types; the running service is a separate module.
Implementation Related guideintake/proto
Workflow-run request and lifecycle event messages for asynchronous job submission and observation.
Use it when: Produce workflow requests or consume job lifecycle events through Kafka.
Message definitions only; job operations are exposed through catalog actions rather than a service in this proto.
Implementation Related guidejobs/proto
Metric mapping discovery, aggregate query, and rollup rebuild request and response messages.
Use it when: Build a typed client for descriptor-declared metrics.
Contract definitions and generated types; the running service is a separate module.
Implementation Related guidemetric/proto
The parsing coordinator and parser plugin contracts, including routing and streamed parser messages.
Use it when: Implement a parser plugin or call the coordinator from another application.
Contract definitions and generated types; the running service is a separate module.
Implementation Related guideparse/proto
Defines the parts-based document store (repo.v2), document links (link = 59100551), drive, archive, rendition, and event contracts.
Use it when: Integrate with parts-based document storage, typed document links, or versioned archive operations.
Contract definitions and generated types; the running services live in protomolt-repo-accession and protomolt-repo-service.
Implementation Related guiderepo/proto
Typed indexing and search requests, query lanes, stored-value results, and subject discovery.
Use it when: Build a client for the Java search service or implement its service contract.
Contract definitions and generated types; the running service is a separate module.
Implementation Related guidesearch/proto