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.
114 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
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 and internet-format strings.
Use it when: Validation or application code needs email, hostname, IP, URI, date, encoding, 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, screening, postal, and access-policy protobuf types.
Use it when: A schema needs these structural values with declared validation rules.
Range types are DateRange, LongRange, and DoubleRange; not every numeric index kind has its own message.
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
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
Compiles and evaluates CEL expressions over protobuf descriptors and messages.
Use it when: A mapping, validation, or projection requires an expression instead of a direct path.
Strict and try-map operations intentionally 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
Stores versioned protobuf schemas, references, descriptor sets, compatibility modes, and registry configuration.
Use it when: Embedding a registry behind either an in-memory store or a local Git repository.
Git storage is local repository storage; serving it 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 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 built-in search role does not yet wire reranking into its request path.
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, Git repository, 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 Git repositories.
Implementation Related guidesink/emit/core
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
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
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
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
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 currently covers selected content types and needs 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
The portable archive-container codec and blob-store abstractions used by repository documents.
Use it when: Reading, writing, caching, or moving document parts independently of a repository deployment.
Implementation Related guiderepo/container
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
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
Document, drive, archive, rendition, and event contracts for repository clients.
Use it when: Integrate with document storage or versioned archive operations.
Contract definitions and generated types; the running service is a separate module.
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