Vercel AI SDK

bun add @databuddy/ai ai @ai-sdk/openai

import { createTracker } from "@databuddy/ai/vercel";
import { openai } from "@ai-sdk/openai";
import { generateText } from "ai";

const { track } = createTracker({
apiKey: process.env.DATABUDDY_API_KEY
});

const result = await generateText({
model: track(openai("gpt-4o")),
prompt: "Explain quantum computing in simple terms"
});

import { createTracker } from "@databuddy/ai/vercel";

const { track, transport } = createTracker({
// Required: API key for authentication
apiKey: process.env.DATABUDDY_API_KEY,

// Optional: Custom API endpoint
apiUrl: "https://basket.databuddy.cc/llm",

// Optional: Compute token costs (default: true)
computeCosts: true,

// Optional: Don't capture message content (default: false)
privacyMode: false,

// Optional: Max content size in bytes (default: 1MB)
maxContentSize: 1_048_576,

// Optional: Success callback
onSuccess: (call) => console.log("AI call completed:", call.traceId),

// Optional: Error callback
onError: (call) => console.error("AI call failed:", call.error)
});

import { createTracker } from "@databuddy/ai/vercel";
import { openai } from "@ai-sdk/openai";
import { anthropic } from "@ai-sdk/anthropic";
import { generateText, streamText } from "ai";

const { track } = createTracker({
apiKey: process.env.DATABUDDY_API_KEY
});

// Track OpenAI
const result1 = await generateText({
model: track(openai("gpt-4o")),
prompt: "Hello!"
});

// Track Anthropic
const result2 = await generateText({
model: track(anthropic("claude-sonnet-4-20250514")),
prompt: "Hello!"
});

// Streaming works too
const stream = await streamText({
model: track(openai("gpt-4o-mini")),
prompt: "Write a poem"
});

const { track } = createTracker({
apiKey: process.env.DATABUDDY_API_KEY
});

// Enable privacy mode for sensitive calls
const result = await generateText({
model: track(openai("gpt-4o"), {
  privacyMode: true,
  traceId: "custom-trace-123"
}),
prompt: "Process this sensitive data..."
});

import { createTracker } from "@databuddy/ai/vercel";
import { openai } from "@ai-sdk/openai";
import { generateText, tool } from "ai";
import { z } from "zod";

const { track } = createTracker({
apiKey: process.env.DATABUDDY_API_KEY
});

const result = await generateText({
model: track(openai("gpt-4o")),
prompt: "What's the weather in London?",
tools: {
  getWeather: tool({
    description: "Get current weather",
    parameters: z.object({
      city: z.string()
    }),
    execute: async ({ city }) => {
      return { temperature: 15, condition: "cloudy" };
    }
  })
}
});

// Tracked data includes:
// tools: {
//   callCount: 1,
//   resultCount: 1,
//   calledTools: ["getWeather"],
//   availableTools: ["getWeather"]
// }

import { createTracker } from "@databuddy/ai/vercel";
import { openai } from "@ai-sdk/openai";
import { streamText } from "ai";

const { track } = createTracker({
apiKey: process.env.DATABUDDY_API_KEY
});

const result = await streamText({
model: track(openai("gpt-4o")),
prompt: "Write a story"
});

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

// Usage data is tracked when stream completes

const { track } = createTracker({
apiKey: process.env.DATABUDDY_API_KEY,
onError: (call) => {
  console.error("AI call failed:", {
    model: call.model,
    error: call.error?.message,
    durationMs: call.durationMs
  });
}
});

try {
await generateText({
  model: track(openai("gpt-4o")),
  prompt: "..."
});
} catch (error) {
// Error is logged automatically, plus your onError callback runs
}

const { track } = createTracker({
apiKey: process.env.DATABUDDY_API_KEY,
privacyMode: true  // Don't capture prompts/responses
});

// Only usage, costs, and metadata are tracked
// input: [] and output: [] in the logged data

import { createTracker, httpTransport, type LLMCall } from "@databuddy/ai/vercel";

// Custom transport that logs locally and sends to API
const customTransport = async (call: LLMCall) => {
console.log("AI call:", {
  model: call.model,
  tokens: call.usage.totalTokens,
  cost: call.cost.totalCostUSD
});

// Also send to Databuddy
await httpTransport("https://basket.databuddy.cc/llm", "your-api-key")(call);
};

const { track } = createTracker({
transport: customTransport
});

import { createTracker, createTraceId } from "@databuddy/ai/vercel";

const { track } = createTracker({
apiKey: process.env.DATABUDDY_API_KEY
});

// Generate a trace ID for a conversation
const traceId = createTraceId();

// All calls in this conversation share the trace ID
const result1 = await generateText({
model: track(openai("gpt-4o"), { traceId }),
prompt: "What is 2+2?"
});

const result2 = await generateText({
model: track(openai("gpt-4o"), { traceId }),
prompt: "And what is that times 3?"
});

import {
createTracker,
httpTransport,
createTraceId,
type CallOptions,
type Cost,
type ErrorInfo,
type LLMCall,
type Message,
type TrackerOptions,
type Transport,
type Usage
} from "@databuddy/ai/vercel";