Vercel AI SDK

O Vercel AI SDK é a maneira mais popular de construir recursos de IA em apps Next.js, React, Svelte e Vue. A Venice funciona imediatamente como um provedor compatível com OpenAI.

Configuração

Os exemplos usam o AI SDK 7. Instale-o junto com o provedor OpenAI, os hooks React e o Zod:

npm install ai@7 @ai-sdk/openai@4 @ai-sdk/react@4 zod

Configuração do provedor

Crie um provedor Venice usando o adaptador compatível com OpenAI:

// lib/venice.ts
import { createOpenAI } from '@ai-sdk/openai';

const openai = createOpenAI({
  apiKey: process.env.VENICE_API_KEY!,
  baseURL: 'https://api.venice.ai/api/v1',
});

// Use .chat() para garantir compatibilidade com o endpoint de chat completions da Venice
export const venice = (modelId: string) => openai.chat(modelId);

Usar .chat() garante que as requisições vão para o endpoint /chat/completions da Venice. Nas versões recentes do AI SDK, a sintaxe padrão openai('model') usa a Responses API, que a Venice oferece em /responses com algumas limitações. Consulte o guia da Responses API antes de usá-la.

Streaming de chat (Next.js App Router)

Rota de API

// app/api/chat/route.ts
import {
  convertToModelMessages,
  createUIMessageStreamResponse,
  streamText,
  toUIMessageStream,
  type UIMessage,
} from 'ai';
import { venice } from '@/lib/venice';

export async function POST(req: Request) {
  const { messages }: { messages: UIMessage[] } = await req.json();

  const result = streamText({
    model: venice('venice-uncensored-1-2'),
    instructions: 'You are a helpful, privacy-respecting AI assistant.',
    messages: await convertToModelMessages(messages),
  });

  return createUIMessageStreamResponse({
    stream: toUIMessageStream({ stream: result.stream }),
  });
}

Componente React

// app/page.tsx
'use client';

import { useChat } from '@ai-sdk/react';
import { useState } from 'react';

export default function Chat() {
  const [input, setInput] = useState('');
  const { messages, sendMessage, status } = useChat();
  const isLoading = status === 'submitted' || status === 'streaming';

  return (
    <div className="max-w-2xl mx-auto p-4">
      <div className="space-y-4 mb-4">
        {messages.map((m) => (
          <div key={m.id} className={m.role === 'user' ? 'text-right' : 'text-left'}>
            <span className="font-bold">{m.role === 'user' ? 'You' : 'Venice'}:</span>
            {m.parts.map((part, i) =>
              part.type === 'text' ? (
                <p key={i} className="whitespace-pre-wrap">{part.text}</p>
              ) : null,
            )}
          </div>
        ))}
      </div>

      <form
        onSubmit={(e) => {
          e.preventDefault();
          if (!input.trim()) return;
          sendMessage({ text: input });
          setInput('');
        }}
        className="flex gap-2"
      >
        <input
          value={input}
          onChange={(e) => setInput(e.target.value)}
          placeholder="Ask anything..."
          className="flex-1 border rounded px-3 py-2"
          disabled={isLoading}
        />
        <button type="submit" disabled={isLoading} className="bg-red-600 text-white px-4 py-2 rounded">
          Send
        </button>
      </form>
    </div>
  );
}

Gerando texto (sem streaming)

import { generateText } from 'ai';
import { venice } from '@/lib/venice';

const { text } = await generateText({
  model: venice('z-ai-glm-5-3-flash'),
  prompt: 'Explain zero-knowledge proofs in simple terms.',
});

console.log(text);

Saída estruturada

import { generateText, Output } from 'ai';
import { venice } from '@/lib/venice';
import { z } from 'zod';

const { output } = await generateText({
  model: venice('venice-uncensored-1-2'),
  output: Output.object({
    schema: z.object({
      recipe: z.object({
        name: z.string(),
        ingredients: z.array(z.string()),
        steps: z.array(z.string()),
        prepTimeMinutes: z.number(),
      }),
    }),
  }),
  prompt: 'Generate a recipe for chocolate chip cookies.',
});

console.log(output.recipe.name);
console.log(`Prep time: ${output.recipe.prepTimeMinutes} minutes`);

Tool calling

import { isStepCount, streamText, tool } from 'ai';
import { venice } from '@/lib/venice';
import { z } from 'zod';

const result = streamText({
  model: venice('z-ai-glm-5-3-flash'),
  messages: [{ role: 'user', content: 'What is the weather in Tokyo?' }],
  tools: {
    getWeather: tool({
      description: 'Get current weather for a location',
      inputSchema: z.object({
        location: z.string().describe('City name'),
      }),
      execute: async ({ location }) => {
        // Sua chamada de API de clima aqui
        return { temperature: 22, condition: 'Sunny', location };
      },
    }),
  },
  stopWhen: isStepCount(2),
});

for await (const part of result.stream) {
  if (part.type === 'text-delta') {
    process.stdout.write(part.text);
  } else if (part.type === 'tool-result') {
    console.log('Tool result:', part.output);
  }
}

stopWhen: isStepCount(2) permite que o modelo responda em uma segunda etapa depois que a ferramenta é executada. Sem isso, o stream termina após o resultado da ferramenta.

Geração de imagens

A geração de imagens Venice pode ser chamada diretamente junto com o AI SDK:

// app/api/image/route.ts
export async function POST(req: Request) {
  const { prompt } = await req.json();

  const response = await fetch('https://api.venice.ai/api/v1/image/generate', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.VENICE_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      model: 'qwen-image',
      prompt,
      aspect_ratio: '1:1',
    }),
  });

  const data = await response.json();
  return Response.json({ image: data.images[0] });
}

Chat multi-modelo (seletor de modelo)

Deixe os usuários escolherem entre modelos Venice:

// app/api/chat/route.ts
import {
  convertToModelMessages,
  createUIMessageStreamResponse,
  streamText,
  toUIMessageStream,
  type UIMessage,
} from 'ai';
import { venice } from '@/lib/venice';

const ALLOWED_MODELS = [
  'venice-uncensored-1-2',
  'z-ai-glm-5-3-flash',
  'qwen3-vl-235b-a22b',
  'nvidia-nemotron-3-nano-30b-a3b',
];

export async function POST(req: Request) {
  const { messages, model: modelId }: { messages: UIMessage[]; model: string } =
    await req.json();

  if (!ALLOWED_MODELS.includes(modelId)) {
    return new Response('Invalid model', { status: 400 });
  }

  const result = streamText({
    model: venice(modelId),
    messages: await convertToModelMessages(messages),
  });

  return createUIMessageStreamResponse({
    stream: toUIMessageStream({ stream: result.stream }),
  });
}

// Componente cliente com seletor de modelo
'use client';

import { useChat } from '@ai-sdk/react';
import { useState } from 'react';

const MODELS = [
  { id: 'venice-uncensored-1-2', name: 'Venice Uncensored', desc: 'Fast & uncensored' },
  { id: 'z-ai-glm-5-3-flash', name: 'GLM 5.3 Flash', desc: 'Fast private reasoning' },
  { id: 'qwen3-vl-235b-a22b', name: 'Qwen Vision', desc: 'Advanced vision + text' },
  { id: 'nvidia-nemotron-3-nano-30b-a3b', name: 'Nemotron 3 Nano 30B', desc: 'Fast & low cost' },
];

export default function Chat() {
  const [model, setModel] = useState('venice-uncensored-1-2');
  const [input, setInput] = useState('');
  const { messages, sendMessage } = useChat();

  return (
    <div>
      <select value={model} onChange={(e) => setModel(e.target.value)}>
        {MODELS.map((m) => (
          <option key={m.id} value={m.id}>{m.name} — {m.desc}</option>
        ))}
      </select>
      {messages.map((m) => (
        <p key={m.id}>
          {m.role}: {m.parts.map((part) => (part.type === 'text' ? part.text : '')).join('')}
        </p>
      ))}
      <form
        onSubmit={(e) => {
          e.preventDefault();
          sendMessage({ text: input }, { body: { model } });
          setInput('');
        }}
      >
        <input value={input} onChange={(e) => setInput(e.target.value)} />
      </form>
    </div>
  );
}

sendMessage envia o model selecionado no corpo da requisição junto com cada mensagem, então a troca de modelo vale a partir da próxima mensagem.

Integração de busca na web

Ative a busca na web da Venice com um sufixo de recurso do modelo no ID do modelo. O sufixo passa venice_parameters pelo ID do modelo, então você não precisa adicionar campos à requisição:

import { streamText } from 'ai';
import { venice } from '@/lib/venice';

const result = streamText({
  model: venice('venice-uncensored-1-2:enable_web_search=auto'),
  messages: [{ role: 'user', content: 'What happened in AI news today?' }],
});

Embeddings

Para embeddings, use embeddingModel() diretamente no provedor:

import { embed, embedMany } from 'ai';
import { createOpenAI } from '@ai-sdk/openai';

const openai = createOpenAI({
  apiKey: process.env.VENICE_API_KEY!,
  baseURL: 'https://api.venice.ai/api/v1',
});

// Embedding único
const { embedding } = await embed({
  model: openai.embeddingModel('text-embedding-bge-m3'),
  value: 'Privacy-first AI infrastructure',
});

// Embeddings em batch
const { embeddings } = await embedMany({
  model: openai.embeddingModel('text-embedding-bge-m3'),
  values: [
    'Venice AI provides private inference.',
    'Zero data retention guaranteed.',
    'OpenAI SDK compatible.',
  ],
});

Variáveis de ambiente

# .env.local
VENICE_API_KEY=your-venice-api-key

Modelos recomendados

Caso de uso	Modelo	Por quê
Apps de chat	`venice-uncensored-1-2`	Rápido, barato, sem filtragem
Tarefas complexas	`z-ai-glm-5-3-flash`	Raciocínio privado rápido
Apps de visão	`qwen3-vl-235b-a22b`	Compreensão de imagem avançada
Alto volume	`nvidia-nemotron-3-nano-30b-a3b`	Baixo custo, $0,075/1M de entrada, $0,30/1M de saída
Tool calling	`z-ai-glm-5-3-flash`	Function calling confiável

Documentação do Vercel AI SDK

Documentação oficial do Vercel AI SDK

Modelos Venice

Navegue por todos os modelos Venice

Documentação

Primeiros passos

Texto e chat

Imagem

Vídeo

Áudio

Pesquisa e RAG

Agentes e integrações

Ferramentas de código

Ferramentas para agentes

SDKs e frameworks

Configuração

Configuração do provedor

Streaming de chat (Next.js App Router)

Rota de API

Componente React

Gerando texto (sem streaming)

Saída estruturada

Tool calling

Geração de imagens

Chat multi-modelo (seletor de modelo)

Integração de busca na web

Embeddings

Variáveis de ambiente

Modelos recomendados

Documentação do Vercel AI SDK

Modelos Venice

​Configuração

​Configuração do provedor

​Streaming de chat (Next.js App Router)

​Rota de API

​Componente React

​Gerando texto (sem streaming)

​Saída estruturada

​Tool calling

​Geração de imagens

​Chat multi-modelo (seletor de modelo)

​Integração de busca na web

​Embeddings

​Variáveis de ambiente

​Modelos recomendados

Documentação do Vercel AI SDK

Modelos Venice

Configuração

Configuração do provedor

Streaming de chat (Next.js App Router)

Rota de API

Componente React

Gerando texto (sem streaming)

Saída estruturada

Tool calling

Geração de imagens

Chat multi-modelo (seletor de modelo)

Integração de busca na web

Embeddings

Variáveis de ambiente

Modelos recomendados