Nvcf Nvidia NVIDIA Cloud Functions
Community OpenAPI document · agent-readyCloud InfrastructureServerlessbearer36 EndpointsREST
Know of an official OpenAPI document? Contribute it →
For Agents
Deploy and invoke GPU-backed serverless functions on NVIDIA's NVCF platform with bearer authentication, including streamed and polling execution patterns.
Use for: I need to deploy an LLM container on NVCF GPU capacity, Invoke a deployed NVCF function and stream the response, Submit a long-running inference job and poll for its result, List all my deployed function versions
Not supported: Does not handle model training, dataset storage, or non-GPU compute - use for serverless GPU function deployment and invocation only.
NVIDIA Cloud Functions (NVCF) is a serverless GPU runtime that lets teams package containers and trained models as functions and invoke them through HTTP and streamed responses. The 36-endpoint API covers the full lifecycle: registering a function and version, deploying it onto GPU capacity, calling it via the polling-execute (pexec) and synchronous-execute (exec) paths, listing deployments, and tearing them down. It targets workloads such as LLM inference, image and video generation, and ML training pipelines that need on-demand GPU compute without managing the underlying cluster.
Install Jentic One Beta
Connect the NVIDIA Cloud Functions to your agent
Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the NVIDIA Cloud Functions, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.
Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.
1
Step 1: Jentic One Host machine
# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fnvcf.nvidia.com%2Fnvidia-cloud-functions" | sh2
Step 2: Agent machine
# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fnvcf.nvidia.com%2Fnvidia-cloud-functions" | sh
jentic register # connects your agent to your Jentic One instanceJentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.
Capabilities
What an agent can do with NVIDIA Cloud Functions API.
Register new functions and versions to wrap containers or models for invocation
Deploy a function version onto GPU capacity with configurable scaling parameters
Invoke a function synchronously through the exec endpoints for low-latency calls
Invoke a function via pexec for long-running jobs that return a status URL to poll
Update a deployment's scaling configuration and tear down deployments when idle
Stream responses from generative model functions back to the caller
Use Cases
Patterns agents use NVIDIA Cloud Functions API for, with concrete tasks.
★ Serverless LLM Inference
Run an open-source LLM behind an HTTP endpoint without managing a GPU cluster. Wrap the model server in a container, register it as a function version, deploy it onto NVCF capacity, and invoke it via /v2/nvcf/exec for low-latency requests or /v2/nvcf/pexec for batched jobs. Deployment is typically a few hours from a working container image, and idle deployments can be torn down to control cost.
Call POST /v2/nvcf/deployments/functions/{functionId}/versions/{functionVersionId} with the chosen GPU type, then POST /v2/nvcf/exec/functions/{functionId} with a prompt payload and return the completion.
Long-Running Generative Jobs
Handle workloads such as video generation or batched embeddings where individual jobs take minutes by using the pexec invocation pattern. The API returns an invocation id and a status URL the caller polls until the result is ready, freeing the client from holding open connections. This is well suited to creative pipelines and offline ML batch jobs.
POST /v2/nvcf/pexec/functions/{functionId} with the input payload, then poll the returned status URL every five seconds until completion and return the result.
Cost-Aware Deployment Lifecycle
Keep GPU spend in check by deploying functions only when needed and tearing them down on a schedule or when traffic drops. The deployment endpoints support create, retrieve, update, and delete on a function-version pair, so a controller process can run scale-to-zero or off-hours teardown logic. Pair with monitoring on invocation counts to drive the policy.
List deployments, identify any with zero invocations in the last hour, and DELETE /v2/nvcf/deployments/functions/{functionId}/versions/{functionVersionId} for each match.
Agent-Driven Inference Routing
Let an AI agent route incoming requests to the right NVCF deployment - for example picking a small fast model for short prompts and a larger one for complex prompts - by listing deployments and invoking the appropriate function. Through Jentic, the agent searches by intent and gets only the operations it needs, with credentials handled by the platform.
Search Jentic for 'invoke an NVCF function', load the operation, and call the chosen function id with the user's prompt.
Key Endpoints
36 endpoints — nvidia cloud functions (nvcf) is a serverless gpu runtime that lets teams package containers and trained models as functions and invoke them through http and streamed responses.
METHOD
PATH
DESCRIPTION
POST
/v2/nvcf/deployments/functions/{functionId}/versions/{functionVersionId}
Deploy a function version onto GPU capacity
GET
/v2/nvcf/deployments/functions/{functionId}/versions/{functionVersionId}
Get function deployment details
PUT
/v2/nvcf/deployments/functions/{functionId}/versions/{functionVersionId}
Update a function deployment
DELETE
/v2/nvcf/deployments/functions/{functionId}/versions/{functionVersionId}
Delete a function deployment
POST
/v2/nvcf/exec/functions/{functionId}
Invoke a function synchronously
POST
/v2/nvcf/pexec/functions/{functionId}
Invoke a function with polling-execute
POST
/v2/nvcf/deployments/functions/{functionId}/versions/{functionVersionId}
Deploy a function version onto GPU capacity
GET
/v2/nvcf/deployments/functions/{functionId}/versions/{functionVersionId}
Get function deployment details
PUT
/v2/nvcf/deployments/functions/{functionId}/versions/{functionVersionId}
Update a function deployment
DELETE
/v2/nvcf/deployments/functions/{functionId}/versions/{functionVersionId}
Delete a function deployment
POST
/v2/nvcf/exec/functions/{functionId}
Invoke a function synchronously
POST
/v2/nvcf/pexec/functions/{functionId}
Invoke a function with polling-execute
Why Jentic?
What agents get from Jentic-routed access to this vendor.
Setup
Wiring NVIDIA Cloud Functions by hand means setting up its bearer key auth against api.nvcf.nvidia.com and handling the deployment and invocation request plumbing yourself. Through Jentic you install once, import NVIDIA Cloud Functions from the API Directory, store the key once, and your agent calls it.
Permission scoping
NVCF puts the function id and version id in the URL path (/v2/nvcf/deployments/functions/{functionId}/versions/{functionVersionId}), so a rule can pin your agent to the operations it needs on one function: it can invoke and read while a destructive operation like delete is not included unless you add it. You choose the operations it may call.
Credential isolation
Your NVCF bearer key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
Intent-based discovery
Agents search Jentic by intent such as 'invoke an NVCF function' or 'deploy an NVCF function version', and Jentic returns the matching NVCF operation with its input schema so the agent calls the right endpoint without browsing the reference docs.
Related APIs
Alternatives and complements available in the Jentic catalogue.
FAQs
Specific to using NVIDIA Cloud Functions API through Jentic.
What authentication does the NVIDIA Cloud Functions API use?
The API uses bearer-token authentication. You generate an API key in NVIDIA's NGC portal and pass it in the Authorization header as 'Bearer <key>' on every call. Through Jentic, the bearer key is stored encrypted in the vault and injected at execution time.
When should I use exec versus pexec?
Use POST /v2/nvcf/exec/functions/{functionId} for short, latency-sensitive calls where you can hold the connection open. Use POST /v2/nvcf/pexec/functions/{functionId} for long-running jobs - it returns an invocation id and a status URL you poll until the result is ready.
What are the rate limits for NVCF?
The spec does not embed explicit limits; throughput is governed by the GPU capacity attached to each deployment. If your workload bursts, scale the deployment via PUT /v2/nvcf/deployments/functions/{functionId}/versions/{functionVersionId} or split traffic across versions.
How do I tear down an idle deployment through Jentic?
Run pip install jentic, then search for 'delete an NVCF deployment'. Jentic returns DELETE /v2/nvcf/deployments/functions/{functionId}/versions/{functionVersionId} with its input schema; pass the function and version ids and execute. Run it through Jentic One, the self-hosted execution layer, to get an agent API key.
Can I host my own container on NVCF?
Yes - the function-and-version model wraps a container image. Register a function, register a version that points at your image, then deploy it onto GPU capacity. The exec and pexec endpoints route requests into the container's HTTP server.
Can I limit what my agent is allowed to do with the NVIDIA Cloud Functions API?
Yes. Because you run Jentic One yourself, your own rules decide which NVCF operations and credentials the agent may use, and NVCF puts the function id and version id in the URL path, so you can pin the agent to one function. You can allow it to invoke via POST /v2/nvcf/exec/functions/{functionId} and POST /v2/nvcf/pexec/functions/{functionId} and read deployment details with GET on the deployment path, while leaving out the destructive DELETE on /v2/nvcf/deployments/functions/{functionId}/versions/{functionVersionId} unless you add it. You choose the operations it may call and the bearer key it may use.
GET STARTED