Nvcf Nvidia 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.

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.

Step 1: 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

Step 2: 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

GET STARTED

Start building with NVIDIA Cloud Functions API

Explore with Jentic

View OpenAPI Document

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

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.

Nvcf Nvidia NVIDIA Cloud Functions

Connect the NVIDIA Cloud Functions to your agent

Capabilities

Start building with NVIDIA Cloud Functions API

Use Cases

Key Endpoints

Why Jentic?

Related APIs

FAQs