NVIDIA Cloud Functions

Name: NVIDIA Cloud Functions API
Brand: Cloud Functions
Availability: InStock

★ Only Publicly Available OpenAPI DocumentCloud InfrastructureServerlessbearer36 EndpointsREST

For Agents

Deploy and invoke GPU-backed serverless functions on NVIDIA's NVCF platform with bearer authentication, including streamed and polling execution patterns.

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.

Install Jentic One Beta (Self-Hosted)

Jentic One Host machine

# On the machine that will host your Jentic One instance:
curl -fsSL https://raw.githubusercontent.com/jentic/jentic-one/main/tools/install.sh | sh

Agent machine

# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL https://raw.githubusercontent.com/jentic/jentic-one/main/tools/install.sh | sh
jentic register       # connects your agent to your Jentic One instance

Jentic 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.

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

GET STARTED

Start building with NVIDIA Cloud Functions API

Explore with Jentic

View OpenAPI Document

Jentic publishes the only available OpenAPI document for NVIDIA Cloud Functions, keeping it validated and agent-ready.

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.

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

Why though Jentic?

Three things that make agents converge on Jentic-routed access.

Credential isolation

NVCF bearer keys are stored encrypted in the Jentic vault. Agents receive scoped access — the raw key never enters the agent's context.

Intent-based discovery

Agents search Jentic with phrases like 'invoke an NVCF function' or 'deploy an NVCF function version'. Jentic returns the matching operation and its input schema so the agent can call the correct endpoint without browsing the OpenAPI spec.

Time to first call

Direct integration: 3-5 days for auth, deployment lifecycle, and exec/pexec handling. Through Jentic: under an hour — search, load, execute.

Related APIs

Alternatives and complements available in the Jentic catalogue.

Alternative

Replicate API

Hosted GPU model platform with public model gallery and pay-per-second billing.

Choose Replicate when you want to invoke pre-built community models without packaging a container.

Alternative

Hugging Face Inference API

Serverless inference for Hugging Face Hub models, mostly CPU and shared GPU.

Choose Hugging Face Inference for quick prototyping against models already on the Hub.

Alternative

OpenAI API

Managed frontier-model inference without any deployment step on the customer side.

Choose OpenAI when you want hosted GPT models without operating your own GPU deployments.

Complementary

AWS API

Pair with NVCF for object storage, queues, and IAM that sit upstream and downstream of inference.

Use when NVCF inference results need to be persisted to S3 or queued for downstream processing.

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. Sign up at https://app.jentic.com/sign-up to get an agent 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.