What you get for free
- · Connection form in the Management UI (from authSchema)
- · Operation picker on CONNECTOR nodes
- · Automatic path parameter extraction
- · Shared ClientManager pool per connection
- · Secret-ref resolution (vault://, aws-sm://, etc.)
VectorFlowApp is a platform you can own — Java SDK, YAML-driven connector definitions, OpenAPI 3.1 export for every contract, and a native MCP server. No proprietary DSL, no lock-in.
Pick the right surface for the integration you're building. All four coexist in the same gateway; nothing requires a rewrite as your needs grow.
A 40-line file defines a REST connector. Auth block, operations list, authSchema for the UI form. Gateway loads it at boot.
Implement Connector + ConnectorProvider, drop the shaded jar into plugins/. Classloader isolation ensures packs don't collide.
Every contract becomes an MCP tool via JSON-RPC. Protocol 2025-06-18. Any MCP-aware client works out of the box.
Every contract has a spec. Download or fetch, pipe into Postman, Redoc, SDK generators — no manual YAML authoring.
Most REST integrations are a base URL, an auth header, and a list of operations. That's all YAML. Drop the file in connector-definitions/, restart the gateway, and the connector appears in the Flow Builder.
id: my-api
name: My API
category: business
baseUrl: https://api.myapi.com/v1
auth:
type: bearer
header: Authorization
prefix: "Bearer "
authSchema:
- key: password
label: API Key
placeholder: sk-...
secret: true
required: true
operations:
- id: listItems
method: GET
path: /items
- id: createItem
method: POST
path: /items
contentType: application/jsonTwo interfaces, one service file, done. The plugin loader discovers your JAR at startup, runs start() once, routes execute() for each flow step, and calls stop() on shutdown.
public class MyConnector implements Connector {
private WebClient webClient;
@Override public String id() { return "my-connector"; }
@Override public Future<Void> start(ConnectorRuntime runtime) {
this.webClient = WebClient.create(runtime.vertx());
return Future.succeededFuture();
}
@Override public Future<ConnectorResponse> execute(
ConnectorRequest request,
ConnectorConfig config,
ExecutionContext ctx) {
String op = request.operation();
JsonObject payload = request.payload();
return webClient.postAbs(config.getString("baseUrl") + "/" + op)
.putHeader("Authorization", "Bearer " + config.getString("password"))
.sendJsonObject(payload)
.map(resp -> ConnectorResponse.ok(resp.bodyAsJsonObject(), null));
}
@Override public Future<Void> stop() {
if (webClient != null) webClient.close();
return Future.succeededFuture();
}
}public class MyConnectorProvider implements ConnectorProvider {
@Override public String connectorId() { return "my-connector"; }
@Override public MyConnector create() { return new MyConnector(); }
@Override public ConnectorMetadata metadata() {
return new ConnectorMetadata(
"my-connector", "My Connector",
"Description", List.of("op1", "op2"));
}
}Create src/main/resources/META-INF/services/com.vectorflowapp.connector.sdk.ConnectorProvider:
com.example.myconnector.MyConnectorProvider./mvnw package
cp target/my-connector-*.jar /path/to/vectorflowapp/plugins/
# restart the gatewayEvery enabled API contract in your organization is automatically exposed as a Model Context Protocol tool. Any MCP client — Claude Desktop, Cursor, Cline — speaks to one endpoint and gets the full catalog.
curl -X POST 'https://your-gateway/management/api/v1/mcp?org=YOUR_ORG_ID' \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'Read the full MCP server guideEvery API contract has a canonical OpenAPI 3.1 spec. Download it from the Management UI or fetch it over HTTP and pipe into any OpenAPI-aware tool — Postman, Redoc, Stoplight, an SDK generator.
# Per-contract
curl http://localhost:8080/management/api/v1/api-contract/get/$CONTRACT_ID/openapi \
> contract.openapi.json
# Whole partner, one version
curl 'http://localhost:8080/management/api/v1/partner/DEMO/openapi?version=v1' \
> partner.openapi.json
# Generate a Python client from the spec
openapi-generator-cli generate -i partner.openapi.json -g python -o ./clientNarrow scope: one spec per endpoint, downloadable from the contract edit page.
Merged spec covering every contract under a partner + API version.
Uses Swagger Json31 writer — no noisy nulls, extensions flattened to x-* keys.
Auth runs on the gateway — before any connector step executes. Contracts carry a policy list; policies compose. JWT today, API keys today, schema validation today.
Configure multiple JWKS issuers per organization. Contracts opt in via auth_provider_codes. Required scopes and forwarded claims per policy.
Static key check at a configurable header name. Rotation and hashing on the roadmap; keys are stored encrypted today.
Per-contract JSON Schema applied to request body or query parameters before the pipeline runs. Rejects with a configurable status.
Connection credentials accept vault://, aws-sm://, gcp-sm://, azure-kv:// references. Resolved at runtime through SecretResolver.
The native SDK is Java. For non-Java logic inside a flow, use the Script Service node — GraalVM JavaScript runs inside the flow with access to request/response stage data.
Each plugin JAR loads in its own URLClassLoader, parented to the SDK classloader. Transitive dependencies don't collide across packs.
Vert.x 5 on JDK 21, deployed as a Spring Boot application. Hazelcast provides clustering; MongoDB is the configuration store with change streams for hot reload.
Docker-based. A docker-compose file and a sample helm chart ship with the repository. The management UI is a separate Next.js-style deployable.
Connection password fields support literal values and reference strings (vault://, aws-sm://, gcp-sm://, azure-kv://). References are resolved at runtime and never logged.
Tell us about the systems you connect and the automations you need. We will walk through what VectorFlowApp ships today and how it fits your stack.