import OpenAI from 'openai';

const openai = new OpenAI();

const generation = trace.generation({
  name: 'openai-call',
  model: 'gpt-4o',
  modelParameters: { temperature: 0.3, maxTokens: 512 },
  input: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'What is the capital of France?' },
  ],
});

const result = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'What is the capital of France?' },
  ],
});

generation.end({
  output: result.choices[0].message,
  usage: {
    input: result.usage?.prompt_tokens,
    output: result.usage?.completion_tokens,
  },
});

import openai

openai_client = openai.OpenAI(api_key=os.environ["OPENAI_API_KEY"])

generation = trace.start_generation(
    name="generate-answer",
    model="gpt-4o",
    input=[
        {"role": "system", "content": "Answer based on the provided context."},
        {"role": "user", "content": "What is the capital of France?"},
    ],
)

response = openai_client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Answer based on the provided context."},
        {"role": "user", "content": "What is the capital of France?"},
    ],
)

answer = response.choices[0].message.content
generation.update(
    output=answer,
    usage_details={"input": response.usage.prompt_tokens, "output": response.usage.completion_tokens},
)
generation.end()

import com.browserstack.aisdk.tracing.model.GenerationBody;
import com.browserstack.aisdk.tracing.model.Usage;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.*;

OpenAIClient openai = OpenAIOkHttpClient.fromEnv();

long genStart = System.currentTimeMillis();

ChatCompletion response = openai.chat().completions().create(
    ChatCompletionCreateParams.builder()
        .model("gpt-4o")
        .addMessage(ChatCompletionMessageParam.ofUser("What causes Northern Lights?"))
        .build()
);

String answer = response.choices().get(0).message().content();

trace.generation(GenerationBody.builder()
    .name("gpt-4o-call")
    .model("gpt-4o")
    .input(List.of(Map.of("role", "user", "content", "What causes Northern Lights?")))
    .output(answer)
    .usage(Usage.builder()
        .promptTokens(120)
        .completionTokens(85)
        .totalTokens(205)
        .build())
    .startTime(genStart)
    .endTime(System.currentTimeMillis())
    .modelParameters(Map.of("temperature", 0.7, "maxTokens", 512))
    .build());

import { AISDK } from '@browserstack/ai-sdk';
import OpenAI from 'openai';

const testOps = new AISDK({
  publicKey: process.env.AISDK_PUBLIC_KEY,
  secretKey: process.env.AISDK_SECRET_KEY,
});
const openai = new OpenAI();

async function runRagPipeline(question) {
  const trace = testOps.trace({
    name: 'rag-pipeline',
    input: { question },
    tags: ['rag', 'production'],
  });

  // Step 1: Retrieve context
  const retrievalSpan = trace.span({
    name: 'retrieval',
    input: { query: question },
  });
  const context = await retrieveDocuments(question);
  retrievalSpan.end({ output: context });

  // Step 2: Generate answer
  const generation = trace.generation({
    name: 'answer-generation',
    model: 'gpt-4o',
    input: [
      { role: 'system', content: 'Answer using the provided context.' },
      { role: 'user', content: `Context:\n${context}\n\nQuestion: ${question}` },
    ],
  });

  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      { role: 'system', content: 'Answer using the provided context.' },
      { role: 'user', content: `Context:\n${context}\n\nQuestion: ${question}` },
    ],
  });

  const answer = response.choices[0].message.content ?? '';
  generation.end({
    output: answer,
    usage: {
      input: response.usage?.prompt_tokens,
      output: response.usage?.completion_tokens,
    },
  });

  trace.update({ output: answer });
  await testOps.shutdown();
  return answer;
}

async function retrieveDocuments(question) {
  return 'Paris is the capital of France. France is a country in Europe.';
}

await runRagPipeline('What is the capital of France?');

import os
from browserstack_ai_sdk import AISDK
import openai

client = AISDK(
    public_key=os.environ["AISDK_PUBLIC_KEY"],
    secret_key=os.environ["AISDK_SECRET_KEY"],
)
openai_client = openai.OpenAI()

def run_rag_pipeline(question: str) -> str:
    trace = client.trace(
        name="rag-pipeline",
        user_id="user-123",
        session_id="session-abc",
        tags=["rag", "production"],
    )

    # Step 1: Retrieve context
    retrieval_span = trace.span(
        name="retrieve-documents",
        input={"query": question},
    )
    documents = ["France is a country in Western Europe. Its capital is Paris."]
    retrieval_span.update(output={"documents": documents})
    retrieval_span.end()

    # Step 2: Generate answer
    generation = trace.start_generation(
        name="generate-answer",
        model="gpt-4o",
        input=[
            {"role": "system", "content": "Answer based on the provided context."},
            {"role": "user", "content": question},
        ],
    )

    response = openai_client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "Answer based on the provided context."},
            {"role": "user", "content": question},
        ],
    )

    answer = response.choices[0].message.content
    generation.update(output=answer, usage_details={"input": 50, "output": 20})
    generation.end()
    trace.update(output=answer)

    trace.score(name="answer-quality", value=0.9)

    client.flush()
    return answer

result = run_rag_pipeline("What is the capital of France?")
print(result)

import com.browserstack.aisdk.TestOps;
import com.browserstack.aisdk.tracing.TraceManager;
import com.browserstack.aisdk.tracing.model.*;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.*;
import java.util.List;
import java.util.Map;

public class TracingExample {
    public static void main(String[] args) throws Exception {
        TestOps sdk = TestOps.fromEnv();
        TraceManager tm = sdk.traceManager();

        String question = "What causes Northern Lights?";

        var trace = tm.trace(TraceBody.builder()
            .name("rag-pipeline")
            .input(question)
            .userId("user-42")
            .environment("production")
            .build());

        // Retrieve documents
        long t0 = System.currentTimeMillis();
        List<String> docs = List.of("Aurora borealis occur when...", "Solar particles...");
        trace.span(SpanBody.builder()
            .name("retrieval")
            .input(question)
            .output(docs)
            .startTime(t0)
            .endTime(System.currentTimeMillis())
            .build());

        // Call the LLM
        OpenAIClient openai = OpenAIOkHttpClient.fromEnv();
        long genStart = System.currentTimeMillis();
        ChatCompletion response = openai.chat().completions().create(
            ChatCompletionCreateParams.builder()
                .model("gpt-4o")
                .addMessage(ChatCompletionMessageParam.ofUser(question))
                .build()
        );
        String answer = response.choices().get(0).message().content();

        var gen = trace.generation(GenerationBody.builder()
            .name("gpt-4o-call")
            .model("gpt-4o")
            .input(List.of(Map.of("role", "user", "content", question)))
            .output(answer)
            .usage(Usage.builder().promptTokens(200).completionTokens(120).totalTokens(320).build())
            .startTime(genStart)
            .endTime(System.currentTimeMillis())
            .build());

        gen.score(ScoreBody.builder().name("faithfulness").value(0.95).build());
        trace.update(TraceBody.builder().output(answer).build());

        tm.flush();
        sdk.shutdown();
    }
}