Vercel AI SDK | Venice API Docs

El Vercel AI SDK es la forma más popular de construir funciones de IA en aplicaciones Next.js, React, Svelte y Vue. Venice funciona out of the box como proveedor compatible con OpenAI.

Configuración

npm install ai @ai-sdk/openai

Configuración del proveedor

Crea un proveedor de Venice usando el adaptador compatible con 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',
});

// Usa .chat() para asegurar la compatibilidad con el endpoint chat completions de Venice
export const venice = (modelId: string) => openai.chat(modelId);

Usar .chat() garantiza que las solicitudes vayan al endpoint /chat/completions de Venice. La sintaxis predeterminada openai('model') puede usar endpoints más nuevos de OpenAI que Venice aún no admite.

Chat en streaming (Next.js App Router)

API Route

// app/api/chat/route.ts
import { streamText } from 'ai';
import { venice } from '@/lib/venice';

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

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

  return result.toDataStreamResponse();
}

Componente React

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

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

export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat();

  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>
            <p className="whitespace-pre-wrap">{m.content}</p>
          </div>
        ))}
      </div>

      <form onSubmit={handleSubmit} className="flex gap-2">
        <input
          value={input}
          onChange={handleInputChange}
          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>
  );
}

Generar texto (sin streaming)

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

const { text } = await generateText({
  model: venice('zai-org-glm-5-1'),
  prompt: 'Explain zero-knowledge proofs in simple terms.',
});

console.log(text);

Salida estructurada

import { generateObject } from 'ai';
import { venice } from '@/lib/venice';
import { z } from 'zod';

const { object } = await generateObject({
  model: venice('venice-uncensored'),
  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(object.recipe.name);
console.log(`Prep time: ${object.recipe.prepTimeMinutes} minutes`);

Tool calling

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

const result = streamText({
  model: venice('zai-org-glm-5-1'),
  messages: [{ role: 'user', content: 'What is the weather in Tokyo?' }],
  tools: {
    getWeather: tool({
      description: 'Get current weather for a location',
      parameters: z.object({
        location: z.string().describe('City name'),
      }),
      execute: async ({ location }) => {
        // Tu llamada a la API del tiempo aquí
        return { temperature: 22, condition: 'Sunny', location };
      },
    }),
  },
});

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

Generación de imágenes

La generación de imágenes de Venice se puede llamar directamente junto con el 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,
      width: 1024,
      height: 1024,
    }),
  });

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

Chat multi-modelo (selector de modelo)

Deja que los usuarios elijan entre los modelos de Venice:

// app/api/chat/route.ts
import { streamText } from 'ai';
import { venice } from '@/lib/venice';

const ALLOWED_MODELS = [
  'venice-uncensored',
  'zai-org-glm-5-1',
  'qwen3-vl-235b-a22b',
  'qwen3-5-9b',
];

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

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

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

  return result.toDataStreamResponse();
}

// Componente cliente con selector de modelo
'use client';

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

const MODELS = [
  { id: 'venice-uncensored', name: 'Venice Uncensored', desc: 'Fast & uncensored' },
  { id: 'zai-org-glm-5-1', name: 'GLM 5.1', desc: 'Most intelligent (private)' },
  { id: 'qwen3-vl-235b-a22b', name: 'Qwen Vision', desc: 'Advanced vision + text' },
  { id: 'qwen3-5-9b', name: 'Qwen 3.5 9B', desc: 'Fastest & cheapest' },
];

export default function Chat() {
  const [model, setModel] = useState('venice-uncensored');
  const { messages, input, handleInputChange, handleSubmit } = useChat({
    body: { model },
  });

  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>
      {/* ... UI del chat ... */}
    </div>
  );
}

Integración con búsqueda web

Pasa parámetros de Venice para la búsqueda web:

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

const result = streamText({
  model: venice('venice-uncensored'),
  messages: [{ role: 'user', content: 'What happened in AI news today?' }],
  // Parámetros específicos de Venice
  experimental_providerMetadata: {
    venice_parameters: {
      enable_web_search: 'auto',
    },
  },
});

Si experimental_providerMetadata no pasa, puedes usar un wrapper de fetch personalizado o llamar directamente a la API de Venice para las funciones de búsqueda web.

Embeddings

Para embeddings, usa textEmbeddingModel() directamente en el proveedor:

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.textEmbeddingModel('text-embedding-bge-m3'),
  value: 'Privacy-first AI infrastructure',
});

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

Variables de entorno

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

Modelos recomendados

Caso de uso	Modelo	Por qué
Apps de chat	`venice-uncensored`	Rápido, barato, sin filtrado
Tareas complejas	`zai-org-glm-5-1`	Razonamiento flagship privado
Apps de visión	`qwen3-vl-235b-a22b`	Comprensión avanzada de imágenes
Alto volumen	`qwen3-5-9b`	El más barato a $0.10/1M de entrada,$ 0.15/1M de salida
Tool calling	`zai-org-glm-5-1`	Function calling fiable

Docs del Vercel AI SDK

Documentación oficial del Vercel AI SDK

Modelos de Venice

Explora todos los modelos de Venice

​Configuración

​Configuración del proveedor

​Chat en streaming (Next.js App Router)

​API Route

​Componente React

​Generar texto (sin streaming)

​Salida estructurada

​Tool calling

​Generación de imágenes

​Chat multi-modelo (selector de modelo)

​Integración con búsqueda web

​Embeddings

​Variables de entorno

​Modelos recomendados

Docs del Vercel AI SDK

Modelos de Venice

Configuración

Configuración del proveedor

Chat en streaming (Next.js App Router)

API Route

Componente React

Generar texto (sin streaming)

Salida estructurada

Tool calling

Generación de imágenes

Chat multi-modelo (selector de modelo)

Integración con búsqueda web

Embeddings

Variables de entorno

Modelos recomendados