Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Vercel AI SDK e integrazione frontend

Lezione 6 di 12 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Vercel AI SDK per applicazioni web
  2. Installazione
  3. Lato server: generazione di testo
  4. Streaming lato server
  5. Lato client: l’hook useChat
  6. Rotta API corrispondente
  7. Punti chiave

Aggiornato il 3 novembre 2026 sulla base della documentazione di AI SDK 7 (ai 7.0.x, @ai-sdk/react 4.x): useChat funziona con DefaultChatTransport e sendMessage, i messaggi vengono visualizzati tramite parts, la rotta restituisce createUIMessageStreamResponse, system diventa instructions e il provider @ai-sdk/xai 5 non supporta più le Chat Completions: xai() utilizza le Responses API (codice verificato con il compilatore TypeScript usando ai 7.0.162 e @ai-sdk/xai 5.0.38). La versione precedente utilizzava le API di AI SDK 4 (input, handleSubmit, isLoading, toDataStreamResponse). Fonti: AI SDK, Chatbot · AI SDK, provider xAI.

Vercel AI SDK per applicazioni web

Vercel AI SDK è un framework TypeScript progettato per integrare modelli di intelligenza artificiale nelle applicazioni web. Fornisce hook React, utility per lo streaming e un’astrazione unificata che supporta nativamente xAI/Grok tramite il pacchetto @ai-sdk/xai.

Se stai sviluppando un’applicazione Next.js, Nuxt, SvelteKit o qualsiasi applicazione React che necessita di visualizzare risposte in streaming, Vercel AI SDK semplifica notevolmente il lavoro.

Installazione

Installa l’SDK core e il provider xAI:

npm install ai @ai-sdk/xai

Configura la tua chiave API nelle variabili d’ambiente:

# .env.local
XAI_API_KEY=your-api-key

Lato server: generazione di testo

La funzione generateText è l’equivalente più semplice di client.chat.create(). Una cosa è cambiata e riguarda direttamente questo corso: dalla versione 5 del provider @ai-sdk/xai (settembre 2026), compatibile con AI SDK 7, il provider non supporta più l’endpoint Chat Completions. xai(model) utilizza le Responses API, che xAI raccomanda ora. Il metodo xai.chat(model), citato ancora da alcune guide di migrazione, esisteva solo nella versione 4 del provider; per il codice che deve rimanere sulle Chat Completions, usa invece l’SDK OpenAI puntato su xAI (Lezione 5).

import { generateText } from "ai";
import { xai } from "@ai-sdk/xai";

const { text } = await generateText({
  model: xai("grok-4.7"), // xAI Responses API
  instructions: "You are a technical assistant.",
  prompt: "Explain the concept of containerization.",
});

console.log(text);

Il provider xai legge automaticamente XAI_API_KEY dall’ambiente; createXai() ti permette di creare un’istanza con impostazioni personalizzate. L’opzione instructions sostituisce system, che viene ancora accettato ma è deprecato in AI SDK 7.

Streaming lato server

Per lo streaming, usa streamText. La risposta viene letta chunk per chunk da textStream:

import { streamText } from "ai";
import { xai } from "@ai-sdk/xai";

const result = streamText({
  model: xai("grok-4.7"),
  instructions: "You are a teaching assistant.",
  messages: [
    { role: "user", content: "How does a relational database work?" },
  ],
});

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

Lato client: l’hook useChat

L’hook useChat è il componente centrale sul frontend. Gestisce la cronologia delle conversazioni, lo streaming e lo stato della richiesta; il campo di input, tuttavia, rimane un semplice stato React che devi gestire tu:

"use client";
import { useChat } from "@ai-sdk/react";
import { DefaultChatTransport } from "ai";
import { useState } from "react";

export default function ChatPage() {
  const { messages, sendMessage, status } = useChat({
    transport: new DefaultChatTransport({ api: "/api/chat" }),
  });
  const [input, setInput] = useState("");

  return (
    <div>
      {messages.map((m) => (
        <div key={m.id}>
          <strong>{m.role === "user" ? "You" : "Grok"}</strong>
          {m.parts.map((part, i) =>
            part.type === "text" ? <p key={i}>{part.text}</p> : null
          )}
        </div>
      ))}

      <form
        onSubmit={(e) => {
          e.preventDefault();
          if (input.trim()) {
            sendMessage({ text: input });
            setInput("");
          }
        }}
      >
        <input
          value={input}
          onChange={(e) => setInput(e.target.value)}
          placeholder="Ask your question..."
          disabled={status !== "ready"}
        />
        <button type="submit" disabled={status !== "ready"}>
          Send
        </button>
      </form>
    </div>
  );
}

Cosa gestisce automaticamente useChat

  • Cronologia messaggi: Accumula gli scambi; ogni messaggio contiene parts (testo, chiamate a tool…), visualizza questi invece del vecchio campo content
  • Streaming: Visualizza la risposta man mano che viene generata
  • Stato della richiesta: status è ready quando può essere inviato un nuovo messaggio
  • Gestione errori: Intercetta errori di rete e API
  • Cancellazione: stop() interrompe una generazione in corso

Rotta API corrispondente

L’hook si aspetta una rotta che restituisca uno stream di messaggi UI. Ecco l’implementazione con Next.js App Router, modellata sull’esempio ufficiale di AI SDK 7:

// app/api/chat/route.ts
import {
  convertToModelMessages,
  createUIMessageStreamResponse,
  streamText,
  toUIMessageStream,
  type UIMessage,
} from "ai";
import { xai } from "@ai-sdk/xai";

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

  const result = streamText({
    model: xai("grok-4.7"),
    instructions: "You are a helpful assistant. Respond in English.",
    messages: await convertToModelMessages(messages),
  });

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

Due conversioni avvolgono lo scambio: convertToModelMessages trasforma i messaggi UI ricevuti dal client in messaggi per il modello, e toUIMessageStream fa l’inverso sullo stream di risposta. I metodi toUIMessageStreamResponse() sul risultato di streamText funzionano ancora in AI SDK 7, ma sono deprecati; quanto al vecchio toDataStreamResponse(), non esiste più.

Punti chiave

  • Vercel AI SDK supporta xAI/Grok tramite il pacchetto @ai-sdk/xai
  • generateText per risposte sincrone, streamText per lo streaming
  • L’hook useChat gestisce l’intero stato di una conversazione sul client
  • createUIMessageStreamResponse e toUIMessageStream restituiscono lo stream atteso da useChat; toDataStreamResponse() non esiste più
  • Da @ai-sdk/xai 5, il provider non supporta più le Chat Completions: xai() utilizza le Responses API; per rimanere sulle Chat Completions, usa l’SDK OpenAI
  • Il provider createXai() rileva automaticamente la chiave API nell’ambiente