Quick Start

Get started with Vivgrid in minutes — connect your AI app to the Model API and extend it with Function Calling.

This guide will help you get started with Vivgrid OpenAI Bridge. You will learn how to extend your AI Agent abilities by LLM Function Calling.

Deploy NextChat to Vercel

NextChat is an open-source cross-platform ChatGPT/Gemini UI. You can create your own by forking and deploying NextChat to Vercel.

Once deployed, config the environment variables on Vercel:

Vercel - Environment Variables Settings Page

These are the required environment variables:

BASE_URL: https://api.vivgrid.com
OPENAI_API_KEY: grab it from Vivgrid Console

It works!

Let's try to ask the question Compare amazon and shopify network performance in your AI application.

You will see the followings:

OpenAI Chat Completions w/o Function Calling

OpenAI can not answer this question, but we can extend the gpt-5.1 model capabilities by Function Calling feature, OpenAI has great cookbook on how to call functions with chat models, but it's complex to implement and maintain:

OpenAI Cookbook: How to call functions with chat models

Extend your AI application abilities with a skill in Node.js

Let's try to implement a linux ping Function Calling skill in Node.js, before this, you need to install the Yomo Framework:

curl -fsSL https://get.yomo.run | sh

Initialize a new Node.js skill project:

yomo init -l node ./llm-tool

A skill is a Node.js project with three exports in src/app.ts: a description, an Argument type, and a handler. Let's build them up.

Create a function to measure the network performance for a given website:

import { promises as dns } from 'node:dns'
import ping from 'ping'

async function measure(domain: string) {
  // get all ip addresses
  const ips = await dns.resolve4(domain)

  // get the first ip address and measure latency by ping
  const res = await ping.promise.probe(ips[0], { timeout: 3, min_reply: 3 })

  // log the result
  console.log('[sfn] get ping latency', 'domain:', domain, 'ip:', ips[0], 'latency:', `${res.avg}ms`, 'PacketLoss:', `${res.packetLoss}%`)

  // return result to OpenAI as this is required by OpenAI spec
  return `domain ${domain} has ip ${ips[0]} with average latency ${res.avg}ms, make sure answer with the IP address and Latency`
}

Next, we need to wrap it to meet the spec of OpenAI Function Calling, luckily, we have Yomo to help us:

First, we need define the description for our function, this helps OpenAI to understand the function, it's very important for the accuracy. What we need to do is to export a description from src/app.ts:

export const description = `if user asks ip or network latency of a domain,
you should return the result of the given domain.
try your best to dissect user expressions to infer the right domain names`

The measure() requires a domain name as parameter, we will ask OpenAI to inference the domain name from the user input, and pass it by Arguments in tools_call. Export an Argument type to describe it:

// Argument defines the arguments data type for the OpenAI tools_call
export type Argument = {
  // Domain of the website, e.g. example.com
  domain: string
}

Finally, we need to wrap it as a skill by exporting a handler:

/**
 * handler will be triggered when OpenAI tools_call occurs.
 * @param args - LLM Function Calling Arguments.
 * @returns The result is returned to the LLM for the next round of chat completions.
 */
export async function handler(args: Argument) {
  // parse the arguments from OpenAI tools_call
  console.log('triggered', 'domain:', args.domain)
  // execute linux ping command to get result
  return await measure(args.domain)
}

Run it locally

For test or hosted on your own infra, install dependencies and run the Tool, connecting it to Vivgrid with your APP_KEY:

yomo run \
  --name ai_skill_get_ip_lantency \
  --zipper zipper.vivgrid.com:9000 \
  --credential <VIVGRID_APP_KEY>

ℹ️ Yomo Stream Function file: /Users/fanweixiao/_wrk/llm-tool/sfn.yomo
⌛ Create Yomo Stream Function instance...
ℹ️ Starting Yomo Stream Function instance with zipper: zipper.vivgrid.com:9000
ℹ️ Stream Function is running...
ℹ️ Run: /Users/fanweixiao/_wrk/llm-tool/sfn.yomo
time=2026-05-06T22:50:44.883+07:00 level=INFO msg="connected to zipper" component=StreamFunction sfn_id=<YOUR_APP_ID> sfn_name=ai_skill_get_ip_lantency zipper_addr=zipper.vivgrid.com:9000

Deploy to Vivgrid Geo-distributed Network

Next, your skill will be deployed to Vivgrid Geo-distributed Network, it will be available in multiple regions, and the requests will be routed to the nearest region by Vivgrid Geo-distributed Network.

At first, create a file named vivgrid.yml with content:

secret: <APP_SECRET>
tool: ai_skill_get_ip_lantency

then run:

viv deploy .

important Make sure you have the viv CLI installed, if not, install it follows here.

Once Deployed, monitor real-time logs and ask the question "Compare amazon and shopify network performance" again:

$ viv logs

[sgp.1] OK: {"log":"INFO triggered domain=amazon.com"}
[sgp.1] OK: {"log":"INFO triggered domain=shopify.com"}
[sgp.1] OK: {"log":"INFO [sfn] get ip domain=amazon.com ip=205.251.242.103"}
[sgp.1] OK: {"log":"INFO [sfn] get ip domain=amazon.com ip=54.239.28.85"}
[sgp.1] OK: {"log":"INFO [sfn] start ping domain=amazon.com ip=205.251.242.103"}
[sgp.1] OK: {"log":"INFO [sfn] get ip domain=amazon.com ip=52.94.236.248"}
[sgp.1] OK: {"log":"INFO [sfn] get ip domain=shopify.com ip=23.227.38.33"}
[sgp.1] OK: {"log":"INFO [sfn] start ping domain=shopify.com ip=23.227.38.33"}
[sgp.1] OK: {"log":"INFO [sfn] get ping latency domain=shopify.com ip=23.227.38.33 latency=2.182382ms PacketLoss=0.000000%"}
[sgp.1] OK: {"log":"INFO [sfn] get ping latency domain=amazon.com ip=205.251.242.103 latency=232.835894ms PacketLoss=0.000000%"}

Your AI Agent can now answer the question with network performance comparison:

OpenAI Chat Completions w/ Function Calling on Vivgrid

Do you know? Your skill will be deployed to multiple regions automatically, bringing computing closer to your users. This reduces latency and improves user experience. For Free Plan users, there are 7 regions available.