Vercel AI SDK

Le Vercel AI SDK est la manière la plus populaire de construire des fonctionnalités IA dans des applications Next.js, React, Svelte et Vue. Venice fonctionne immédiatement comme fournisseur compatible OpenAI.

Installation

Les exemples utilisent l’AI SDK 7. Installez-le avec le provider OpenAI, les hooks React et Zod :

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

Configuration du provider

Créez un provider Venice à l’aide de l’adaptateur compatible 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',
});

// Utilisez .chat() pour garantir la compatibilité avec l'endpoint chat completions de Venice
export const venice = (modelId: string) => openai.chat(modelId);

L’utilisation de .chat() garantit que les requêtes vont vers l’endpoint /chat/completions de Venice. Dans les versions récentes de l’AI SDK, la syntaxe par défaut openai('model') utilise à la place la Responses API, que Venice propose sur /responses avec certaines limitations. Consultez le guide de la Responses API avant de l’utiliser.

Streaming chat (Next.js App Router)

Route 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 }),
  });
}

Composant 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>
  );
}

Génération de texte (non-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);

Sortie structurée

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`);

Appel d’outils (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 }) => {
        // Votre appel d'API météo ici
        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) permet au modèle de répondre dans une seconde étape après l’exécution de l’outil. Sans cela, le stream se termine après le résultat de l’outil.

Génération d’images

La génération d’images Venice peut être appelée directement aux côtés du 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-modèles (sélecteur de modèle)

Laissez les utilisateurs choisir parmi les modèles 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 }),
  });
}

// Composant client avec sélecteur de modèle
'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 envoie le model sélectionné dans le corps de la requête avec chaque message, de sorte qu’un changement de modèle s’applique au message suivant.

Intégration de la recherche web

Activez la recherche web Venice avec un suffixe de fonctionnalité de modèle sur l’ID du modèle. Le suffixe transmet les venice_parameters via l’ID du modèle, vous n’avez donc pas besoin d’ajouter de champs à la requête :

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

Pour les embeddings, utilisez embeddingModel() directement sur le provider :

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 unique
const { embedding } = await embed({
  model: openai.embeddingModel('text-embedding-bge-m3'),
  value: 'Privacy-first AI infrastructure',
});

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

Variables d’environnement

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

Modèles recommandés

Cas d’usage	Modèle	Pourquoi
Applis de chat	`venice-uncensored-1-2`	Rapide, économique, sans filtrage
Tâches complexes	`z-ai-glm-5-3-flash`	Raisonnement privé rapide
Applis vision	`qwen3-vl-235b-a22b`	Compréhension d’images avancée
Fort volume	`nvidia-nemotron-3-nano-30b-a3b`	Peu coûteux à 0,075 $/1 M entrée, 0,30 $/1 M sortie
Tool calling	`z-ai-glm-5-3-flash`	Function calling fiable

Docs du Vercel AI SDK

Documentation officielle du Vercel AI SDK

Modèles Venice

Parcourir tous les modèles Venice

Documentation

Démarrage

Texte et chat

Image

Vidéo

Audio

Recherche et RAG

Agents et intégrations

Outils de code

Outils pour agents

SDK et frameworks

Installation

Configuration du provider

Streaming chat (Next.js App Router)

Route API

Composant React

Génération de texte (non-streaming)

Sortie structurée

Appel d’outils (tool calling)

Génération d’images

Chat multi-modèles (sélecteur de modèle)

Intégration de la recherche web

Embeddings

Variables d’environnement

Modèles recommandés

Docs du Vercel AI SDK

Modèles Venice

​Installation

​Configuration du provider

​Streaming chat (Next.js App Router)

​Route API

​Composant React

​Génération de texte (non-streaming)

​Sortie structurée

​Appel d’outils (tool calling)

​Génération d’images

​Chat multi-modèles (sélecteur de modèle)

​Intégration de la recherche web

​Embeddings

​Variables d’environnement

​Modèles recommandés

Docs du Vercel AI SDK

Modèles Venice

Installation

Configuration du provider

Streaming chat (Next.js App Router)

Route API

Composant React

Génération de texte (non-streaming)

Sortie structurée

Appel d’outils (tool calling)

Génération d’images

Chat multi-modèles (sélecteur de modèle)

Intégration de la recherche web

Embeddings

Variables d’environnement

Modèles recommandés