Schema intelligence
Gather and compile proto sources at runtime. Resolve descriptors from Git, Maven, jars, filesystems, and schema registries. Compare versions with typed compatibility findings.
Descriptor-first protobuf infrastructure
Protocol Buffers at runtime.
ProtoMolt loads schemas, validates and transforms messages, exposes dynamic services, and keeps schema history in Git. Everything works from protobuf descriptors, without requiring generated classes.
Java 21+
Apache-2.0
Full protovalidate conformance
Lucene, OpenSearch, Solr, Microsoft Graph
Start with one command.
The demo starts the gRPC service with reflection, a JSON/REST gateway, Swagger UI, the MCP endpoint, the console, and a Git-backed registry with a sample schema already loaded.
docker run -p 8080:8080 -p 9090:9090 ghcr.io/ai-pipestream/protomolt-serve --demo
Explore the console
localhost:8080/console
Try the REST API
localhost:8080/docs
Inspect gRPC
grpcurl -plaintext localhost:9090 list
Prefer a local process? Release archives need only a JRE 21+ installation. See all run options.
One model for the full schema lifecycle.
ProtoMolt treats descriptors and their metadata as operational inputs. The same schema can guide validation, compatibility, transformation, transport, indexing, and service discovery.
Runtime interoperability
Work with DynamicMessage as naturally as generated types. Reflect on live gRPC services, invoke methods without stubs, and expose operations through Java, gRPC, REST, MCP, and Kafka Connect.
Policy-aware metadata
Carry validation, sensitivity, JSON, and indexing intent on protobuf descriptors. Build integrations from declared schema policy instead of duplicating it in each downstream system.
Measured compatibility
Full protovalidate conformance
The complete v1.2.2 suite passes, 2,872 of 2,872 cases, and CI re-scores it with Buf's own conformance runner.
Included integration Protobuf-native search indexingDescriptor hints drive documents and schema artifacts for Lucene, OpenSearch, Solr, and Microsoft Graph search, including vector and HNSW configuration.
Use the pieces you need.
ProtoMolt is a collection of focused Java modules under one BOM. Start with descriptor loading or validation, then add registry, API, search, streaming, or code-generation support without adopting a monolith.
Descriptors and source gathering
Load descriptor sets or compile proto text gathered from directories, jars, Git repositories, Maven coordinates, Confluent-compatible registries, and Apicurio Registry.
Registry and compatibility
Store schema subjects and versions as Git commits, serve the Confluent subjects protocol, gate writes by compatibility mode, and retrieve binary descriptor sets for runtime consumers.
Validation and metadata
Validate protovalidate-annotated schemas unchanged, with the complete upstream conformance suite passing. Read declared metadata for sensitivity, mapping, JSON representation, and downstream indexing policy, and act on it — masking fields by sensitivity class, whether removed, redacted, or AES-GCM encrypted.
Mapping, shapes, and chains
Reshape messages with text rules and CEL, derive and merge message shapes, infer schemas from structured data, and verify typed compositions of gRPC calls — including keyed joins over two live streams — before execution.
Search and streaming integration
Map protobuf messages directly for Lucene, OpenSearch, Solr, and Microsoft Graph search, or emit engine-neutral NDJSON. Drive dynamic gRPC methods from Kafka topics and feed topics from server streams, with protobuf-aware validation, mapping, and filtering as in-pipeline transforms.
Apache Iceberg tables
Convert descriptors to Iceberg table schemas and back, and commit batches of messages as real table snapshots written by ProtoMolt's own Hadoop-free Parquet emitter. Per-file column metrics let engines prune scans; tables can partition by identity, time, bucket, or truncate; an S3FileIO path reaches any S3-compatible store; and a Kafka Connect sink lands topics as snapshots.
Microsoft Graph
Read and write OneDrive and SharePoint files and list-item metadata, and register agentless Copilot connectors — all over the public Microsoft Graph REST API, with no Microsoft SDK and no Windows agent. Graph search is the fourth target for the same indexing hints.
Emit bundles and columnar files
Render schemas into file bundles delivered to a caller-named sink — a directory, a Git commit, or an in-memory zip — including an Open Knowledge Format renderer for agent-consumable documentation and a descriptor-driven Parquet emitter that carries zero Hadoop jars.
Dynamic APIs and code generation
Reflect on and invoke live gRPC services without generated stubs. Serve a descriptor-native API over gRPC and REST, expose it to agents through MCP, or generate clients in process. The generators run libprotoc compiled to WebAssembly, so there is no native protoc toolchain to install.
Embeddings and reranking
Fill a message's vector field from its text field as part of the indexing plan, backed by a static engine, a Hugging Face inference server, or an OpenVINO model server, and rerank results the same way. A pairwise harness certifies that two providers of one model agree, by cosine for embeddings and by rank correlation for reranking, before either is trusted in a pipeline.
Data-quality scoring
Declare quality dimensions on a message as weighted CEL expressions and get back a composite score. It is separate from validation: validation decides whether a message is admissible, quality measures how good it is, and the Kafka serde can score it on write and optionally gate on the result.
Agent and command-line surfaces
The same action catalog runs as an Agent Client Protocol agent inside editors like Zed and JetBrains, and as a command-line tool with an interactive console. Streaming verbs render as they produce output, so an agent watches a long operation unfold instead of waiting for it to finish.
A shared capability model
Choose the interface, not a separate implementation.
Twenty-three verbs are described as typed actions with machine-readable input and output schemas. Hosts adapt that one catalog to the interface that fits the caller, while the descriptor-driven implementation stays the same.
JavaFocused library modules and SPIs
gRPCTyped service with reflection
RESTJSON gateway, OpenAPI, Swagger UI
MCPTools and schema resources for agents
Kafka ConnectSource, sink, and transforms
ConsoleDescriptor-driven exploration and operations
See what the descriptors know.
The console is built into the server. Browse subjects and versions, inspect message types and declared options, compare schema changes, validate messages, merge schemas, run chains, or connect a live gRPC service.
Point an agent at a live gRPC server.
Over MCP, the gRPC verbs compose into something an agent can drive on its own. It reflects a running service, falls back to the registry when reflection is turned off, invokes methods with no generated stubs, and generates a native client when it needs one.
Video · coming soon
ProtoMolt over MCP
An agent reflects a live inference server, reads its tensor contract, and runs it with no generated code, following the OpenVINO tutorial step by step.
Library first when you need it.
The bundled server is the fastest way to explore ProtoMolt. The same capabilities are available as ordinary Java dependencies for embedding into an existing service.
Gather proto sources and resolve descriptors at runtime
ProtoGatherer gatherer = GitProtoGatherer.builder()
.repo("https://github.com/acme/schemas.git")
.ref("main")
.subdir("proto")
.build();
var descriptors = DescriptorRegistry.create();
descriptors.addLoader(
new GatheringDescriptorLoader(gatherer)
);Add only the modules your application uses
dependencies {
implementation platform(
'ai.pipestream:protomolt-bom:<version>'
)
implementation(
'ai.pipestream:protomolt-descriptors'
)
implementation(
'ai.pipestream:protomolt-mapper-cel'
)
}Built in the open
Read the code. Run the tests. Try the server.
ProtoMolt is Apache-2.0-licensed. Its standard build covers the module suite, and dedicated CI exercises protovalidate conformance and live schema-registry integrations.