Observability for OpenAI (TypeScript) with Opik

1
import OpenAI from "openai";
2
import { trackOpenAI } from "opik-openai";
3
4
// Initialize the original OpenAI client
5
const openai = new OpenAI({
6
  apiKey: process.env.OPENAI_API_KEY,
7
});
8
9
// Wrap the client with Opik tracking
10
const trackedOpenAI = trackOpenAI(openai);
11
12
// Use the tracked client just like the original
13
const completion = await trackedOpenAI.chat.completions.create({
14
  model: "gpt-5",
15
  messages: [{ role: "user", content: "Hello, how can you help me today?" }],
16
});
17
18
console.log(completion.choices[0].message.content);
19
20
// Ensure all traces are sent before your app terminates
21
await trackedOpenAI.flush();

1
import OpenAI from "openai";
2
import { trackOpenAI } from "opik-openai";
3
4
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
5
const trackedOpenAI = trackOpenAI(openai);
6
7
async function streamingExample() {
8
  // Create a streaming chat completion
9
  const stream = await trackedOpenAI.chat.completions.create({
10
    model: "gpt-5-nano",
11
    messages: [{ role: "user", content: "What is streaming?" }],
12
    stream: true,
13
    // Include usage in the stream
14
    stream_options: {
15
      include_usage: true,
16
    },
17
  });
18
19
  // Process the stream
20
  let streamedContent = "";
21
  for await (const chunk of stream) {
22
    const content = chunk.choices[0]?.delta?.content || "";
23
    process.stdout.write(content);
24
    streamedContent += content;
25
  }
26
27
  console.log("\nStreaming complete!");
28
29
  // Don't forget to flush when done
30
  await trackedOpenAI.flush();
31
}
32
33
streamingExample();

1
import OpenAI from "openai";
2
import { trackOpenAI } from "opik-openai";
3
import { Opik } from "opik";
4
5
// Optional: Create a custom Opik client
6
const customOpikClient = new Opik({
7
  apiKey: "YOUR_OPIK_API_KEY", // If not using environment variables
8
  projectName: "openai-integration-project",
9
});
10
11
const existingOpikTrace = customOpikClient.trace({
12
  name: `Trace`,
13
  input: {
14
    prompt: `Hello, world!`,
15
  },
16
  output: {
17
    response: `Hello, world!`,
18
  },
19
});
20
21
const openai = new OpenAI({
22
  apiKey: process.env.OPENAI_API_KEY,
23
});
24
25
// Configure the tracked client with options
26
const trackedOpenAI = trackOpenAI(openai, {
27
  // Optional array of tags to apply to all traces
28
  traceMetadata: {
29
    tags: ["openai", "production", "user-query"],
30
31
    // Optional metadata to include with all traces
32
    environment: "production",
33
    version: "1.2.3",
34
    component: "recommendation-engine",
35
  },
36
37
  // Optional custom name for the generation/trace
38
  generationName: "ProductRecommendationService",
39
40
  // Optional pre-configured Opik client
41
  // If not provided, a singleton instance will be used
42
  client: customOpikClient,
43
44
  // Optional parent trace for hierarchical relationships
45
  parent: existingOpikTrace,
46
});
47
48
// Use the tracked client with your configured options
49
const response = await trackedOpenAI.embeddings.create({
50
  model: "text-embedding-ada-002",
51
  input: "This is a sample text for embeddings",
52
});
53
54
// Close the existing trace
55
existingOpikTrace.end();
56
57
// Flush before your application exits
58
await trackedOpenAI.flush();