A proof-of-concept showing how to integrate Tapes with the Vercel AI SDK using a custom fetch wrapper.

This integration routes AI SDK requests through a local Tapes proxy for:

• 📼 Recording all LLM requests/responses
• 🔍 Searchable conversation history
• 🔄 Replay and checkpointing of agent sessions
• 📊 Observability without modifying the AI SDK

┌─────────────┐      ┌─────────────┐      ┌─────────────────┐
│   AI SDK    │ ───► │ Tapes Proxy │ ───► │ LLM Provider    │
│ (your app)  │      │ (localhost) │      │ (OpenAI/Claude) │
└─────────────┘      └─────────────┘      └─────────────────┘
                            │
                            ▼
                   ┌─────────────────┐
                   │ PostgreSQL /    │
                   │ SQLite (storage)│
                   └─────────────────┘

curl -fsSL https://download.tapes.dev/install | bash

# Recommended: Start Tapes with PostgreSQL storage
tapes serve --postgres "postgres://user:pass@localhost:5432/tapes"

# Or use the default SQLite storage
tapes serve

cd tapes-ai-sdk-example
npm install

# For OpenAI
export OPENAI_API_KEY=sk-...

# Or for Anthropic
export ANTHROPIC_API_KEY=sk-ant-...
export PROVIDER=anthropic

# Smoke test + start server (runs examples, then chat, then web UI)
npm start

# Or run individually:
npm run dev      # examples only
npm run chat     # interactive CLI chat
npm run server   # web UI only

The tapes/ai.js module centralizes all proxy and provider configuration:

// Pre-configured singletons (reads env vars at import time)
import { model, config } from './tapes/ai.js';

const { text } = await generateText({
  model,
  prompt: 'Hello, world!',
});

For server use where each request needs its own session tracking:

import { createSessionModel } from './tapes/ai.js';

const model = createSessionModel('user-123-chat');

import { createTapesProvider } from './tapes/ai.js';

const { provider, model } = createTapesProvider({
  sessionId: 'my-session',
  provider: 'anthropic',
  model: 'claude-sonnet-4-5-20250929',
  debug: true,
});

For direct control, use tapes-fetch.js directly:

import { createTapesFetch } from './tapes-fetch.js';
import { createOpenAI } from '@ai-sdk/openai';

const tapesFetch = createTapesFetch({
  proxyUrl: 'http://localhost:8080',
  headers: { 'X-Tapes-Session': 'my-session-id' },
});

const openai = createOpenAI({
  fetch: tapesFetch,
  apiKey: process.env.OPENAI_API_KEY,
});

The npm run server command launches an Express server with a browser-based chat interface at http://localhost:3000. It uses streamText to stream responses in real-time through the Tapes proxy and renders them in a dark-themed chat UI with session tracking and conversation clearing.

Requests through the Tapes proxy automatically retry on network errors (ECONNREFUSED, ECONNRESET, ETIMEDOUT) and HTTP 502/503/504 responses using exponential backoff.

When failover is enabled and all proxy retries are exhausted, one final attempt is made directly to the LLM provider, bypassing the proxy. This keeps your app functional even when the Tapes proxy is down.

const { model } = createTapesProvider({
  retry: { maxAttempts: 5, initialDelayMs: 1000, maxDelayMs: 10000 },
  failover: true,
});

Add metadata to your requests for better organization:

const tapesFetch = createTapesFetch({
  proxyUrl: 'http://localhost:8080',
  headers: {
    'X-Tapes-Session': 'user-123-chat',
    'X-Tapes-App': 'my-chatbot',
    'X-Tapes-Environment': 'production',
  },
});

Tapes supports three storage backends:

PostgreSQL is the recommended default for anything beyond local experimentation. Pass the DSN via the CLI flag or set TAPES_POSTGRES_DSN in your environment:

# Via CLI flag
tapes serve --postgres "postgres://user:pass@localhost:5432/tapes"

# Or via env var
export TAPES_POSTGRES_DSN="postgres://user:pass@localhost:5432/tapes"
tapes serve --postgres "$TAPES_POSTGRES_DSN"

For remote providers, team setup, and managed Postgres options, see the PostgreSQL Storage guide on tapes.dev.

After running conversations through Tapes:

# Search conversations
tapes search "your query"

# View recent activity
tapes log

# Checkout a previous state
tapes checkout <hash>

Tapes stores all recorded data in either PostgreSQL or SQLite (at ~/.tapes/tapes.sqlite for local). The schema is the same for both backends.

The primary table — each row is a message node in a conversation tree:

Indexed on parent_hash, role, model, provider, and (role, model).

Messages form a directed acyclic graph (DAG) via parent_hash references:

• Root nodes (parent_hash is null) are conversation starts
• Branching — multiple children can share a parent, enabling conversation forks
• Checkpointing — tapes checkout <hash> restores any previous state
• Replay — walk the DAG to replay or inspect conversation history

The vec_embeddings table stores 768-dimensional float vectors for semantic search, linked to nodes via the vec_documents table. Query with tapes search "your query".

• tapes/ai.js - Pre-configured provider wrapper (main entry point)
• tapes-fetch.js - Low-level custom fetch wrapper for Tapes proxy
• index.js - Example usage (generateText, streamText, multi-turn conversation)
• chat.js - Interactive CLI chat
• server.js - Express web server with chat UI
• public/index.html - Web chat interface

MIT