Overview

Learn how to implement AI tracking using Handit.AI's wrapper-based approach.

Set Up Agent Configuration

Copy your agent's tracking configuration from the Connect Agent section in the AI Performance Hub:

Node.js

const agentsTrackingConfig = {
  "myAgentName": {                          // Your agent name
    "classifierNode": "agent-classifier",    // Node slugs
    "processorNode": "agent-processor",
    "apiCallNode": "agent-api-call",
    "storageNode": "agent-storage"
  }
}

Python

agent_config = {
    "my_agent_name": {                      // Your agent name
        "classifier_node": "agent-classifier",    // Node slugs
        "processor_node": "agent-processor",
        "api_call_node": "agent-api-call",
        "storage_node": "agent-storage"
    }
}

Basic Implementation

Node.js

import { startAgentTracing, traceAgentNode } from '@handit.ai/node';
import { OpenAI } from 'openai';

const openai = new OpenAI();

// Define your agent function
async function myAgent(input) {
  // Define a node (e.g., GPT call)
  const gptNode = async (messages) => {
    const response = await openai.chat.completions.create({
      messages,
      model: "gpt-4"
    });
    return response;
  };
  
  // Wrap node with tracing
  const tracedGpt = traceAgentNode({
    agentNodeId: agentsTrackingConfig.myAgentName.processorNode,  // Use your agent and node names
    callback: gptNode
  });
  
  // Execute traced node
  return await tracedGpt(input);
}

// Wrap entire agent with tracing
const tracedAgent = startAgentTracing(myAgent);

// Use the agent
const result = await tracedAgent({ 
  messages: [{ role: "user", content: "Hello!" }] 
});

Python

from handit import HanditTracker
from openai import OpenAI

# Initialize tracker and OpenAI client
tracker = HanditTracker()
client = OpenAI()

# Using decorator for agent tracing
@tracker.start_agent_tracing()
def process_message(request: MessageRequest):
    # Agent logic here
    result = generate_response(request)
    return result

# Method 1: Using decorator for node tracing
@tracker.trace_agent_node(agent_config["my_agent_name"]["classifier_node"])  # Use your agent and node names
def classify_intent(message: str):
    # Classification logic
    return intent

# Method 2: Using function wrapper for node tracing
def generate_response(request):
    response = tracker.trace_agent_node_func_sync(
        client.chat.completions.create,
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": request.message}
        ],
        temperature=0.7,
        max_tokens=200,
        key=agent_config["my_agent_name"]["processor_node"]  # Use your agent and node names
    )
    return response

Advanced Usage

Multiple Node Tracing

Track multiple nodes within a single agent:

Node.js

async function complexAgent(input) {
  // First node: Document compression
  const compressNode = traceAgentNode({
    agentNodeId: agentsTrackingConfig.myAgentName.storageNode,
    callback: async (doc) => {/* compression logic */}
  });
  
  // Second node: Task assignment
  const assignNode = traceAgentNode({
    agentNodeId: agentsTrackingConfig.myAgentName.processorNode,
    callback: async (task) => {/* assignment logic */}
  });
  
  const compressed = await compressNode(input);
  const assigned = await assignNode(compressed);
  return assigned;
}

const tracedComplexAgent = startAgentTracing(complexAgent);

Python

from handit import HanditTracker

tracker = HanditTracker()

@tracker.start_agent_tracing()
def complex_process(input_data):
    # Method 1: Using decorator
    @tracker.trace_agent_node(agent_config["my_agent_name"]["classifier_node"])
    def classify_intent(text):
        # Intent classification logic
        return intent
    
    # Method 2: Using function wrapper
    response = tracker.trace_agent_node_func_sync(
        generate_response,
        intent=intent,
        context=context,
        key=agent_config["my_agent_name"]["processor_node"]
    )
    
    intent = classify_intent(input_data)
    final_response = response
    return final_response

Error Handling

The wrappers automatically handle errors without breaking your application:

Node.js

[Previous Node.js implementation remains the same]

Python

@tracker.start_agent_tracing()
def process_with_error_handling(input_data):
    try:
        # Method 1: Using decorator
        @tracker.trace_agent_node(agent_config["my_agent_name"]["risky_operation"])
        def risky_operation(data):
            # Your risky operation here
            return result

        # Method 2: Using function wrapper
        result = tracker.trace_agent_node_func_sync(
            risky_function,
            input_data=input_data,
            key=agent_config["my_agent_name"]["another_operation"]
        )
        
        return result
    except Exception as e:
        # Error will be tracked automatically
        return fallback_response

Tracking AI Tools

Software Tools

• APIs

• Databases

• External AI models

Non-Software Tools

• Hardware sensors

• Human escalations