Anthropic Integration

The Anthropic integration provides automatic monitoring for Claude API calls with minimal code changes. Simply wrap your existing Anthropic client to start tracking all interactions, token usage, costs, and compliance violations.

Prerequisites

@anthropic-ai/sdk package installed
Agent Governance SDK installed
Valid Anthropic and Agent Governance API keys

Basic Setup

Installation

If you haven’t already, install both the Anthropic SDK and Agent Governance SDK:

npm install @anthropic-ai/sdk @agent-governance/node

Initialize the Monitor

Use the AnthropicAgentMonitor class for automatic Claude monitoring:

import { AnthropicAgentMonitor } from '@agent-governance/node';
import Anthropic from '@anthropic-ai/sdk';

const monitor = new AnthropicAgentMonitor({
  apiKey: 'your-governance-api-key',
  organizationId: 'your-org-id',
  environment: 'development',
  enableComplianceChecks: true
});

Register Your Agent

await monitor.registerAgent({
  id: 'banking-claude',
  name: 'Banking Assistant Claude',
  category: 'tool_calling',
  specialty: 'personal_banking',
  version: '1.0.0',
  llmProvider: 'anthropic',
  model: 'claude-3-5-sonnet-20241022',
  description: 'Claude-powered banking assistant',
  complianceSettings: {
    sr11_7_enabled: true,
    fair_lending_monitoring: true,
    bsa_aml_checks: true
  }
});

Wrap the Anthropic Client

Wrap your existing Anthropic client to enable automatic monitoring:

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY
});

// Wrap the client - all API calls will now be monitored
const monitoredAnthropic = monitor.wrapAnthropic(anthropic, 'banking-claude');

Usage Examples

Basic Conversation

// Use the wrapped client exactly like the normal Anthropic client
const response = await monitoredAnthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 1000,
  messages: [
    {
      role: 'user',
      content: 'Can you help me understand my account balance?'
    }
  ],
  sessionId: 'customer-session-456' // Optional: links events together
});

console.log(response.content[0].text);
// Response: "I'd be happy to help you understand your account balance..."

With Tool Calls

The integration automatically tracks when Claude decides to call tools:

const response = await monitoredAnthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 1000,
  messages: [
    {
      role: 'user',
      content: 'What is my current checking account balance?'
    }
  ],
  tools: [
    {
      name: 'get_account_balance',
      description: 'Get the current balance for a bank account',
      input_schema: {
        type: 'object',
        properties: {
          account_type: {
            type: 'string',
            description: 'Type of account (checking, savings, etc.)'
          }
        },
        required: ['account_type']
      }
    }
  ],
  sessionId: 'banking-session-789'
});

// If Claude decides to call a tool, it's automatically tracked
// Tool calls are logged with parameters and execution details

Multi-turn Conversations

For conversations with multiple exchanges, including tool results:

// Initial user message
let messages = [
  { role: 'user', content: 'I want to check my account and transfer money' }
];

let response = await monitoredAnthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  messages,
  tools: bankingTools,
  sessionId: 'banking-session-123'
});

// Add Claude's response to conversation
messages.push({ role: 'assistant', content: response.content });

// If Claude used a tool, add the tool result
if (response.content.some(content => content.type === 'tool_use')) {
  messages.push({
    role: 'user',
    content: [
      {
        type: 'tool_result',
        tool_use_id: 'tool_abc123',
        content: JSON.stringify({ balance: 2547.83, currency: 'USD' })
      }
    ]
  });

  // Continue the conversation
  response = await monitoredAnthropic.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    messages,
    sessionId: 'banking-session-123' // Same session ID
  });
}

Automatic Tracking Features

The Anthropic integration automatically captures:

Conversation Events

Conversation Start: When a new session begins
User Messages: All user inputs including text and tool results
Agent Responses: Claude’s text responses
Tool Calls: When Claude decides to use a tool

Performance Metrics

Latency: Time taken for each API call
Token Usage: Input, output, and total tokens
Cost Calculation: Automatic cost tracking based on model pricing
Response Quality: Optional quality scoring

Compliance Monitoring

PII Detection: Scans for personal information in responses
Fair Lending: Checks for discriminatory language
BSA/AML: Monitors for suspicious activity indicators

Configuration Options

Session Management

Link related interactions by providing a sessionId:

const response = await monitoredAnthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  messages: [{ role: 'user', content: 'Hello' }],
  sessionId: 'unique-session-id' // Groups related events
});

Monitoring Options

Pass additional monitoring configuration:

const monitoredAnthropic = monitor.wrapAnthropic(anthropic, 'agent-id', {
  userId: 'customer-123',
  trackConversationStart: true, // Default: true
  agentCategory: 'tool_calling',
  agentSpecialty: 'personal_banking'
});

Custom User Identification

Track which customer is interacting with the agent:

const response = await monitoredAnthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  messages: [{ role: 'user', content: 'What services do you offer?' }],
  sessionId: 'session-456',
  userId: 'customer-789' // Links events to specific user
});

Cost Tracking

The integration automatically calculates costs based on Claude’s pricing:

Claude 3.5 Sonnet
Claude 3 Haiku
Claude 3 Opus

Input: $3 per million tokens
Output: $15 per million tokens

Costs are automatically calculated and included in the tracked events:

// Cost calculation happens automatically
const response = await monitoredAnthropic.messages.create({
  model: 'claude-3-haiku-20240307', // Lower cost model
  messages: [{ role: 'user', content: 'Quick question' }]
});

// Check your governance dashboard for cost analytics

Error Handling

The wrapper preserves normal error handling while tracking errors:

try {
  const response = await monitoredAnthropic.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    messages: [{ role: 'user', content: 'Hello' }],
    sessionId: 'session-123'
  });
} catch (error) {
  // Error is automatically tracked and then re-thrown
  console.error('API call failed:', error.message);
  // Handle error normally
}

Banking Example

Here’s a complete example for a banking use case:

import { AnthropicAgentMonitor } from '@agent-governance/node';
import Anthropic from '@anthropic-ai/sdk';

async function bankingAssistantExample() {
  // Initialize monitor
  const monitor = new AnthropicAgentMonitor({
    apiKey: process.env.AGENT_GOVERNANCE_API_KEY,
    organizationId: 'first-national-bank',
    environment: 'production',
    enableComplianceChecks: true
  });

  // Register banking agent
  await monitor.registerAgent({
    id: 'personal-banking-claude',
    name: 'Personal Banking Assistant',
    category: 'tool_calling',
    specialty: 'personal_banking',
    version: '2.1.0',
    llmProvider: 'anthropic',
    model: 'claude-3-5-sonnet-20241022',
    description: 'AI assistant for personal banking services',
    availableTools: [
      {
        name: 'get_account_summary',
        description: 'Retrieves account balance and recent transactions',
        category: 'banking',
        riskLevel: 'medium'
      },
      {
        name: 'transfer_funds',
        description: 'Transfers money between accounts',
        category: 'banking',
        riskLevel: 'high'
      }
    ],
    complianceSettings: {
      sr11_7_enabled: true,
      fair_lending_monitoring: true,
      bsa_aml_checks: true
    }
  });

  // Initialize Claude client
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  // Wrap with monitoring
  const monitoredClaude = monitor.wrapAnthropic(
    anthropic,
    'personal-banking-claude',
    {
      agentCategory: 'tool_calling',
      agentSpecialty: 'personal_banking'
    }
  );

  // Handle customer interaction
  const sessionId = `banking-${Date.now()}`;
  const response = await monitoredClaude.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 1000,
    messages: [
      {
        role: 'user',
        content: 'I need to check my account balance and possibly transfer some money to my savings account.'
      }
    ],
    tools: bankingTools, // Your banking tool definitions
    sessionId: sessionId
  });

  console.log('Claude Response:', response.content[0].text);

  // Cleanup
  await monitor.shutdown();
}

bankingAssistantExample().catch(console.error);

Best Practices

Troubleshooting

Events not appearing in dashboard

Ensure you’ve properly configured your API key and organization ID. Check that monitor.flush() is called if you’re not seeing events immediately.

Cost calculations seem incorrect

Verify you’re using the correct model name. Cost calculations are based on the model specified in your API call.

Compliance violations not detected

Make sure enableComplianceChecks: true is set in your monitor configuration. Compliance checks only run on agent responses.

Tool calls not being tracked

Tool calls are automatically detected when Claude returns tool_use content. Ensure your tools are properly configured in your Claude API call.

Next Steps

OpenAI Integration

Learn about monitoring GPT models

Manual Tracking

Advanced event tracking capabilities

Compliance Engine

Deep dive into compliance monitoring

Configuration

Advanced configuration options

Getting Started

Core Features

Integrations

Examples

Prerequisites

Basic Setup

Installation

Initialize the Monitor

Register Your Agent

Wrap the Anthropic Client

Usage Examples

Basic Conversation

With Tool Calls

Multi-turn Conversations

Automatic Tracking Features

Conversation Events

Performance Metrics

Compliance Monitoring

Configuration Options

Session Management

Monitoring Options

Custom User Identification

Cost Tracking

Error Handling

Banking Example

Best Practices

Troubleshooting

Next Steps

OpenAI Integration

Manual Tracking

Compliance Engine

Configuration

Getting Started

Core Features

Integrations

Examples

Documentation Index

​Prerequisites

​Basic Setup

​Installation

​Initialize the Monitor

​Register Your Agent

​Wrap the Anthropic Client

​Usage Examples

​Basic Conversation

​With Tool Calls

​Multi-turn Conversations

​Automatic Tracking Features

​Conversation Events

​Performance Metrics

​Compliance Monitoring

​Configuration Options

​Session Management

​Monitoring Options

​Custom User Identification

​Cost Tracking

​Error Handling

​Banking Example

​Best Practices

​Troubleshooting

​Next Steps

OpenAI Integration

Manual Tracking

Compliance Engine

Configuration

Prerequisites

Basic Setup

Installation

Initialize the Monitor

Register Your Agent

Wrap the Anthropic Client

Usage Examples

Basic Conversation

With Tool Calls

Multi-turn Conversations

Automatic Tracking Features

Conversation Events

Performance Metrics

Compliance Monitoring

Configuration Options

Session Management

Monitoring Options

Custom User Identification

Cost Tracking

Error Handling

Banking Example

Best Practices

Troubleshooting

Next Steps