Quickstart Guide

Follow this guide to start tracking and optimizing your AI agents with Handit.AI.

Quick Setup

1. Get Your Agent Configuration

1. Go to the AI Performance Hub in Handit.AI

2. Click on "Connect Agent" in the navigation bar

3. Copy your agent's tracking configuration:

// This configuration is generated in the Connect Agent section
const agentsTrackingConfig = {
  "supportAgent": {
    "initialPrompt": "support-agent-initial",
    "followUp": "support-agent-followup",
    "summary": "support-agent-summary"
  },
  // ... other agents and their nodes
};

These slugs are unique identifiers for your agent nodes and will be used in the tracking setup.

2. Install the SDK

Node.js

npm install @handit.ai/node

Python

pip install handit

3. Configure Your API Key

Get your API key from the Handit.AI Dashboard.

Node.js

const { config } = require('@handit.ai/node');
config({ apiKey: 'your-api-key' });

Python

from handit import HanditTracker
tracker = HanditTracker(api_key="your-api-key")

Tracking Your AI Agent

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.supportAgent.initialPrompt,
    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 start_agent_tracing, trace_agent_node
from openai import OpenAI

client = OpenAI()

class MyAgent:
    @start_agent_tracing
    async def process(self, input_data):
        # Define a node (e.g., GPT call)
        async def gpt_node(messages):
            response = await client.chat.completions.create(
                messages=messages,
                model="gpt-4"
            )
            return response
        
        # Wrap node with tracing
        traced_gpt = trace_agent_node({
            "agent_node_id": agents_tracking_config["support_agent"]["initial_prompt"],
            "callback": gpt_node
        })
        
        # Execute traced node
        return await traced_gpt(input_data)

# Use the agent
agent = MyAgent()
result = await agent.process({"messages": [{"role": "user", "content": "Hello!"}]})

Automatic Optimization

Handit.AI automatically optimizes your agent's performance based on tracked data. Access optimized configurations:

Node.js

const { fetchOptimizedPrompt } = require('@handit.ai/node');

const optimizedPrompt = await fetchOptimizedPrompt({
  modelId: agentsTrackingConfig.supportAgent.initialPrompt,
});

Python

optimized_prompt = tracker.fetch_optimized_prompt(
    model_id=agents_tracking_config["support_agent"]["initial_prompt"]
)

That's it! Your AI agent is now being tracked and optimized automatically. 🎉