Using Prompts in Code

HoneyHive allows you to manage your prompts in HoneyHive instead of your codebase and deploy your saved prompts to specific env variables. This allows your domain experts to independently iterate on and deploy prompts without needing any technical skills. This guide will walk through available environments, how to deploy a prompt to a specific environment within the app, and how to export and use these prompts in your application.

Available Environments

Each environment is specific to a project and can be used to automatically fetch the latest deployed prompt version. By default, we offer the below 3 environments:

dev: For development-related tasks such as testing, debugging, etc.
staging: For staging your prompt changes
prod: For managing your production instance

Deploying Prompts

Expected Time: Less than a minute To deploy a prompt, simply navigate to Registry within Studio. Here, you can select any of your saved prompts and deploy it to a specific env.

Integrating with your application

After creating a desired prompt and deploying it, you’ll need to add it to your codebase to use in development or production. We have two primary suggested flows for being able to export and use your prompts:

SDK-based export (with caching)
YAML file export

1. SDK-based export

You can fetch your deployed prompts using our GET Configurations API. This method allows you to dynamically retrieve the latest version of your prompts directly from HoneyHive.

Basic SDK Usage

Here are examples of how to use the API in Python and TypeScript. The env and name parameters are optional below.

Fetching all prompts: If only the project is specified, all prompts in the project will be returned.
Fetching prod deployed version: By setting env to operations.env.PROD (Python) or Env.Prod (JS/TS), the prompt deployed to the prod environment will be returned.
Fetching prompts deployed to other environments: Specifying a particular environment will fetch the prompt for that specific environment.
Fetching a specific prompt: Specifying a name will fetch that exact prompt.

import honeyhive
from honeyhive.models import operations

hhai = honeyhive.HoneyHive(
    bearer_auth="HONEYHIVE_API_KEY_HERE",
    server_url="HONEYHIVE_SERVER_URL" # Optional / Required for self-hosted or dedicated deployments
)

def get_deployed_prompt(project_name, environment=operations.env.PROD, prompt_name=None):
    res = hhai.configurations.get_configurations(
        project=project_name,
        env=environment, # optional
        name=prompt_name # optional
    )

    # fetch a prompt list
    prompts = res.configurations

    # fetching a single prompt
    return res.configurations[0]

prompt = get_deployed_prompt(
    "PROJECT_NAME_HERE",
    operations.env.PROD,
    "OPTIONAL_PROMPT_NAME"
)

import { HoneyHive } from "honeyhive";
import { Env } from "honeyhive/models/operations";

const hhai = new HoneyHive({
    bearerAuth: "HONEYHIVE_API_KEY_HERE",
});

async function getDeployedPrompt(projectName, environment=Env.Prod, promptName=null) {
    const project: string = projectName;
    const env: Env = environment; 
    const name: string | null = promptName;

    const res = await hhai.configurations.getConfigurations(
        project,
        env,
        name
    );

    // full prompt list
    const prompts = res;

    const prompt = prompts[0];
    
    return prompt;
}

const prompt = await getDeployedPrompt(
    "PROJECT_NAME_HERE",
    Env.Prod,
    "OPTIONAL_PROMPT_NAME"
);

Cached SDK export

To reduce the number of API calls and improve performance, we recommend implementing a caching mechanism. Here are examples using LRU (Least Recently Used) cache in both Python and TypeScript:

For typescript, you’ll have to install the package lru-cache

from functools import lru_cache
import honeyhive
from honeyhive.models import operations

hhai = honeyhive.HoneyHive(
    bearer_auth="HONEYHIVE_API_KEY_HERE",
    server_url="HONEYHIVE_SERVER_URL" # Optional / Required for self-hosted or dedicated deployments
)

@lru_cache(maxsize=100)
def get_deployed_prompt(project_name, environment=operations.env.PROD, prompt_name=None):
    res = hhai.configurations.get_configurations(
        project=project_name,
        env=environment, # optional
        name=prompt_name # optional
    )

    # fetch a prompt list
    prompts = res.configurations

    # fetching a single prompt
    return prompts[0]

# Usage
prompt = get_deployed_prompt(
    "PROJECT_NAME_HERE",
    operations.env.PROD,
    "OPTIONAL_PROMPT_NAME"
)

import LRU from 'lru-cache';
import { HoneyHive } from "honeyhive";
import { Env, GetConfigurationsRequest } from "honeyhive/dist/models/operations";

const hhai = new HoneyHive({
    bearerAuth: "HONEYHIVE_API_KEY_HERE",
});

const cache = new LRU({ max: 100 });

async function getDeployedPrompt(projectName: string, environment: Env = Env.Prod, promptName: string | null = null) {
    const key = `${projectName}:${environment}:${promptName}`;
    if (cache.has(key)) {
        return cache.get(key);
    }

    const project: string = projectName;
    const env: Env = environment; 
    const name: string | null = promptName;

    const res = await hhai.configurations.getConfigurations(
        project,
        env,
        name
    );

    if (res.statusCode == 200) {
        const prompt = res[0];
        cache.set(key, prompt);
        return prompt;
    }
    return null;
}

// Usage
const deployedPrompt = await getDeployedPrompt('my_project', Env.Dev, 'my_prompt');

By implementing caching, you can significantly reduce the number of API calls while still ensuring that your application has access to up-to-date prompt configurations.

2. YAML file export

Another approach to exporting prompts is by saving them as YAML files and including them in your project. This method is useful when you want to version control your prompts with your codebase or when you prefer to have the prompt configurations directly in your codebase. We recommend running this export flow in your production build process.

Exporting to YAML

Here’s how you can export a prompt configuration to a YAML file using the HoneyHive SDK:

import yaml
from honeyhive import HoneyHive
from honeyhive.models import operations

# Initialize the SDK outside the function
s = HoneyHive(
    bearer_auth="<YOUR_API_KEY>",
    server_url="HONEYHIVE_SERVER_URL" # Optional / Required for self-hosted or dedicated deployments
)

def export_prompt_to_yaml(project, env, name):
    res = s.configurations.get_configurations(
        project=project,
        env=env,
        name=name
    )

    if res.configurations is not None:
        prompt = res.configurations[0]
        with open(f"{name}_config.yaml", 'w') as file:
            yaml.dump(prompt, file)
        print(f"Prompt configuration exported to {name}_config.yaml")
    else:
        print("Error: Failed to retrieve configuration")

# Usage
export_prompt_to_yaml("my_project", operations.Env.DEV, "my_prompt")

import * as fs from 'fs';
import * as yaml from 'js-yaml';
import { HoneyHive } from "honeyhive";
import { Env } from "honeyhive/dist/models/operations";

// Initialize the SDK outside the function
const hhai = new HoneyHive({
    bearerAuth: "<YOUR_API_KEY>",
});

async function exportPromptToYaml(project: string, env: Env, name: string) {
    try {
        const res = await hhai.configurations.getConfigurations(project, env, name);
        
        if (res.statusCode === 200 && res.configurations) {
            const prompt = res.configurations[0];
            const yamlStr = yaml.dump(prompt);
            fs.writeFileSync(`${name}_config.yaml`, yamlStr, 'utf8');
            console.log(`Prompt configuration exported to ${name}_config.yaml`);
        } else {
            console.error("Error: Failed to retrieve configuration");
        }
    } catch (error) {
        console.error("Error:", error);
    }
}

// Usage
exportPromptToYaml("my_project", Env.Dev, "my_prompt");

These functions will fetch the prompt configuration using the HoneyHive SDK and save it as a YAML file. You can later import it elsewhere for making calls to an LLM.

Reading YAML Configurations

Once you have exported your prompt configurations to YAML files, you can easily load them in your application. Here’s how you can read the YAML files:

import yaml

def load_prompt_config(file_path):
    with open(file_path, 'r') as file:
        return yaml.safe_load(file)

# Usage
prompt_config = load_prompt_config('my_prompt_config.yaml')
# Use prompt_config in your application

import * as fs from 'fs';
import * as yaml from 'js-yaml';

function loadPromptConfig(filePath: string) {
    const fileContents = fs.readFileSync(filePath, 'utf8');
    return yaml.load(fileContents) as any;
}

// Usage
const promptConfig = loadPromptConfig('my_prompt_config.yaml');
// Use promptConfig in your application

These functions allow you to load the YAML configuration files back into your application, making it easy to use the exported prompt configurations in your code.

Conclusion

Whether you choose the SDK-based approach for real-time updates or the YAML file method for static configurations, HoneyHive provides flexible options for integrating your prompts into your application. Choose the method that best fits your development workflow and application requirements.

Introduction

Observability

Evaluation

Workspace Management

Learn More

Available Environments

Deploying Prompts

Integrating with your application

1. SDK-based export

Basic SDK Usage

Cached SDK export

2. YAML file export

Exporting to YAML

Reading YAML Configurations

Conclusion

​Available Environments

​Deploying Prompts

​Integrating with your application

​1. SDK-based export

Basic SDK Usage

​Cached SDK export

​2. YAML file export

Exporting to YAML

​Reading YAML Configurations

​Conclusion

Available Environments

Deploying Prompts

Integrating with your application

1. SDK-based export

Cached SDK export

2. YAML file export

Reading YAML Configurations

Conclusion