Quick Start Guide

npm install ants-platform
# or install specific packages
npm install @antsplatform/tracing @antsplatform/otel
# or
yarn add ants-platform
# or
pnpm add ants-platform

// For OpenTelemetry-based setup (recommended)
import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
import { resourceFromAttributes } from "@opentelemetry/resources";
import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions";
import { AntsPlatformSpanProcessor } from "@antsplatform/otel";
import { setAntsPlatformTracerProvider } from "@antsplatform/tracing";
 
// Create the Ants Platform span processor
const processor = new AntsPlatformSpanProcessor({
  publicKey: process.env.ANTS_PLATFORM_PUBLIC_KEY,
  secretKey: process.env.ANTS_PLATFORM_SECRET_KEY,
  baseUrl: process.env.ANTS_PLATFORM_HOST || "https://api.agenticants.ai",
  environment: process.env.ANTS_PLATFORM_ENVIRONMENT || "production",
});
 
// Create tracer provider
const provider = new NodeTracerProvider({
  resource: resourceFromAttributes({
    [SemanticResourceAttributes.SERVICE_NAME]: "my-agent",
    [SemanticResourceAttributes.SERVICE_VERSION]: "1.0.0",
  }),
  spanProcessors: [processor],
});
 
// Register with Ants Platform and globally
setAntsPlatformTracerProvider(provider);
provider.register();
 
console.log('✅ Ants Platform tracing initialized');

import { startObservation } from '@antsplatform/tracing'
import OpenAI from 'openai'
 
const openai = new OpenAI()
 
async function customerSupportAgent(query: string) {
  // Start a trace
  const trace = startObservation('customer-support-agent', {
    input: { user_input: query },
    metadata: {
      agent: 'customer-support',
      channel: 'web-chat',
      priority: 'high'
    }
  })
 
  // Set trace-level attributes
  trace.updateTrace({
    userId: 'user_123',
    tags: ['agent:customer-support', 'service:my-app', 'version:1.0.0']
  })
 
  try {
    // Create a span for request validation
    const validationSpan = trace.startObservation('request_validation', {
      input: { raw_input: query },
      metadata: { step: 'validation' }
    })
    // Validate input...
    validationSpan.update({
      output: { validated_input: query, input_length: query.length }
    })
    validationSpan.end()
 
    // Create a span for LLM call
    const llmSpan = trace.startObservation('llm_preparation', {
      input: { model: 'gpt-4', task: 'customer-support' },
      metadata: { step: 'preparation' }
    })
    llmSpan.end()
 
    // Your agent logic
    const response = await openai.chat.completions.create({
      model: 'gpt-4',
      messages: [
        { role: 'system', content: 'You are a helpful customer support agent.' },
        { role: 'user', content: query }
      ]
    })
 
    const output = response.choices[0].message.content
 
    // Create generation span for LLM call
    const generation = trace.startObservation('gpt-4_llm_call', {
      model: 'gpt-4',
      input: query,
      output: output,
      usageDetails: {
        input: response.usage.prompt_tokens,
        output: response.usage.completion_tokens,
        total: response.usage.total_tokens
      },
      metadata: {
        step: 'llm_call',
        status: 'success',
        agent: 'customer-support'
      }
    }, { asType: 'generation' })
    generation.end()
 
    // Update trace with final results
    trace.update({
      output: { result: output },
      metadata: {
        input_tokens: response.usage.prompt_tokens,
        output_tokens: response.usage.completion_tokens,
        total_tokens: response.usage.total_tokens,
        status: 'success'
      }
    })
 
    // End the trace
    trace.end()
 
    return output
  } catch (error) {
    // Log errors
    const errorSpan = trace.startObservation('error_handling', {
      input: { error: error.message },
      output: { error_response: error.message },
      level: 'ERROR',
      metadata: {
        error_type: error.name,
        step: 'error_handling'
      }
    })
    errorSpan.end()
 
    trace.update({
      level: 'ERROR',
      output: { error: error.message }
    })
    trace.end()
 
    throw error
  }
}
 
// Use your agent
const result = await customerSupportAgent('How do I track my order?')
console.log(result)