DOCA Flow gRPC Server (doca_flow_grpc)
CRITICAL transport-security correction (Run-12 + R13). The
shipped doca_flow_grpc / doca_flow_grpc_client
binaries hard-code the gRPC plaintext credentials surface:
the server uses grpc::InsecureServerCredentials() (the
C++ gRPC server-side API in tools/flow_grpc_server/server/);
the C++ client uses
grpc::InsecureChannelCredentials() (the C++ gRPC
client-side API; the client lives in
libs/doca_flow/grpc/client/, compiled into the
doca_flow library, NOT under tools/flow_grpc_client/);
the Python
client uses grpc.aio.insecure_channel(...). Do NOT cite the
server-side string as grpc::InsecureChannelCredentials() —
that is the client-side API name and a Grep-against-source
verification will fail. There
is no TLS, no mTLS, and no token-auth knob on the shipped
control plane today. Any prose below (or in CAPABILITIES.md
/ TASKS.md) that frames "mTLS / token auth / TLS posture"
as a configurable knob on this server is the bundle's
previous aspirational framing and is wrong against the shipped
source. Treat the server as plaintext-on-a-trusted-segment
only: it MUST be bound on a control-plane-only network
segment behind an external proxy, sidecar, or VPN
that itself enforces TLS + identity. Any "TLS / mTLS / token-
auth" discussion below is about the operator's external
hardening layer, NOT a knob on this binary. Routing for an
TLS / identity design discussion must stay on the selected
external proxy, sidecar, or VPN; never route it to a
shipped-today binary knob.
Where to start: This is a tool skill for standing up and
operating doca_flow_grpc, the DOCA-shipped gRPC remote-
control surface for doca-flow. Open TASKS.md and
start at ## configure to decide whether a
remote control plane is the right answer at all (vs talking to
libdoca_flow.so directly), then ## run for
the start → bind → one-client-smoke sequence, then
## test for the smoke-before-bulk loop that
gates any RPC that mutates Flow / dataplane state. Open
CAPABILITIES.md when the question is what
the gRPC contract surface looks like (the .proto files shipped
under the tool's source tree on the user's install), which
external proxy / sidecar / VPN protects the plaintext server, which language bindings
the gRPC ecosystem covers, or how to interpret the server's
own logs alongside the live Flow application's logs. If DOCA is
not installed, route to
doca-setup first; if the user has
not stood up doca-flow yet, route to
doca-flow FIRST — the gRPC
server is a remote control plane on top of the Flow library, not
a replacement for it.
Example questions this skill answers well
The CLASSES of doca_flow_grpc questions this skill is
built to answer, each with one worked example. The class is the
load-bearing piece; the worked example is one instance.
- "Do I actually need a remote control plane for my Flow
pipeline, or should my client just link
libdoca_flow.so
directly?" — worked example: "my client is a Python
service on a different host; can it program Flow rules
remotely?". Answered by the when-to-use-gRPC decision in
CAPABILITIES.md ## Capabilities and modes
- the routing into
doca-flow when a direct
library link is the better answer.
- "Where is the gRPC contract surface actually defined on my
install?" — worked example: "I want to generate a Python
client; where do I get the
.proto file?". Answered by the
the-.proto-file-is-the-source-of-truth rule in
CAPABILITIES.md ## Capabilities and modes
- the language-bindings discussion of standard gRPC tooling
(
protoc + the language-specific gRPC plugin per the
official gRPC docs on grpc.io).
- "How do I harden the gRPC endpoint so it isn't an open
door into my dataplane?" — worked example: "the server is
bound on
0.0.0.0; what should I do before exposing it?".
Answered by the admin attack surface posture in
CAPABILITIES.md ## Safety policy
- the external protection / network-segment decision in
TASKS.md ## configure.
- "How do I smoke ONE client end-to-end before opening the
server to the fleet?" — worked example: "my Python client
can dial the endpoint; what is the first RPC I run to prove
it talks to the live Flow application?". Answered by the
smoke-before-bulk loop in
TASKS.md ## test +
CAPABILITIES.md ## Safety policy
smoke-before-bulk rule.
- "My client cannot reach the server — is the server down,
the wrong endpoint, an external-proxy mismatch, or a version
mismatch?" — worked example: "the client times out
connecting". Answered by the layered error taxonomy in
CAPABILITIES.md ## Error taxonomy
- the layered ladder in
TASKS.md ## debug.
- "Is my non-C++ client (Python / Go / Rust) actually the
right shape for the gRPC contract, or is there a cleaner
path?" — worked example: "I want a Rust client; what
does the
.proto-generated API look like?". Answered by the
language-bindings discussion in
CAPABILITIES.md ## Capabilities and modes
- the routing through standard gRPC tooling.
Audience
This skill serves external operators, control-plane developers,
and AI agents who need to program a running DOCA Flow pipeline
from a non-C++ process across a network boundary instead of
linking libdoca_flow.so directly into the controlling process.
Concretely:
- A control-plane engineer writing a Python / Go / Rust client
that programs Flow rules on a BlueField from outside the
BlueField's address space.
- A platform operator running a Flow-using service on
BlueField who wants to expose a remote-control surface to a
centralized control plane.
- An AI agent driving the "can I program these Flow rules
from this client / this network position" triage step
before recommending a code change to the surrounding
doca-flow application.
It is not for users debugging the gRPC server's source code,
not a substitute for the live public DOCA Flow gRPC Server
guide on docs.nvidia.com, and not the place to learn the
doca-flow API — that audience belongs in
doca-flow.
doca_flow_grpc is a single CLI binary built from the DOCA
source tree (executable('doca_flow_grpc', ..., install: false)
in tools/flow_grpc_server/meson.build, gated by
flag_enable_grpc_support), plus its companion .proto
contract files under libs/doca_flow/grpc/; per the tool's
source tree (server/, dpa_device/, packet_buffering/) the
tool can also be paired with a packet-buffering / DPA-side
helper on configurations that need them. The skill uses the
same kind: tool three-file shape (SKILL.md + CAPABILITIES.md + TASKS.md) the rest of the bundle's tool slot uses — front matter at the top of this file already says kind: tool. (Prior bundle revisions said "library three-file shape" here; that wording was internally inconsistent with the front matter and is corrected.)
Language scope
This skill governs deployment, configuration, hardening, and
client-side bring-up across the languages standard gRPC tooling
covers — Python, Go, C++, Rust, Java, Node.js, C#, Kotlin, Ruby,
PHP, Dart — via the language-specific gRPC plugin generated
from the shipped .proto files (see the
gRPC language support index
on grpc.io). The server itself is C++ + DOCA; the client
languages are open, gated only by the standard protoc plugin
set. For the doca-flow API the server programs, see
doca-flow — that surface is
C-language.
When to load this skill
Load this skill when the user is — or the agent needs to — bring
up doca_flow_grpc against a running doca-flow
application (or its preconditions) and connect a non-C++ client
to it. Concretely:
- Deciding whether a remote gRPC control plane is the right
surface (vs a direct
libdoca_flow.so link in the client
process).
- Locating the
.proto files on the user's install so a
language-binding client can generate the appropriate
stubs.
- Deciding the deployment's transport-security posture and
network segment. NOTE: the shipped server is plaintext-only
(
grpc::InsecureServerCredentials()); TLS / mTLS / token-auth
are NOT binary configuration knobs — they are external
infrastructure concerns handled by a capable proxy, sidecar,
or VPN, and the
plaintext endpoint must stay on a trusted, isolated segment.
- Standing up the server alongside a known-good Flow setup
and smoke-testing one client end-to-end before exposing
the endpoint to the fleet.
- Diagnosing a connect / version / RPC failure through the
layered taxonomy.
Do not load this skill for general DOCA orientation,
doca-flow API work, DOCA install, or general gRPC tooling
(use the grpc.io docs directly for those).
What this skill provides
This is a thin loader. Substantive material lives in two
companion files:
CAPABILITIES.md — what doca_flow_grpc exposes:
the gRPC remote-control surface in front of doca-flow,
the .proto-files-as-authoritative-contract rule (the
shipped .proto files under the tool's source on the
user's install are the source of truth), the when-to-use-
gRPC vs direct-library-link decision, the language-
bindings story (any language standard gRPC tooling covers),
the external proxy / sidecar / VPN and network-segment decision, the
packet-buffering / DPA-side option per the shipped
packet_buffering/ and dpa_device/ subtrees, the
version overlay (server rides the doca-flow library
version it links against), the layered error taxonomy
(server-not-started / server-binding-failed / external-layer-
rejected / RPC-call-error / Flow-precondition-failed /
version / cross-cutting), the observability surface (the
server's own logs + the live Flow application's logs +
the RPC client's status codes), and the safety policy
that treats the endpoint as an admin attack surface.
TASKS.md — step-by-step workflows for the in-scope task
verbs: install (route to setup; binary is built from
source with gRPC support enabled),
configure (decide remote-vs-direct, pick the external
proxy / sidecar / VPN and network segment), build (route to install),
modify (refuse — modify the deployment, not the binary),
run (start → bind → smoke), test (the
smoke-before-bulk loop with the client-side stub
generation step), debug (the layered diagnosis ladder),
use (the agent-side workflow for consuming a captured
gRPC server session), plus a Deferred task verbs block
and a Command appendix.
The skill assumes a host where DOCA is already installed (or
the NGC DOCA container is running) with the Flow library
present, a working doca-flow application to program against,
and the operator's awareness that exposing a gRPC control plane
is a high-stakes posture.
What this skill deliberately does not ship
This skill is agent guidance, not a samples or scripts
bundle. To keep the boundary clean, it deliberately does not
contain — and pull requests should not add:
- Verbatim RPC method names, message field inventories, or
default endpoint paths. The
.proto files shipped under
the tool's source tree on the user's install are the
authoritative contract; copying them here pins the skill
to one release and silently rots when the contract
evolves.
- Pre-baked client code in any language. The
language-specific gRPC plugin + the shipped
.proto files
are the contract; client code generated from them on the
user's installed version is the right answer, not a stub
pinned to a snapshot.
- A pre-baked external security-layer configuration. CA,
token, and mTLS configuration belong to the selected proxy,
sidecar, or VPN and its security review, never to
doca_flow_grpc.
- Wrappers, parsers, or scripts that proxy the gRPC
endpoint into another protocol. The endpoint is the
endpoint; if a user wants HTTP/JSON instead, that is a
separate concern outside this skill's scope.
- A
samples/, bindings/, or reference/ subtree.
Even one labeled "reference" is misleading: operators
will read it as buildable.
Loading order
- Read this
SKILL.md first to confirm the user's question
is in scope (the user actually wants a remote gRPC control
plane on top of doca-flow, not a direct library link or
a different DOCA library).
- For what the server exposes, the
.proto-as-contract
rule, the language-bindings story, the external proxy /
sidecar / VPN and network-segment decision, version availability, the
layered error surface, observability, and safety posture,
see CAPABILITIES.md.
- For the documented start sequence and the
smoke-before-bulk workflow —
install, configure,
build, modify, run, test, debug, use — see
TASKS.md.
Related skills
doca-flow — the base
library the server's gRPC contract is a thin remote-
control wrapper over. Pipe / entry / rule semantics, the
validate-before-commit rule, the Flow counter / inspector
surface all live there.
doca-flow-tune — the Flow
tuning tool. When a Flow-program change is recommended,
the change can be applied through the surrounding
application or — when the control plane is remote —
through this gRPC server's RPC surface.
doca-public-knowledge-map
— routing to the public DOCA Flow gRPC Server page on
docs.nvidia.com and the rest of the public DOCA
documentation set.
doca-version — canonical
version-handling rules. The
## Version compatibility
section in this skill is a thin overlay on top.
doca-debug — the cross-cutting
debug ladder. gRPC server failures route into the ladder at
the runtime layer.
doca-setup — env preparation,
install verification, and the NGC DOCA container path.
doca-hardware-safety —
the cross-cutting hardware-safety meta-policy this skill's
## Safety policy overlays. Any state-changing RPC is a
potential dataplane-affecting change and must respect the
meta-policy.
1---2license: Apache-2.03name: doca-flow-grpc-server4description: >5 PLAINTEXT-ONLY: the shipped `doca_flow_grpc` server uses6 `grpc::InsecureServerCredentials()` with NO TLS / mTLS / token-auth7 knob on the binary — transport security must come from external8 infrastructure (e.g. an mTLS proxy / sidecar) on a trusted segment.9 Use this skill when bringing up, configuring, hardening, or10 debugging `doca_flow_grpc` — the DOCA-shipped gRPC remote-control11 surface in front of `doca-flow` that lets non-C++ clients (Python,12 Go, Rust, Java) program Flow pipes and entries over RPC instead of13 linking `libdoca_flow.so` directly. Trigger even when the user14 doesn't say 'doca-flow-grpc-server' or 'gRPC' — e.g. 'program Flow15 rules from Python on another host', 'remotely configure pipes on the16 BlueField', 'client times out connecting to the Flow server', 'where17 is the .proto for Flow', 'UNAUTHENTICATED / FAILED_PRECONDITION on a18 Flow RPC'. Route elsewhere for the underlying doca-flow API, generic19 gRPC tooling (protoc, language bindings), or DOCA install / BFB20 bring-up.21metadata:22 source: https://skillmd.com/skills/nvidia/doca-flow-grpc-server23 kind: tool24compatibility: >25 Requires DOCA on Linux (Ubuntu 22.04/24.04 or RHEL/SLES) with a26 BlueField DPU or ConnectX NIC. The `doca_flow_grpc` binary is a build27 artifact (install: false in tools/flow_grpc_server/meson.build, gated by28 flag_enable_grpc_support + flag_enable_grpc_flow_library) — NOT29 installed under a default DOCA path; build it from the DOCA source tree30 with gRPC enabled. Its `.proto` lives under libs/doca_flow/grpc/.31 Confirm Flow via `pkg-config doca-flow`.3233---3435# DOCA Flow gRPC Server (`doca_flow_grpc`)3637> **CRITICAL transport-security correction (Run-12 + R13).** The38> shipped `doca_flow_grpc` / `doca_flow_grpc_client`39> binaries hard-code the gRPC plaintext credentials surface:40> the **server** uses **`grpc::InsecureServerCredentials()`** (the41> C++ gRPC server-side API in `tools/flow_grpc_server/server/`);42> the **C++ client** uses43> **`grpc::InsecureChannelCredentials()`** (the C++ gRPC44> client-side API; the client lives in45> `libs/doca_flow/grpc/client/`, compiled into the46> `doca_flow` library, NOT under `tools/flow_grpc_client/`);47> the **Python48> client** uses `grpc.aio.insecure_channel(...)`. Do NOT cite the49> server-side string as `grpc::InsecureChannelCredentials()` —50> that is the **client-side** API name and a Grep-against-source51> verification will fail. There52> is **no TLS, no mTLS, and no token-auth** knob on the shipped53> control plane today. Any prose below (or in `CAPABILITIES.md`54> / `TASKS.md`) that frames "mTLS / token auth / TLS posture"55> as a configurable knob on **this** server is the bundle's56> previous aspirational framing and is wrong against the shipped57> source. Treat the server as **plaintext-on-a-trusted-segment58> only**: it MUST be bound on a control-plane-only network59> segment behind an external proxy, sidecar, or VPN60> that itself enforces TLS + identity. Any "TLS / mTLS / token-61> auth" discussion below is about the operator's external62> hardening layer, NOT a knob on this binary. Routing for an63> TLS / identity design discussion must stay on the selected64> external proxy, sidecar, or VPN; never route it to a65> shipped-today binary knob.6667**Where to start:** This is a tool skill for standing up and68operating `doca_flow_grpc`, the DOCA-shipped gRPC remote-69control surface for `doca-flow`. Open [`TASKS.md`](TASKS.md) and70start at [`## configure`](TASKS.md#configure) to decide whether a71remote control plane is the right answer at all (vs talking to72`libdoca_flow.so` directly), then [`## run`](TASKS.md#run) for73the start → bind → one-client-smoke sequence, then74[`## test`](TASKS.md#test) for the smoke-before-bulk loop that75gates any RPC that mutates Flow / dataplane state. Open76[`CAPABILITIES.md`](CAPABILITIES.md) when the question is *what77the gRPC contract surface looks like* (the `.proto` files shipped78under the tool's source tree on the user's install), *which79external proxy / sidecar / VPN protects the plaintext server*, *which language bindings80the gRPC ecosystem covers*, or *how to interpret the server's81own logs alongside the live Flow application's logs*. If DOCA is82not installed, route to83[`doca-setup`](../../doca-setup/SKILL.md) first; if the user has84not stood up `doca-flow` yet, route to85[`doca-flow`](../../libs/doca-flow/SKILL.md) FIRST — the gRPC86server is a remote control plane on top of the Flow library, not87a replacement for it.8889## Example questions this skill answers well9091The CLASSES of `doca_flow_grpc` questions this skill is92built to answer, each with one worked example. The class is the93load-bearing piece; the worked example is one instance.9495- **"Do I actually need a remote control plane for my Flow96 pipeline, or should my client just link `libdoca_flow.so`97 directly?"** — worked example: *"my client is a Python98 service on a different host; can it program Flow rules99 remotely?"*. Answered by the *when-to-use-gRPC* decision in100 [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)101 + the routing into102 [`doca-flow`](../../libs/doca-flow/SKILL.md) when a direct103 library link is the better answer.104- **"Where is the gRPC contract surface actually defined on my105 install?"** — worked example: *"I want to generate a Python106 client; where do I get the `.proto` file?"*. Answered by the107 *the-`.proto`-file-is-the-source-of-truth* rule in108 [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)109 + the language-bindings discussion of standard gRPC tooling110 (`protoc` + the language-specific gRPC plugin per the111 [official gRPC docs](https://grpc.io/docs/) on `grpc.io`).112- **"How do I harden the gRPC endpoint so it isn't an open113 door into my dataplane?"** — worked example: *"the server is114 bound on `0.0.0.0`; what should I do before exposing it?"*.115 Answered by the *admin attack surface* posture in116 [`CAPABILITIES.md ## Safety policy`](CAPABILITIES.md#safety-policy)117 + the external protection / network-segment decision in118 [`TASKS.md ## configure`](TASKS.md#configure).119- **"How do I smoke ONE client end-to-end before opening the120 server to the fleet?"** — worked example: *"my Python client121 can dial the endpoint; what is the first RPC I run to prove122 it talks to the live Flow application?"*. Answered by the123 smoke-before-bulk loop in124 [`TASKS.md ## test`](TASKS.md#test) +125 [`CAPABILITIES.md ## Safety policy`](CAPABILITIES.md#safety-policy)126 smoke-before-bulk rule.127- **"My client cannot reach the server — is the server down,128 the wrong endpoint, an external-proxy mismatch, or a version129 mismatch?"** — worked example: *"the client times out130 connecting"*. Answered by the layered error taxonomy in131 [`CAPABILITIES.md ## Error taxonomy`](CAPABILITIES.md#error-taxonomy)132 + the layered ladder in133 [`TASKS.md ## debug`](TASKS.md#debug).134- **"Is my non-C++ client (Python / Go / Rust) actually the135 right shape for the gRPC contract, or is there a cleaner136 path?"** — worked example: *"I want a Rust client; what137 does the `.proto`-generated API look like?"*. Answered by the138 language-bindings discussion in139 [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)140 + the routing through standard gRPC tooling.141142## Audience143144This skill serves **external operators, control-plane developers,145and AI agents who need to program a running DOCA Flow pipeline146from a non-C++ process across a network boundary** instead of147linking `libdoca_flow.so` directly into the controlling process.148Concretely:149150- A control-plane engineer writing a Python / Go / Rust client151 that programs Flow rules on a BlueField from outside the152 BlueField's address space.153- A platform operator running a Flow-using service on154 BlueField who wants to expose a remote-control surface to a155 centralized control plane.156- An AI agent driving the *"can I program these Flow rules157 from this client / this network position"* triage step158 before recommending a code change to the surrounding159 doca-flow application.160161It is **not** for users debugging the gRPC server's source code,162**not** a substitute for the live public DOCA Flow gRPC Server163guide on `docs.nvidia.com`, and **not** the place to learn the164`doca-flow` API — that audience belongs in165[`doca-flow`](../../libs/doca-flow/SKILL.md).166167`doca_flow_grpc` is a **single CLI binary built from the DOCA168source tree** (`executable('doca_flow_grpc', ..., install: false)`169in `tools/flow_grpc_server/meson.build`, gated by170`flag_enable_grpc_support`), plus its companion `.proto`171contract files under `libs/doca_flow/grpc/`; per the tool's172source tree (`server/`, `dpa_device/`, `packet_buffering/`) the173tool can also be paired with a packet-buffering / DPA-side174helper on configurations that need them. The skill uses the175same `kind: tool` three-file shape (`SKILL.md` + `CAPABILITIES.md` + `TASKS.md`) the rest of the bundle's tool slot uses — front matter at the top of this file already says `kind: tool`. (Prior bundle revisions said "library three-file shape" here; that wording was internally inconsistent with the front matter and is corrected.)176177## Language scope178179This skill governs deployment, configuration, hardening, and180client-side bring-up across the languages standard gRPC tooling181covers — Python, Go, C++, Rust, Java, Node.js, C#, Kotlin, Ruby,182PHP, Dart — via the language-specific gRPC plugin generated183from the shipped `.proto` files (see the184[gRPC language support](https://grpc.io/docs/languages/) index185on `grpc.io`). The server itself is C++ + DOCA; the client186languages are open, gated only by the standard `protoc` plugin187set. For the `doca-flow` API the server programs, see188[`doca-flow`](../../libs/doca-flow/SKILL.md) — that surface is189C-language.190191## When to load this skill192193Load this skill when the user is — or the agent needs to — bring194up `doca_flow_grpc` against a running `doca-flow`195application (or its preconditions) and connect a non-C++ client196to it. Concretely:197198- Deciding whether a remote gRPC control plane is the right199 surface (vs a direct `libdoca_flow.so` link in the client200 process).201- Locating the `.proto` files on the user's install so a202 language-binding client can generate the appropriate203 stubs.204- Deciding the deployment's transport-security posture and205 network segment. NOTE: the shipped server is plaintext-only206 (`grpc::InsecureServerCredentials()`); TLS / mTLS / token-auth207 are NOT binary configuration knobs — they are external208 infrastructure concerns handled by a capable proxy, sidecar,209 or VPN, and the210 plaintext endpoint must stay on a trusted, isolated segment.211- Standing up the server alongside a known-good Flow setup212 and smoke-testing one client end-to-end before exposing213 the endpoint to the fleet.214- Diagnosing a connect / version / RPC failure through the215 layered taxonomy.216217Do **not** load this skill for general DOCA orientation,218`doca-flow` API work, DOCA install, or general gRPC tooling219(use the [grpc.io](https://grpc.io/) docs directly for those).220221## What this skill provides222223This is a **thin loader**. Substantive material lives in two224companion files:225226- `CAPABILITIES.md` — what `doca_flow_grpc` exposes:227 the gRPC remote-control surface in front of `doca-flow`,228 the `.proto`-files-as-authoritative-contract rule (the229 shipped `.proto` files under the tool's source on the230 user's install are the source of truth), the *when-to-use-231 gRPC vs direct-library-link* decision, the language-232 bindings story (any language standard gRPC tooling covers),233 the external proxy / sidecar / VPN and network-segment decision, the234 packet-buffering / DPA-side option per the shipped235 `packet_buffering/` and `dpa_device/` subtrees, the236 version overlay (server rides the `doca-flow` library237 version it links against), the layered error taxonomy238 (server-not-started / server-binding-failed / external-layer-239 rejected / RPC-call-error / Flow-precondition-failed /240 version / cross-cutting), the observability surface (the241 server's own logs + the live Flow application's logs +242 the RPC client's status codes), and the safety policy243 that treats the endpoint as an admin attack surface.244- `TASKS.md` — step-by-step workflows for the in-scope task245 verbs: `install` (route to setup; binary is built from246 source with gRPC support enabled),247 `configure` (decide remote-vs-direct, pick the external248 proxy / sidecar / VPN and network segment), `build` (route to install),249 `modify` (refuse — modify the deployment, not the binary),250 `run` (start → bind → smoke), `test` (the251 smoke-before-bulk loop with the client-side stub252 generation step), `debug` (the layered diagnosis ladder),253 `use` (the agent-side workflow for consuming a captured254 gRPC server session), plus a `Deferred task verbs` block255 and a `Command appendix`.256257The skill assumes a host where DOCA is already installed (or258the NGC DOCA container is running) with the Flow library259present, a working `doca-flow` application to program against,260and the operator's awareness that exposing a gRPC control plane261is a high-stakes posture.262263## What this skill deliberately does not ship264265This skill is **agent guidance**, not a samples or scripts266bundle. To keep the boundary clean, it deliberately does not267contain — and pull requests should not add:268269- **Verbatim RPC method names, message field inventories, or270 default endpoint paths.** The `.proto` files shipped under271 the tool's source tree on the user's install are the272 authoritative contract; copying them here pins the skill273 to one release and silently rots when the contract274 evolves.275- **Pre-baked client code in any language.** The276 language-specific gRPC plugin + the shipped `.proto` files277 are the contract; client code generated from them on the278 user's installed version is the right answer, not a stub279 pinned to a snapshot.280- **A pre-baked external security-layer configuration.** CA,281 token, and mTLS configuration belong to the selected proxy,282 sidecar, or VPN and its security review, never to283 `doca_flow_grpc`.284- **Wrappers, parsers, or scripts** that proxy the gRPC285 endpoint into another protocol. The endpoint is the286 endpoint; if a user wants HTTP/JSON instead, that is a287 separate concern outside this skill's scope.288- **A `samples/`, `bindings/`, or `reference/` subtree.**289 Even one labeled *"reference"* is misleading: operators290 will read it as buildable.291292## Loading order2932941. Read this `SKILL.md` first to confirm the user's question295 is in scope (the user actually wants a remote gRPC control296 plane on top of `doca-flow`, not a direct library link or297 a different DOCA library).2982. **For what the server exposes, the `.proto`-as-contract299 rule, the language-bindings story, the external proxy /300 sidecar / VPN and network-segment decision, version availability, the301 layered error surface, observability, and safety posture,302 see [CAPABILITIES.md](CAPABILITIES.md).**3033. **For the documented start sequence and the304 smoke-before-bulk workflow — `install`, `configure`,305 `build`, `modify`, `run`, `test`, `debug`, `use` — see306 [TASKS.md](TASKS.md).**307308## Related skills309310- [`doca-flow`](../../libs/doca-flow/SKILL.md) — the **base311 library** the server's gRPC contract is a thin remote-312 control wrapper over. Pipe / entry / rule semantics, the313 validate-before-commit rule, the Flow counter / inspector314 surface all live there.315- [`doca-flow-tune`](../doca-flow-tune/SKILL.md) — the Flow316 tuning tool. When a Flow-program change is recommended,317 the change can be applied through the surrounding318 application or — when the control plane is remote —319 through this gRPC server's RPC surface.320- [`doca-public-knowledge-map`](../../doca-public-knowledge-map/SKILL.md)321 — routing to the public DOCA Flow gRPC Server page on322 `docs.nvidia.com` and the rest of the public DOCA323 documentation set.324- [`doca-version`](../../doca-version/SKILL.md) — canonical325 version-handling rules. The326 [`## Version compatibility`](CAPABILITIES.md#version-compatibility)327 section in this skill is a thin overlay on top.328- [`doca-debug`](../../doca-debug/SKILL.md) — the cross-cutting329 debug ladder. gRPC server failures route into the ladder at330 the runtime layer.331- [`doca-setup`](../../doca-setup/SKILL.md) — env preparation,332 install verification, and the NGC DOCA container path.333- [`doca-hardware-safety`](../../doca-hardware-safety/SKILL.md) —334 the cross-cutting hardware-safety meta-policy this skill's335 `## Safety policy` overlays. Any state-changing RPC is a336 potential dataplane-affecting change and must respect the337 meta-policy.