Overview

This guide provides a simple, working demonstration of Pay-i's integration with OpenAI, showcasing cost tracking, limits, tags, and streaming. For an even simpler introduction, see our Getting Started guide. For more advanced examples with different Providers, check out our Pay-i-Quickstarts GitHub repository.

In this quickstart, we'll walk through a basic example step-by-step, showing you how to see immediate value from Pay-i with minimal setup.

What This Quickstart Shows

This quickstart showcases:

Setting up Pay-i with OpenAI
Creating and monitoring usage limits
Adding request tags for custom analytics
Making API requests
Making streaming API requests
Tracking costs and usage in real-time

Prerequisites

Python 3.7+
OpenAI API key
Pay-i API key

Installation

Clone the Pay-i QuickStarts repository:

git clone https://github.com/Pay-i/Pay-i-Quickstarts.git

Navigate to the OpenAI quickstart directory:

cd Pay-i-Quickstarts/quickstarts/openai

Install the required packages:

pip install --upgrade payi openai

%pip install --upgrade payi openai

We'll first run the quickstart to see it in action, then break down each portion of the code to understand how it works.

Running the Quickstart

Set up your API keys using a .env file (recommended):

a. Install python-dotenv:
```
pip install python-dotenv
```
b. Create a .env file with your API keys:
```
OPENAI_API_KEY=your-openai-api-key
PAYI_API_KEY=your-payi-api-key
```
c. Add .env to your .gitignore file to prevent accidentally committing your API keys.

For non-Python environments, see Environment Variables for alternatives.
Run the quickstart:
```
python openai_quickstart.py
```

Understanding the Code

Now that you've seen the quickstart in action, let's break down how it works:

1. Setup and Imports

First, we import the necessary libraries and set up our configuration:

import os
from dotenv import load_dotenv
from datetime import datetime

# Import required libraries
from openai import OpenAI
from payi import Payi
from payi.lib.helpers import payi_openai_url, create_headers

# Load environment variables from .env file
load_dotenv()

2. Client Initialization

Next, we set up our Pay-i and OpenAI clients:

from payi.lib.instrument import payi_instrument

# Initialize Pay-i client for limit management
payi_client = Payi()  # Automatically uses PAYI_API_KEY environment variable

# Enable Pay-i instrumentation
payi_instrument()  # Automatically creates payi sync/async clients using environment variables

# Initialize OpenAI client
openai_client = OpenAI()  # Uses OPENAI_API_KEY environment variable

3. Limit Creation

Creating a limit is optional but helpful for cost control:

# Create a limit (optional)
try:
    limit_name = "QuickStart Limit"
    limit_response = payi_client.limits.create(
        limit_name=limit_name,
        max=10.00  # $10 USD limit
    )
    limit_id = limit_response.limit.limit_id  # Store limit ID to track costs against it
except Exception as e:
    limit_id = None

4. Making an API Request

Now we make a request to OpenAI through Pay-i:

# Create request tags for custom analytics and track costs against limit
tags = ["standard-request"]
headers = create_headers(request_tags=tags, limit_ids=[limit_id] if limit_id else None)

# Make an API call, just like we would with regular OpenAI
response = openai_client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Explain what Pay-i does in one sentence."}],
    max_tokens=50,
    extra_headers=headers
)


# Print the result
print("\nResponse:")
print(f"---\n{response.choices[0].message.content}\n---")

# Pay-i automatically captures tracking information like cost and request ID
cost_info = response.xproxy_result.get('cost', {})
    request_id = response.xproxy_result.get('request_id', 'N/A')
    print("\nPay-i tracking information:")
    print(f"- Request ID: {request_id}")
    print(f"- Cost: ${cost_info}")

5. Limit Monitoring

After making requests, we can check our limit usage:

if limit_id:
    status = payi_client.limits.retrieve(limit_id=limit_id)  # Retrieve current limit status
    
    # Get the total cost from the limit status
    total_cost = status.limit.totals.cost.total.base
        
    usage_percent = (total_cost / status.limit.max) * 100  # Calculate usage percentage
    
    print(f"✓ Current usage: ${total_cost:.6f} of ${status.limit.max:.2f} ({usage_percent:.2f}%)")

6. Streaming API Requests

Pay-i also works with streaming responses:

# Tags for analytics and tracking against our limit
tags = ["streaming-request"]
headers = create_headers(request_tags=tags, limit_ids=[limit_id] if limit_id else None)

# Make streaming request
stream = openai_client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Write a short poem about AI cost efficiency."}],
    max_tokens=100,
    stream=True,  # Enable streaming
    extra_headers=headers
)


# Process the streaming response
print("\nStreaming response:")
print("---")

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        content = chunk.choices[0].delta.content
        print(content, end="")

print("\n---")

# Check final limit status
if limit_id:
    status = payi_client.limits.retrieve(limit_id=limit_id)  # Retrieve current limit status
    
    # Get the total cost from the limit status
    total_cost = status.limit.totals.cost.total.base
        
    usage_percent = (total_cost / status.limit.max) * 100  # Calculate usage percentage
    
    print(f"\nChecking final limit status...")
    print(f"✓ Final usage: ${total_cost:.6f} of ${status.limit.max:.2f} ({usage_percent:.2f}%)")

print("Now you can check your Pay-i dashboard to see detailed metrics and costs.")

What to Look For

Limit creation: Notice how a limit is created and assigned a unique ID
Cost tracking: Each request reports its cost, which is then reflected in the limit status
Streaming support: Pay-i works seamlessly with both standard and streaming requests
Request metadata: Tags are applied to each request for better organization
Error handling: The code includes robust error handling for production use

Next Steps

After running this quickstart, you can:

Check your Pay-i dashboard to see detailed metrics about the requests
Explore the request tags and analytics in the Pay-i interface
Integrate similar code into your own applications
Explore more advanced features like Use Cases and Decorators

For more detailed information about configuring Pay-i with different GenAI Providers, see the Auto-Instrumentation guide.

Expected Output

The quickstart will output something similar to:

Response:
---
Pay-i is a financial technology company that provides a platform for businesses to easily manage and automate their payroll processes.
---

Pay-i tracking information:
- Request ID: 2682615
- Cost: ${'currency': 'usd', 'input': {'base': 8.5e-06}, 'output': {'base': 3.45e-05}, 'total': {'base': 4.3e-05}}
✓ Current usage: $0.000043 of $10.00 (0.00%)

Streaming response:
---
In the world of AI, efficiency is key,
Cutting costs and saving time to set us free.
Algorithms and data work hand in hand,
Bringing savings to businesses across the land.

Automation and insights streamline the process,
Making tasks easier, with no need to second guess.
AI cost efficiency is the future now,
Bringing value and savings to all, somehow.
---

Checking final limit status...
✓ Final usage: $0.000165 of $10.00 (0.00%)
Now you can check your Pay-i dashboard to see detailed metrics and costs.