Ai auzit de noul UI SDK de la Vercel?

Ghid de instalare Vercel UI SDK în Next.js și Nuxt (2026)

Ghid de instalare Vercel UI SDK în Next.js și Nuxt (2026)

Ghid Vercel UI SDK despre ce e noua bibliotecă UI headless, cum o instalezi în Next.js și Nuxt, cum o stilizezi, o testezi și o deschizi agenților AI.

Liviu Zachin

· 13 min de citit

Vercel Labs a lansat UI SDK pe 12 noiembrie 2026. În ciuda numelui, n-are nicio legătură cu apelarea modelelor de limbaj; pentru asta există AI SDK. UI SDK este o bibliotecă TypeScript de comportamente UI (behaviors), ca focusul, navigarea din tastatură, selecția, popup-urile, drag and drop și atributele ARIA de care au nevoie. Peste ele vin 55 de componente fără stiluri și o punte prin care agenții AI pot folosi direct interfața.

Construiesc front-end-uri în Nuxt și React, așa că am instalat versiunea beta într-un proiect React și într-o aplicație Nuxt 4 ca să scriu acest ghid. Îți arăt ce este UI SDK, cum îl instalezi în Next.js și în Nuxt, cum funcționează stilizarea și componentele proprii și unde intră în joc agenții. Totul e verificat pe 0.1.0-beta.1, versiunea curentă la momentul scrierii. E un beta, așa că unele API-uri se vor mai schimba.

Ce este UI SDK de la Vercel?

UI SDK este o bibliotecă TypeScript open source de comportamente UI, creată de Vercel Labs. Comportamentele sunt piesele testate care fac o componentă să funcționeze, ca focusul itinerant (roving focus), căutarea din tastatură (typeahead), popup-urile și selecția. Vercel livrează 55 de componente fără stiluri construite din ele, pentru React, Vue, Svelte, Solid și Web Components, plus o punte pentru agenți (agent bridge) prin care agenții AI pot citi și folosi interfața.

Pe scurt:

  • Cine îl face. Vercel Labs. Codul e pe github.com/vercel-labs/ui, sub licența Apache-2.0, iar documentația e pe ui-sdk.dev.
  • Stadiu. Beta public, lansat pe 12 noiembrie 2026. Toate pachetele sunt la 0.1.0-beta.1.
  • Ce primești
    • peste 50 de comportamente în @ui-sdk/core;
    • 55 de componente, de la Accordion la Waterfall, printre care Select, Combobox, Dialog, Date Picker, Color Picker, Token Input și Tree;
    • un kit de testare;
    • puntea pentru agenți.
  • Fără stiluri. Componentele nu aduc CSS propriu. O foaie de stil opțională le dă un aspect implicit neutru.
FrameworkPachetObservații
React, Next.js@ui-sdk/reactReact 19+; @types/react 19.2.10+ pentru TypeScript
Vue, Nuxt@ui-sdk/vueVue 3.5+; include un modul Nuxt
Svelte@ui-sdk/svelteAceleași părți, ca componente Svelte
Solid@ui-sdk/solidAceleași părți, ca componente Solid
Web Components@ui-sdk/webElemente custom ca <ui-toggle>, merg și fără build

Fiecare pachet de framework are nevoie de @ui-sdk/core instalat alături. Core conține comportamentele și e o dependență peer, ca o singură copie să servească și componentele, și utilitarele pe care le importi.

UI SDK vs AI SDK

Rezolvă probleme diferite. AI SDK conectează aplicația ta la modele de limbaj. UI SDK construiește interfața și le permite agenților s-o folosească.

Vercel AI SDKVercel UI SDK
Ce faceApelează modele pentru text, output structurat, tool-uri și chat cu streamingConstruiește componente accesibile din comportamente și le expune agenților
API-uri principalestreamText, generateText, useChatdefinePrimitive, createParts, <Select>, createAgent
Pacheteai, @ai-sdk/react, pachetele furnizorilor@ui-sdk/core, @ui-sdk/react, @ui-sdk/vue și altele
StadiuStabil, versiunea 7Beta, versiunea 0.1

Deocamdată nu există o integrare oficială între ele, dar se potrivesc. agentTools din UI SDK exportă definiții simple de tool-uri (nume, descriere, JSON Schema) și lasă bucla cu modelul în seama ta. Un asistent construit cu AI SDK, sau cu orice alt SDK pentru modele, poate deci folosi un ecran făcut cu UI SDK. Dacă abia începi cu AI SDK, tutorialul meu despre Vercel AI SDK 7 construiește un chat cu tool-uri și generative UI în Next.js și Nuxt.

Cum se leagă comportamentele, primitivele, părțile și componentele

UI SDK are patru niveluri, fiecare construit peste cel de dedesubt:

  1. Comportamentele sunt funcții din @ui-sdk/core, ca createRovingFocus (un singur Tab stop pentru un grup, săgeți în interiorul lui), createTypeahead, createPopup, createSelection, createReorder și createVirtualizer.
  2. O primitivă adună starea, acțiunile și părțile unei componente într-o singură definiție, independentă de framework, creată cu definePrimitive.
  3. Părțile sunt componentele de framework pe care createParts le face dintr-o primitivă, ca Root, Trigger și Content, randate ca elementele pe care le alegi.
  4. Componentele sunt biblioteca gata făcută (Dialog, Select, Tabs și celelalte). Sunt construite la fel, așa că poți reface oricare dintre ele sub numele tău.

Comportamentul stă în core, iar fiecare pachet de framework doar îl conectează la framework-ul lui. De aceea un Select se poartă la fel în React, în Vue și ca element custom. Documentația spune că testele componentelor rulează în React, Vue și Web Components, iar doar pagina Dialog listează aproximativ 90 de verificări automate.

Cum instalezi UI SDK în Next.js

Instalezi două pachete, imporți opțional foaia de stil implicită și randezi componentele direct din pagini. Nu ai nevoie de niciun provider.

1. Verifică cerințele

Ai nevoie de React 19 și React DOM 19 sau mai nou, pe care un proiect Next.js recent cu App Router le folosește deja. Cu TypeScript, mai ai nevoie de @types/react 19.2.10 sau mai nou.

2. Instalează pachetele

npm install @ui-sdk/react @ui-sdk/core

3. Adaugă aspectul implicit (opțional)

Pentru un punct de plecare neutru, importă web.css o singură dată, la începutul app/layout.tsx:

// app/layout.tsx
import "@ui-sdk/core/web.css"
import "./globals.css"

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html lang="ro">
      <body>{children}</body>
    </html>
  )
}

Cu Tailwind CSS, importă-l în schimb în foaia de stil globală, după Tailwind, și declară stratul ui-sdk deasupra amândurora:

/* app/globals.css */
@layer ui-sdk;

@import "tailwindcss";
@import "@ui-sdk/core/web.css" layer(components);

layer(components) pune aspectul implicit peste stilurile de bază ale Tailwind și sub utilitare, așa că clasele tale câștigă în continuare.

Foaia de stil urmează tema luminoasă sau întunecată a sistemului. O personalizezi prin variabile --ui-*, ca --ui-primary, --ui-radius și --ui-font-sans.

4. Randează prima componentă

// app/bookmark-button.tsx
import { Toggle } from "@ui-sdk/react/toggle"

export function BookmarkButton() {
  return (
    <Toggle className="rounded-md border px-3 py-1.5 text-sm data-pressed:bg-neutral-900 data-pressed:text-white">
      Bookmark
    </Toggle>
  )
}

Toggle randează un <button>, își ține minte starea apăsată, răspunde la Enter și Space și setează aria-pressed. Pe server, <Toggle defaultPressed>Bold</Toggle> randează HTML-ul de mai jos. L-am verificat cu server rendererul din React:

<button data-slot="toggle" type="button" aria-pressed="true" data-pressed="">Bold</button>

Fiecare componentă se importă din propriul punct de intrare, de exemplu @ui-sdk/react/toggle. Nu există un import din rădăcina @ui-sdk/react, așa că o pagină aduce doar ce folosește.

5. Construiește un control de formular real

// app/role-select.tsx
import {
  Select,
  SelectContent,
  SelectItem,
  SelectLabel,
  SelectTrigger,
  SelectValue,
} from "@ui-sdk/react/select"

export function RoleSelect() {
  return (
    <Select placeholder="Alege un rol">
      <SelectLabel>Rol</SelectLabel>
      <SelectTrigger>
        <SelectValue />
      </SelectTrigger>
      <SelectContent>
        <SelectItem value="viewer">Vizualizator</SelectItem>
        <SelectItem value="editor">Editor</SelectItem>
      </SelectContent>
    </Select>
  )
}

Triggerul se randează ca un combobox ARIA, cu aria-haspopup="listbox", aria-expanded și o referință la etichetă, iar dacă tastezi cât e închis, selectează următoarea potrivire. Aceeași componentă mai acoperă:

  • selecția multiplă;
  • căutarea în popup;
  • opțiunile încărcate asincron;
  • grupurile;
  • o opțiune „selectează tot”.

6. Unde pui „use client”

Modulele componentelor UI SDK conțin deja "use client". O pagină Server Component poate randa direct <Toggle> sau <Select>, iar serverul trimite HTML-ul inițial cu starea ARIA.

Adaugi directiva în fișierele tale doar când au stare React, callback-uri sau funcții de randare:

// app/mute-toggle.tsx
"use client"

import { Toggle } from "@ui-sdk/react/toggle"
import { useState } from "react"

export function MuteToggle() {
  const [muted, setMuted] = useState(false)

  return (
    <>
      <Toggle pressed={muted} onPressedChange={setMuted}>
        Fără sunet
      </Toggle>
      <output>{muted ? "Sunetul e oprit" : "Sunetul e pornit"}</output>
    </>
  )
}

Cum instalezi UI SDK în Nuxt (și Vue)

@ui-sdk/vue vine cu un modul Nuxt. Îl adaugi în modules, iar fiecare parte devine o componentă importată automat, randată pe server. Puține biblioteci de componente sunt atât de simple în Nuxt din prima zi.

1. Instalează pachetele

Ai nevoie de Vue 3.5 sau mai nou. Intervalul de dependențe peer al modulului acoperă Nuxt 4 și Nuxt 5.

npm install @ui-sdk/vue @ui-sdk/core

2. Înregistrează modulul și foaia de stil

// nuxt.config.ts
export default defineNuxtConfig({
  modules: ["@ui-sdk/vue"],
  css: ["@ui-sdk/core/web.css"],
})

Modulul nu adaugă niciun plugin și niciun stil propriu. Linia css e aspectul implicit opțional, deci o poți scoate dacă stilizezi totul singur.

3. Folosește componentele fără importuri

<!-- pages/index.vue -->
<script setup lang="ts">
const role = ref<string | null>(null)
</script>

<template>
  <Dialog>
    <DialogTrigger>Distribuie</DialogTrigger>
    <DialogBackdrop />
    <DialogContent>
      <DialogTitle>Distribuie linkul</DialogTitle>
      <DialogDescription>Oricine are linkul poate vedea proiectul.</DialogDescription>
      <DialogClose>Gata</DialogClose>
    </DialogContent>
  </Dialog>

  <Select v-model:value="role" placeholder="Alege un rol">
    <SelectLabel>Rol</SelectLabel>
    <SelectTrigger>
      <SelectValue />
    </SelectTrigger>
    <SelectContent>
      <SelectItem value="viewer">Vizualizator</SelectItem>
      <SelectItem value="editor">Editor</SelectItem>
    </SelectContent>
  </Select>
</template>

Am prerandat pagina asta cu nuxt generate pe Nuxt 4. Triggerul dialogului și select-ul se randează pe server cu atributele ARIA, fără niciun import scris de mână. Fiecare import automat indică tot spre propriul punct de intrare, deci o pagină include doar părțile pe care le folosește.

v-model:value și v-model:open îți lasă controlul asupra stării. Evenimentele de schimbare primesc detaliile ca al doilea argument, iar details.cancel() refuză schimbarea.

4. Evită conflictele de nume cu un prefix

Dacă aplicația ta are deja o componentă Dialog sau Select, a ta are prioritate. Ca să le folosești pe amândouă, dă-i UI SDK un prefix:

// nuxt.config.ts
export default defineNuxtConfig({
  modules: ["@ui-sdk/vue"],
  uiSdk: { prefix: "U" },
})

Cu prefixul ăsta, <DialogTrigger> devine <UDialogTrigger>. Nuxt UI folosește deja prefixul U (USelect, UModal), așa că, dacă le ai pe amândouă, alege altă literă.

Fără Nuxt, imporți părțile din punctele lor de intrare (import { Toggle } from "@ui-sdk/vue/toggle") și pui import "@ui-sdk/core/web.css" la începutul main.ts. Dacă încă alegi între cele două framework-uri, le-am comparat în React vs Vue în 2026.

Cum stilizezi componentele UI SDK

Stilizezi după atribute, nu după clase adăugate de bibliotecă. Fiecare parte are un atribut data-slot, iar starea apare ca atribute precum data-pressed, data-open și data-disabled.

  • CSS simplu. Selectezi părțile și starea lor:
    [data-slot="toggle"] { border: 1px solid #d4d4d4; border-radius: 0.5rem; }
    [data-slot="toggle"][data-pressed] { background: #171717; color: white; }
    
  • Tailwind. Folosești variante de atribut ca data-pressed:bg-neutral-900 și data-disabled:opacity-50.
  • Funcții de stare în React. Într-o componentă client, className și style acceptă o funcție de starea părții, de exemplu className={(state) => (state.pressed ? "font-bold" : "font-normal")}.
  • Animații. Conținutul unui popup primește data-starting-style înainte să apară și data-ending-style cât dispare, și rămâne montat până se termină tranziția de ieșire.
  • Variabile CSS. Popup-urile expun --anchor-width, --available-height și --transform-origin, pentru dimensiuni și animații care pornesc din punctul potrivit.
  • Stratul din cascadă. UI SDK injectează puțin CSS (de exemplu, ca popup-urile închise să rămână ascunse) într-un strat numit ui-sdk. Pune @layer ui-sdk; la începutul foii de stil globale, ca stilurile tale să câștige mereu.
  • Content Security Policy. Dacă style-src nu conține 'unsafe-inline', adaugă <meta property="csp-nonce" nonce="…"> în head-ul paginii. Paginile randate pe server au nevoie și de style-src-attr 'unsafe-inline', pentru câteva atribute style.

Cum construiești o componentă proprie cu definePrimitive

Când biblioteca nu are componenta de care ai nevoie, definești o primitivă o singură dată și o randezi în orice framework. Iată un buton complet de oprire a sunetului, adaptat din documentație:

// lib/mute-button.ts
import { definePrimitive } from "@ui-sdk/core"

export const muteButton = definePrimitive({
  name: "mute-button",
  state: () => ({ muted: false }),
  api: (context) => ({
    toggle: () => context.store.set({ muted: !context.store.get().muted }),
  }),
  slots: (slot) => ({
    root: slot({
      attrs: (state) => ({
        type: "button",
        "aria-pressed": String(state.muted),
      }),
      press: ({ api }) => api.toggle(),
    }),
  }),
})

Apoi îl randezi în React:

// components/mute-button.tsx
"use client"

import { createParts } from "@ui-sdk/react/primitive"
import { muteButton } from "@/lib/mute-button"

export const { Root: MuteButton } = createParts(muteButton, { root: "button" })

În Vue, aceleași două linii importă createParts din @ui-sdk/vue/primitive. În ambele cazuri, <MuteButton>Mute</MuteButton> randează <button data-slot="mute-button" type="button" aria-pressed="false">Mute</button>.

Componentele reale combină mai multe comportamente. Selectorul de iconițe din documentație se deschide cu createPopup, îi dă grilei un singur Tab stop cu createRovingFocus, urmează așezarea în pagină cu spatialMove, ordonează rezultatele căutării cu fuzzyScore și anunță numărul de potriviri cu announce.

Cum folosesc agenții AI o interfață făcută cu UI SDK?

Prin puntea pentru agenți. createAgent listează componentele din pagină, cu starea și acțiunile disponibile, apoi rulează acțiunile prin API-ul fiecărei componente. Un agent schimbă un Select exact cum l-ar schimba codul tău, fără capturi de ecran și fără clickuri simulate.

import { createAgent } from "@ui-sdk/react/agent"

export const agent = createAgent()

agent.snapshot()
// [{ ref: "c1", component: "input", label: "Project name", value: "Apollo", actions: ["setValue", "clear"] }]

await agent.act({
  steps: [{ ref: "Project name", action: "setValue", args: ["Atlas"] }],
})

Vue, Svelte, Solid și Web Components au aceeași punte în @ui-sdk/vue/agent, @ui-sdk/svelte/agent și așa mai departe. Tu decizi ce are voie agentul să facă, pe trei niveluri:

  • Un callback allow în createAgent aprobă sau refuză fiecare acțiune înainte să ruleze. Întoarce un promise ca să aștepți confirmarea din propria interfață. Implicit, renunță după 5 minute.
  • Callback-urile de schimbare primesc details.source, care e "agent" pentru schimbările venite prin punte. Apelezi details.cancel() ca să păstrezi valoarea curentă.
  • Marcaje în markup
    • data-agent-confirm așteaptă mereu un om;
    • data-agent-hidden scoate o zonă din ce vede agentul;
    • data-agent-secret ascunde o valoare.

    Câmpurile de parolă, card și cod unic sunt tratate ca secrete și fără marcaj.
<Select
  defaultValue="europe"
  onValueChange={(value, details) => {
    if (details.source === "agent" && value === "asia-pacific") {
      details.cancel()
    }
  }}
>
  {/* eticheta, triggerul și opțiunile */}
</Select>

<Button data-agent-confirm="Îți taxează cardul cu 20 $ pentru 1.000 de credite" onClick={buyCredits}>
  Cumpără credite
</Button>

Pentru agenții din browser, registerTools publică snapshot, query și act prin WebMCP când browserul îl suportă, și nu face nimic când nu-l suportă:

import { createAgent, registerTools } from "@ui-sdk/react/agent"

const agent = createAgent()

const unregister = registerTools(agent, {
  allow: (step) => step.action !== "press" || window.confirm(`Apeși ${step.args[0]}?`),
})

E mai rapid decât să lași agentul să dea click prin pagină? Benchmark-ul Vercel spune că da, cu câteva rezerve. Un agent a redenumit un proiect, a actualizat membrii și setările, apoi a salvat. O rulare a folosit unelte de browser pe ecranul construit cu altă bibliotecă de componente, nenumită; cealaltă a folosit puntea pe același ecran construit cu UI SDK. Ambele au folosit Sonnet prin Claude Code, iar cifrele sunt mediane din trei rulări:

Unelte de browserPuntea UI SDKDiferență
Apeluri de tool-uri165−69%
Text citit (caractere)39,8k6,8k−83%
Timp41 s16 s−61%
Cost0,073 $0,032 $−56%

E un benchmark al producătorului, pe o singură sarcină, deci ia-l ca direcție, nu ca promisiune.

Tratează ce întorc tool-urile ca date nesigure, pentru că un snapshot poate conține text scris de utilizatori, de exemplu un nume dintr-un tabel. Orice costă bani sau șterge date trebuie să treacă pe la un om.

WebMCP funcționează într-un tab de browser, cu sesiunea utilizatorului. Când asistenții trebuie să ajungă la produsul tău fără un tab deschis, ai nevoie de un server MCP remote, despre care am scris în Servere MCP pentru SaaS.

Cum construiești componente UI SDK cu un agent de programare

Instalează skill-ul UI SDK și trimite-ți agentul la documentația care vine în pachete:

npx skills add vercel-labs/ui --skill ui-sdk

Fiecare pachet include documentație Markdown pentru versiunea exactă instalată, de exemplu node_modules/@ui-sdk/react/docs/llms.txt. Promptul oficial de instalare adaugă o notă în AGENTS.md care îi cere agentului s-o citească înainte să atingă cod UI SDK. Pentru un beta ale cărui API-uri încă se mișcă, documentația versiunii instalate bate orice își amintește modelul.

Începe cu o componentă mică, descrie interacțiunea, nu markup-ul, și verifică rezultatul cu kitul de testare de mai jos. Dacă și restul aplicației a fost construit rapid cu unelte AI, checklistul meu de producție pentru aplicații vibe-coded acoperă ce trebuie reparat înainte de lansare.

Cum testezi accesibilitatea cu kitul de testare UI SDK

@ui-sdk/core/testing verifică un widget randat după tiparul lui WAI-ARIA și testează direct primitivele:

import { checkPattern } from "@ui-sdk/core/testing"

await checkPattern(root, "dialog")

Kitul are trei unelte principale:

  • checkPattern verifică rolurile, numele, stările, referințele dintre părți și interacțiunile din tastatură, apoi aruncă o singură eroare cu toate problemele. Cele 15 tipare suportate sunt listbox, menu, menubar, tabs, radio group, toolbar, tree, dialog, alert dialog, disclosure, accordion, combobox, slider, switch și checkbox. Pe alocuri e intenționat mai strict decât WAI-ARIA Authoring Practices și cere Home și End în listbox-uri, tab-uri și toolbar-uri și aria-modal="true" pe dialogurile modale.
  • mount testează o primitivă cu clickuri, taste, scriere, hover și drag simulate și înregistrează fiecare schimbare cu motivul și sursa ei.
  • checkServer randează o primitivă fără DOM. Pică dacă primitiva citește variabile globale din browser, ceasul sau valori aleatorii, cauzele obișnuite ale nepotrivirilor la hidratare.

Testele de interacțiune au nevoie de jsdom sau de un browser real. Verificările de server nu.

UI SDK vs shadcn/ui, Radix, Base UI, React Aria și Nuxt UI

UI SDK seamănă cel mai mult cu Radix, Base UI și React Aria, care oferă tot piese accesibile, fără stiluri. Dintre bibliotecile de mai jos, e singura care servește cinci framework-uri din același core și singura cu o punte pentru agenți la rulare. Le menționează pe mai multe dintre ele ca sursă de inspirație, alături de Geist și WAI-ARIA Authoring Practices.

BibliotecăStilizareFramework-uriPunte pentru agenți la rulareMaturitate (nov. 2026)
UI SDKFără stiluri, temă implicită opționalăReact, Vue și Nuxt, Svelte, Solid, Web ComponentsDaBeta, 0.1
shadcn/uiTailwind, cod copiat în proiectReactNuFoarte folosit, CLI 4.x
Radix PrimitivesFără stiluriReactNuStabil de ani buni
Base UIFără stiluriReactNuStabil, 1.x
React AriaHook-uri și componente fără stiluriReactNuStabil, 1.x
Nuxt UITailwind, construit pe Reka UIVue, NuxtNuStabil, v4

Cum aș alege:

  • Ești mulțumit de shadcn/ui sau Nuxt UI? Rămâi pe ele. Nimic de aici nu te obligă să migrezi, iar un beta e o fundație slabă pentru un design system pe care îl livrezi clienților.
  • Pornești un design system pentru echipe React și Vue deopotrivă? UI SDK e prima opțiune în care aceeași primitivă se randează nativ în ambele, deci merită un prototip acum.
  • Construiești ecrane pe care le vor folosi agenți? Puntea pentru agenți e motivul să-l încerci. Nicio altă bibliotecă de aici nu o oferă.
  • Ai nevoie de o componentă pe care n-o are nimeni, ca un board kanban sau o cronologie pe care o derulezi? Construiește-o din comportamentele UI SDK, chiar dacă păstrezi altă bibliotecă pentru restul.

Este UI SDK gata de producție?

Încă nu, ca fundație pentru un design system folosit de clienți. E un beta public, documentația spune că API-urile se pot schimba și n-a ajuns la 1.0. E gata pentru prototipuri, unelte interne și componente izolate, dacă iei câteva măsuri:

  1. Fixează versiunile exacte (0.1.0-beta.1, fără caret) și actualizează intenționat, după ce citești changelogul.
  2. Învelește părțile în componente proprii, de exemplu un AppSelect, ca o schimbare de API să atingă un singur fișier.
  3. Stilizează prin data-slot și atributele de stare, niciodată prin ID-uri generate.
  4. Rulează checkPattern pe fiecare widget compus, în CI.
  5. Dă-i agentului de programare documentația versiunii instalate prin AGENTS.md și llms.txt, nu memoria lui.
  6. Înainte să expui puntea pentru agenți clienților, setează allow, marchează acțiunile costisitoare cu data-agent-confirm și ascunde zonele sensibile cu data-agent-hidden.
  7. Urmărește issue-urile de pe GitHub pentru componentele de care depinzi și raportează ce se strică. Pentru asta există un beta.

Cum te pot ajuta

Construiesc front-end-uri în Nuxt și React, inclusiv design systems și funcționalități AI, din România (CET), cu echipe din UE, Marea Britanie și SUA. Dacă te gândești la UI SDK pentru o bibliotecă de componente, o aplicație Nuxt sau o interfață pe care s-o folosească agenții, paginile de mai jos arată cum lucrez:

Spune-mi ce construiești și cere o ofertă. Îți răspund în cel mult o zi lucrătoare.

FAQ

UI SDK e făcut de Vercel?

Da. E un proiect Vercel Labs. Codul e pe github.com/vercel-labs/ui, site-ul documentației trimite la Vercel, iar beta-ul rulează sub termenii Vercel pentru beta public. E open source, sub licența Apache-2.0.

UI SDK e același lucru cu Vercel AI SDK?

Nu. AI SDK (pachetul ai, versiunea 7) conectează aplicațiile la modele de limbaj, pentru text, tool-uri și chat cu streaming. UI SDK (pachetele @ui-sdk/*, versiunea 0.1 beta) construiește componente accesibile și le permite agenților să le folosească. Merg bine împreună.

UI SDK e gratuit?

Da. E open source, sub Apache-2.0, și se instalează din npm, fără cont și fără cheie API.

Funcționează UI SDK cu Nuxt?

Da. @ui-sdk/vue include un modul Nuxt. Adaugi "@ui-sdk/vue" în modules, iar fiecare parte e importată automat și randată pe server. Are nevoie de Vue 3.5 sau mai nou, iar modulul suportă Nuxt 4 și 5.

UI SDK vine cu stiluri și merge cu Tailwind?

Componentele vin fără stiluri. @ui-sdk/core/web.css, opțional, le dă un aspect implicit neutru, care urmează modul luminos sau întunecat și se personalizează prin variabile --ui-*. Cu Tailwind, stilizezi părțile cu variante de atribut ca data-pressed:. Dacă vrei și stilurile implicite, importă web.css în layer(components).

Pot folosi UI SDK în producție?

E un beta public (0.1.0-beta.1 la momentul scrierii), iar API-urile se pot schimba până la 1.0. Folosește-l de acum pentru prototipuri, unelte interne și componente noi, de sine stătătoare. Dacă îl livrezi în producție, fixează versiunile exacte și învelește-i părțile în componente proprii.