Vercel AI SDK

export ZEROGPU_API_KEY="zgpu-api-..."

npm i ai @zerogpu/ai-sdk-provider zod

import { zerogpu } from '@zerogpu/ai-sdk-provider';
import { generateText } from 'ai';

const { text, finishReason, usage } = await generateText({
  model: zerogpu('gpt-oss-120b'),
  prompt: 'Reply with the word ok',
});

console.log(text);
console.log(finishReason, usage.inputTokens, usage.outputTokens);

ok
stop 72 36

import { createZeroGPU } from '@zerogpu/ai-sdk-provider';

const zerogpu = createZeroGPU({
  apiKey: process.env.ZEROGPU_API_KEY,
  baseURL: 'https://api.zerogpu.ai/v1',
});

import { zerogpu } from '@zerogpu/ai-sdk-provider';
import { generateText } from 'ai';

const { text } = await generateText({
  model: zerogpu('llama-3.1-8b-instruct-fast'),
  instructions: 'You summarize support tickets in one sentence.',
  prompt: 'My invoice for October was charged twice and I need a refund for the duplicate.',
  maxOutputTokens: 64,
  temperature: 0.2,
});

console.log(text);

You are requesting a refund for a duplicate charge of your October invoice, which was mistakenly billed twice.

import { zerogpu } from '@zerogpu/ai-sdk-provider';
import { streamText } from 'ai';

const result = streamText({
  model: zerogpu('deepseek-v4.1-flash'),
  prompt: 'Explain edge inference in two sentences.',
});

for await (const textPart of result.textStream) {
  process.stdout.write(textPart);
}

console.log('\n', await result.finishReason, (await result.usage).outputTokens);

Edge inference is the process of running machine learning models directly on local devices like phones or IoT sensors rather than sending data to a remote cloud server. This approach reduces latency, saves bandwidth, and improves privacy by keeping sensitive data on the device.
 stop 48

import { zerogpu } from '@zerogpu/ai-sdk-provider';
import { generateText, isStepCount, tool } from 'ai';
import { z } from 'zod';

const { text, steps } = await generateText({
  model: zerogpu('gpt-6-luna'),
  tools: {
    weather: tool({
      description: 'Get the weather for a city',
      inputSchema: z.object({ city: z.string() }),
      execute: async ({ city }) => ({ city, temperatureC: 21, sky: 'clear' }),
    }),
  },
  stopWhen: isStepCount(3),
  prompt: 'What is the weather in Paris?',
});

console.log(text);
console.log(steps[0].toolCalls.map(c => ({ toolName: c.toolName, input: c.input })));

It's clear in Paris and 21°C.
[ { toolName: 'weather', input: { city: 'Paris' } } ]

import { zerogpu } from '@zerogpu/ai-sdk-provider';
import { generateText, Output } from 'ai';
import { z } from 'zod';

const { output } = await generateText({
  model: zerogpu('gpt-5.4-nano'),
  output: Output.object({
    schema: z.object({
      name: z.string(),
      ingredients: z.array(z.string()),
    }),
  }),
  prompt: 'Generate a short lasagna recipe.',
});

console.log(output.name, output.ingredients.length);

Quick Short-Cut Lasagna 14

import { zerogpu } from '@zerogpu/ai-sdk-provider';
import { generateText } from 'ai';
import { readFile } from 'node:fs/promises';

const { text } = await generateText({
  model: zerogpu('qwen3.6-35b-a3b'),
  messages: [
    {
      role: 'user',
      content: [
        { type: 'text', text: 'What color is this image? One word.' },
        { type: 'file', mediaType: 'image/png', data: await readFile('./image.png') },
      ],
    },
  ],
});

console.log(text.trim()); // "Red"

import { zerogpu } from '@zerogpu/ai-sdk-provider';
import { generateText } from 'ai';

const { text, usage } = await generateText({
  model: zerogpu('gpt-5.6-luna'),
  reasoning: 'high',
  prompt: 'How many prime numbers are there below 100? Answer with the number.',
});

console.log(text, usage.outputTokenDetails);

25 { textTokens: 10, reasoningTokens: 15 }

import { zerogpu } from '@zerogpu/ai-sdk-provider';
import { generateText } from 'ai';

const { text } = await generateText({
  model: zerogpu('zlm-v1-iab-classify-edge'),
  prompt: 'Apple released a new MacBook laptop today.',
});

const { audience, content } = JSON.parse(text);
console.log(audience[0], content.iab_2_2[0]);

{ name: 'Laptops', score: 0.7895236167380252 } { name: 'Laptops', score: 0.8754153951140519 }

const { text } = await generateText({
  model: zerogpu('zlm-v1-signal-extract'),
  prompt: 'How can I pay using my credit card?',
  providerOptions: { zerogpu: { categories: ['signals'], maxKeywords: 6 } },
});

{"keywords":["credit card","login"],"user_intent":{"name":"pay using credit card","category":"navigational","score":0.95}}

// Entities
const { text: entities } = await generateText({
  model: zerogpu('gliner2.5-base-v1'),
  prompt: 'The app is built with Python 3.11 and uses PostgreSQL 15.',
  providerOptions: {
    zerogpu: {
      metadata: { usecase: 'ner', labels: ['programming language', 'database'], threshold: 0.3 },
    },
  },
});

// Structured record
const { text: invoice } = await generateText({
  model: zerogpu('gliner2.5-base-v1'),
  prompt: 'Invoice INV-2291 from Acme Corp is due on March 3 for $1,250.',
  providerOptions: {
    zerogpu: {
      metadata: {
        usecase: 'json',
        schema: {
          invoice: [
            'number::str::Invoice number',
            'vendor::str::Company that issued it',
            'amount::str::Total amount',
            'due_date::str::Due date',
          ],
        },
      },
    },
  },
});

// Labels on several axes at once
const { text: labels } = await generateText({
  model: zerogpu('gliner2.5-base-v1'),
  prompt: 'The checkout page keeps timing out and I am really frustrated.',
  providerOptions: {
    zerogpu: {
      metadata: {
        usecase: 'classification',
        schema: {
          sentiment: ['positive', 'negative', 'neutral'],
          topic: ['billing', 'bug', 'feature request'],
        },
      },
    },
  },
});

{"entities":{"programming language":["Python 3.11"],"database":["PostgreSQL 15"]}}
{"data":{"invoice":[{"number":"INV-2291","vendor":"Acme Corp","amount":"$1,250","due_date":"March 3"}]}}
{"classification":{"sentiment":"negative","topic":"bug"}}

const { text } = await generateText({
  model: zerogpu('gliner2.5-decide-v1'),
  prompt: 'Can you refund my last order? It arrived broken.',
  providerOptions: {
    zerogpu: {
      metadata: {
        usecase: 'decide',
        labels: {
          intent: ['payment_issue', 'refund', 'account_access', 'general_question'],
          handoff: ['yes', 'no'],
        },
      },
    },
  },
});

{"decisions":{"intent":"refund","handoff":"no"}}

const { text } = await generateText({
  model: zerogpu('deberta-v3-small'),
  instructions: '[Sports,Technology,Finance]',
  prompt: 'Apple unveiled its next-generation M5 chip.',
});

{"Technology":0.7767035256605225,"Sports":0.1541566271737724,"Finance":0.06913984716570507}

import { zerogpu } from '@zerogpu/ai-sdk-provider';
import { cosineSimilarity, embedMany } from 'ai';

const { embeddings, usage } = await embedMany({
  model: zerogpu.embeddingModel('all-minilm-l6-v2'),
  values: ['sunny day at the beach', 'rainy afternoon in the city', 'warm sand and ocean waves'],
});

console.log(embeddings.length, embeddings[0].length, usage);
console.log(cosineSimilarity(embeddings[0], embeddings[2]).toFixed(3)); // beach vs. sand
console.log(cosineSimilarity(embeddings[0], embeddings[1]).toFixed(3)); // beach vs. rain

3 384 { tokens: 21 }
0.531
0.471

import { zerogpu } from '@zerogpu/ai-sdk-provider';
import { generateSpeech } from 'ai';
import { writeFile } from 'node:fs/promises';

const { audio, warnings } = await generateSpeech({
  model: zerogpu.speech('chatterbox-nano'),
  text: 'Hello from ZeroGPU! [laugh]',
  voice: 'echo',
  outputFormat: 'wav',
  providerOptions: { zerogpu: { seed: 42, temperature: 0.7 } },
});

await writeFile('./speech.wav', audio.uint8Array);
console.log(audio.mediaType, audio.uint8Array.length, warnings);

audio/wav 147918 []

import { zerogpu } from '@zerogpu/ai-sdk-provider';
import { transcribe } from 'ai';
import { readFile } from 'node:fs/promises';

const result = await transcribe({
  model: zerogpu.transcription('whisper-tiny'),
  audio: await readFile('./reply.mp3'),
  providerOptions: { zerogpu: { language: 'en' } },
});

console.log(result.text);
console.log(result.language, result.durationInSeconds, result.segments.length);

Hi, Dana. Thanks for your message. We've logged this as urgent priority and an engineer will call you back shortly.
en 5.84 1

import { zerogpu } from '@zerogpu/ai-sdk-provider';
import { generateText } from 'ai';

async function handle(message: string) {
  const { text } = await generateText({
    model: zerogpu('gliner2.5-decide-v1'),
    prompt: message,
    providerOptions: {
      zerogpu: {
        metadata: { usecase: 'decide', labels: { type: ['question', 'complaint', 'spam'] } },
      },
    },
  });
  const label = JSON.parse(text).decisions.type as string;

  if (label === 'spam') return null;

  const { text: reply } = await generateText({
    model: zerogpu('gpt-6-luna'),
    prompt: `Write a short, friendly reply to this customer ${label}:\n\n${message}`,
  });
  return reply;
}