Documentation

Get Started with Customer Support AI Monitor

Everything you need to integrate CSAT tracking, monitor escalations, and prove ROI from your Customer Support AI chatbot

Quick Start

Get up and running in 60 seconds

API Reference

Complete API documentation

Examples

Real-world integration examples

Installation & Quick Start

1. Install the Package

pip install agentmonitor

2. Get Your API Key

Sign up at Customer Support AI Monitor and get your API key from the dashboard.

export AGENT_MONITOR_API_KEY="your-api-key-here"

3. Add Monitoring to Your Code

Add the @monitor.track() decorator to any function:

from agentmonitor import monitor
import openai

@monitor.track()
def chat_with_ai(user_message: str):
    """AI chat function with automatic monitoring"""
    response = openai.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": user_message}
        ]
    )
    return response.choices[0].message.content

# That's it! Your function is now monitored
result = chat_with_ai("Hello, how are you?")

You're all set!

Your AI calls are now being monitored. Check your dashboard to see real-time metrics, costs, and performance data.

Configuration

Environment Variables

# Required
AGENT_MONITOR_API_KEY=your-api-key-here

# Optional
AGENT_MONITOR_ENDPOINT=https://api.agentmonitor.ai  # Custom endpoint
AGENT_MONITOR_ENVIRONMENT=production                # Environment tag
AGENT_MONITOR_LOG_LEVEL=INFO                        # Logging level

Advanced Configuration

from agentmonitor import monitor

# Configure monitoring settings
monitor.configure(
    api_key="your-api-key",
    environment="production",
    tags={"service": "chatbot", "version": "2.0"},
    sample_rate=1.0,  # Monitor 100% of calls
    timeout=5000,     # 5 second timeout
    batch_size=100,   # Batch events for efficiency
)

API Reference

monitor.track()

Decorator to automatically monitor function calls.

@monitor.track(
    name: str = None,           # Custom name for the event
    tags: dict = None,          # Additional tags
    capture_input: bool = True, # Capture function inputs
    capture_output: bool = True,# Capture function outputs
    capture_errors: bool = True # Capture exceptions
)

monitor.track_event()

Manually track custom events.

monitor.track_event(
    name="custom_event",
    properties={
        "user_id": "123",
        "action": "button_click",
        "metadata": {"page": "dashboard"}
    },
    timestamp=datetime.now()
)

Context Manager

Track code blocks with context managers.

with monitor.track_context("data_processing"):
    # Your code here
    process_data()
    transform_results()
    # All operations are tracked together

Examples

OpenAI Integration

from agentmonitor import monitor
from openai import OpenAI

client = OpenAI()

@monitor.track(name="openai_completion")
def generate_completion(prompt: str, model: str = "gpt-4"):
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        temperature=0.7,
        max_tokens=500
    )
    return response.choices[0].message.content

# Use it
result = generate_completion("Write a haiku about AI")

LangChain Integration

from agentmonitor import monitor
from langchain.chains import LLMChain
from langchain.llms import OpenAI

@monitor.track(name="langchain_agent")
def run_agent_chain(user_input: str):
    llm = OpenAI(temperature=0.9)
    chain = LLMChain(llm=llm, prompt=prompt_template)
    return chain.run(user_input)

# Automatically tracks the entire chain execution
result = run_agent_chain("Analyze this data")

Anthropic Claude Integration

from agentmonitor import monitor
import anthropic

client = anthropic.Anthropic()

@monitor.track(name="claude_completion")
def chat_with_claude(message: str):
    response = client.messages.create(
        model="claude-3-opus-20240229",
        max_tokens=1024,
        messages=[{"role": "user", "content": message}]
    )
    return response.content[0].text

result = chat_with_claude("Explain quantum computing")

Async Functions

from agentmonitor import monitor
import asyncio

@monitor.track(name="async_ai_call")
async def async_ai_function(prompt: str):
    response = await async_openai_client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

# Works seamlessly with async/await
result = await async_ai_function("Generate ideas")

Best Practices

Use Meaningful Names

Give your tracked functions descriptive names to easily identify them in the dashboard.

@monitor.track(name="customer_support_chatbot")
def handle_support_query(query: str): ...

Add Contextual Tags

Use tags to categorize and filter your AI calls in the dashboard.

@monitor.track(tags={"customer_id": "123", "tier": "premium"})
def personalized_ai_response(prompt: str): ...

Handle Sensitive Data

Control what data is captured to ensure privacy and compliance.

@monitor.track(capture_input=False, capture_output=False)
def process_sensitive_data(user_data: dict): ...

Monitor in Production

Use environment variables to control monitoring in different environments.

monitor.configure(
    environment=os.getenv("ENV", "development"),
    sample_rate=1.0 if os.getenv("ENV") == "production" else 0.1
)

Security & Privacy

Data Encryption

All data is encrypted in transit (TLS 1.3) and at rest (AES-256). We never store your API keys for third-party AI services.

Compliance

We are SOC 2 Type II certified, GDPR compliant, and HIPAA ready. Enterprise plans include BAA agreements.

Data Retention

Configure data retention policies from 7 days to unlimited. Delete data at any time through the dashboard or API.

Need Help?

Our team is here to help you get the most out of Customer Support AI Monitor.

Contact SupportAbout Us