Prompt management

1
import opik
2
3
# Prompt text stored in a variable
4
PROMPT_TEXT = "Write a summary of the following text: {{text}}"
5
6
# Create a prompt
7
prompt = opik.Prompt(
8
    name="prompt-summary",
9
    prompt=PROMPT_TEXT,
10
    metadata={"environment": "production"}
11
)
12
13
# Print the prompt text
14
print(prompt.prompt)
15
16
# Build the prompt
17
print(prompt.format(text="Hello, world!"))

1
import opik
2
3
# Read the prompt from a file
4
with open("prompt.txt", "r") as f:
5
    prompt_text = f.read()
6
7
prompt = opik.Prompt(name="prompt-summary", prompt=prompt_text)
8
9
# Print the prompt text
10
print(prompt.prompt)
11
12
# Build the prompt
13
print(prompt.format(text="Hello, world!"))

1
import opik
2
3
opik.configure()
4
client = opik.Opik()
5
6
# Create a new prompt
7
prompt = client.create_prompt(name="prompt-summary", prompt="Write a summary of the following text: {{text}}", metadata={"environment": "development"})

1
import opik
2
from opik.opik_context import update_current_trace
3
4
# Create prompts
5
system_prompt = opik.Prompt(
6
    name="system-prompt",
7
    prompt="You are a helpful assistant that provides accurate and concise answers."
8
)
9
10
# Get prompt from the Prompt library
11
client = opik.Opik()
12
user_prompt = client.get_prompt(name="user-prompt")
13
14
@opik.track
15
def process_user_query(question: str) -> str:
16
    # Add prompts to the current trace
17
    update_current_trace(
18
        name="user-query-processing",
19
        prompts=[system_prompt, user_prompt],
20
        metadata={"query_type": "general"}
21
    )
22
    
23
    # Your processing logic here
24
    formatted_prompt = user_prompt.format(question=question)
25
    # ... rest of your function
26
    return "Response to: " + question

1
import opik
2
3
opik.configure()
4
client = opik.Opik()
5
6
# Get a dataset
7
dataset = client.get_or_create_dataset("test_dataset")
8
9
# Get the prompt
10
prompt = client.get_prompt(name="prompt-summary")
11
12
# Create the prompt message
13
prompt.format(text="Hello, world!")

1
import opik
2
3
client = opik.Opik()
4
5
# Search by name substring only
6
latest_versions = client.search_prompts(
7
    filter_string='name contains "summary"'
8
)
9
10
# Search by name substring and tags filter
11
filtered = client.search_prompts(
12
    filter_string='name contains "summary" AND tags contains "alpha" AND tags contains "beta"',
13
)
14
15
# Search for only text prompts
16
text_prompts = client.search_prompts(
17
    filter_string='template_structure = "text"'
18
)
19
20
for prompt in filtered:
21
    print(prompt.name, prompt.commit, prompt.prompt)

1
import opik
2
3
# Define chat messages with variables
4
messages = [
5
    {"role": "system", "content": "You are a helpful assistant specializing in {{domain}}."},
6
    {"role": "user", "content": "Explain {{topic}} in simple terms."}
7
]
8
9
# Create a chat prompt
10
chat_prompt = opik.ChatPrompt(
11
    name="educational-assistant",
12
    messages=messages,
13
    metadata={"category": "education"}
14
)
15
16
# Format the prompt with variables
17
formatted_messages = chat_prompt.format(
18
    variables={
19
        "domain": "physics",
20
        "topic": "quantum entanglement"
21
    }
22
)
23
24
# Use formatted messages with your LLM
25
print(formatted_messages)
26
# Output:
27
# [
28
#     {"role": "system", "content": "You are a helpful assistant specializing in physics."},
29
#     {"role": "user", "content": "Explain quantum entanglement in simple terms."}
30
# ]

1
import opik
2
from openai import OpenAI
3
4
# Define chat messages with variables
5
messages = [
6
    {"role": "system", "content": "You are a helpful assistant specializing in {{domain}}."},
7
    {"role": "user", "content": "Explain {{topic}} in simple terms."}
8
]
9
10
# Create a chat prompt
11
chat_prompt = opik.ChatPrompt(
12
    name="educational-assistant",
13
    messages=messages,
14
    metadata={"category": "education"}
15
)
16
17
# Format the prompt with variables
18
formatted_messages = chat_prompt.format(
19
    variables={
20
        "domain": "physics",
21
        "topic": "quantum entanglement"
22
    }
23
)
24
25
# Use with OpenAI API
26
client = OpenAI()
27
response = client.chat.completions.create(
28
    model="gpt-4",
29
    messages=formatted_messages
30
)
31
32
print(response.choices[0].message.content)

1
import opik
2
3
# Define a multi-turn conversation template
4
messages = [
5
    {"role": "system", "content": "You are a customer support agent for {{company}}."},
6
    {"role": "user", "content": "I have an issue with {{product}}."},
7
    {"role": "assistant", "content": "I'd be happy to help with your {{product}}. Can you describe the issue?"},
8
    {"role": "user", "content": "{{issue_description}}"}
9
]
10
11
chat_prompt = opik.ChatPrompt(
12
    name="customer-support-flow",
13
    messages=messages
14
)
15
16
# Format with specific values
17
formatted = chat_prompt.format(
18
    variables={
19
        "company": "Acme Corp",
20
        "product": "Widget Pro",
21
        "issue_description": "It won't turn on"
22
    }
23
)

1
import opik
2
3
# Chat prompt with image content
4
messages = [
5
    {"role": "system", "content": "You analyze images and provide detailed descriptions."},
6
    {
7
        "role": "user",
8
        "content": [
9
            {"type": "text", "text": "What's in this image of {{subject}}?"},
10
            {
11
                "type": "image_url",
12
                "image_url": {
13
                    "url": "{{image_url}}",
14
                    "detail": "high"
15
                }
16
            }
17
        ]
18
    }
19
]
20
21
chat_prompt = opik.ChatPrompt(
22
    name="image-analyzer",
23
    messages=messages
24
)
25
26
# Format with variables
27
formatted = chat_prompt.format(
28
    variables={
29
        "subject": "a sunset",
30
        "image_url": "https://example.com/sunset.jpg"
31
    },
32
    supported_modalities={"vision": True}
33
)

1
import opik
2
3
# Chat prompt with video content
4
messages = [
5
    {"role": "system", "content": "You analyze videos and provide insights."},
6
    {
7
        "role": "user",
8
        "content": [
9
            {"type": "text", "text": "Analyze this video: {{description}}"},
10
            {
11
                "type": "video_url",
12
                "video_url": {
13
                    "url": "{{video_url}}",
14
                    "mime_type": "video/mp4"
15
                }
16
            }
17
        ]
18
    }
19
]
20
21
chat_prompt = opik.ChatPrompt(
22
    name="video-analyzer",
23
    messages=messages
24
)
25
26
# Format with variables
27
formatted = chat_prompt.format(
28
    variables={
29
        "description": "traffic analysis",
30
        "video_url": "https://example.com/traffic.mp4"
31
    },
32
    supported_modalities={"vision": True}
33
)

1
import opik
2
3
# Chat prompt with multiple images and text
4
messages = [
5
    {
6
        "role": "user",
7
        "content": [
8
            {"type": "text", "text": "Compare these two images:"},
9
            {
10
                "type": "image_url",
11
                "image_url": {"url": "{{image1_url}}"}
12
            },
13
            {"type": "text", "text": "and"},
14
            {
15
                "type": "image_url",
16
                "image_url": {"url": "{{image2_url}}"}
17
            },
18
            {"type": "text", "text": "What are the main differences?"}
19
        ]
20
    }
21
]
22
23
chat_prompt = opik.ChatPrompt(
24
    name="image-comparison",
25
    messages=messages
26
)
27
28
formatted = chat_prompt.format(
29
    variables={
30
        "image1_url": "https://example.com/before.jpg",
31
        "image2_url": "https://example.com/after.jpg"
32
    },
33
    supported_modalities={"vision": True}
34
)

1
import opik
2
3
opik.configure()
4
client = opik.Opik()
5
6
# Create a new chat prompt
7
messages = [
8
    {"role": "system", "content": "You are a helpful assistant."},
9
    {"role": "user", "content": "Hello, {{name}}!"}
10
]
11
12
chat_prompt = client.create_chat_prompt(
13
    name="greeting-prompt",
14
    messages=messages,
15
    metadata={"environment": "development"}
16
)
17
18
# Format and use the prompt
19
formatted = chat_prompt.format(variables={"name": "Alice"})
20
print(formatted)

1
import opik
2
3
opik.configure()
4
client = opik.Opik()
5
6
# Get a chat prompt
7
chat_prompt = client.get_chat_prompt(name="greeting-prompt")
8
9
# Format the messages
10
formatted_messages = chat_prompt.format(variables={"name": "Bob"})
11
12
# Use with your LLM
13
# response = llm.chat(messages=formatted_messages)

1
import opik
2
3
client = opik.Opik()
4
5
# Search for only chat prompts
6
chat_prompts = client.search_prompts(
7
    filter_string='template_structure = "chat" AND name contains "assistant"'
8
)
9
10
for prompt in chat_prompts:
11
    print(f"Chat prompt: {prompt.name}")
12
    print(f"Messages: {prompt.template}")

1
import opik
2
from opik.api_objects.prompt import PromptType
3
4
messages = [
5
    {"role": "user", "content": "Hello {{name}}, you live in {{city}}."}
6
]
7
8
chat_prompt = opik.ChatPrompt(
9
    name="mustache-example",
10
    messages=messages,
11
    type=PromptType.MUSTACHE  # Default
12
)
13
14
formatted = chat_prompt.format(variables={"name": "Alice", "city": "Paris"})
15
# Result: [{"role": "user", "content": "Hello Alice, you live in Paris."}]

1
import opik
2
from opik.api_objects.prompt import PromptType
3
4
messages = [
5
    {
6
        "role": "user",
7
        "content": """
8
        {% if is_premium %}
9
        Hello {{ name }}, welcome to our premium service!
10
        {% else %}
11
        Hello {{ name }}, welcome!
12
        {% endif %}
13
        """
14
    }
15
]
16
17
chat_prompt = opik.ChatPrompt(
18
    name="jinja-example",
19
    messages=messages,
20
    type=PromptType.JINJA2
21
)
22
23
# With premium user
24
formatted = chat_prompt.format(
25
    variables={"name": "Alice", "is_premium": True}
26
)
27
# Result includes: "Hello Alice, welcome to our premium service!"
28
29
# With regular user
30
formatted = chat_prompt.format(
31
    variables={"name": "Bob", "is_premium": False}
32
)
33
# Result includes: "Hello Bob, welcome!"

1
import opik
2
3
# Create initial version
4
messages_v1 = [
5
    {"role": "system", "content": "You are helpful."},
6
    {"role": "user", "content": "Hi!"}
7
]
8
9
chat_prompt_v1 = opik.ChatPrompt(
10
    name="assistant-prompt",
11
    messages=messages_v1
12
)
13
14
print(f"Version 1 commit: {chat_prompt_v1.commit}")
15
16
# Create new version with different messages
17
messages_v2 = [
18
    {"role": "system", "content": "You are very helpful."},
19
    {"role": "user", "content": "Hello there!"},
20
    {"role": "assistant", "content": "How can I assist you?"}
21
]
22
23
chat_prompt_v2 = opik.ChatPrompt(
24
    name="assistant-prompt",
25
    messages=messages_v2
26
)
27
28
print(f"Version 2 commit: {chat_prompt_v2.commit}")
29
30
# Get specific version by commit
31
client = opik.Opik()
32
specific_version = client.get_chat_prompt(
33
    name="assistant-prompt",
34
    commit=chat_prompt_v1.commit
35
)
36
37
# Get version history
38
history = client.get_chat_prompt_history(name="assistant-prompt")
39
print(f"Total versions: {len(history)}")

1
import opik
2
3
opik.configure()
4
client = opik.Opik()
5
6
# Get the complete version history for a text prompt
7
prompt_history = client.get_prompt_history(name="prompt-summary")
8
9
# Iterate through all versions
10
for version in prompt_history:
11
    print(f"Name: {version.name}")
12
    print(f"Commit: {version.commit}")
13
    print(f"Prompt text: {version.prompt}")
14
    print(f"Metadata: {version.metadata}")
15
    print(f"Type: {version.type}")
16
    print("-" * 50)

1
import opik
2
3
opik.configure()
4
client = opik.Opik()
5
6
# Get a specific version of a text prompt by commit ID
7
prompt = client.get_prompt(name="prompt-summary", commit="abc123def456")
8
9
# Use the prompt in your application
10
formatted_prompt = prompt.format(text="Hello, world!")
11
print(formatted_prompt)

1
import opik
2
3
client = opik.Opik()
4
5
# Get version IDs from the prompt history
6
history = client.get_prompt_history(name="summarizer")
7
version_id = history[0].version_id  # latest version
8
9
prompts_client = client.get_prompts_client()
10
11
# Replace all tags (default behavior)
12
prompts_client.batch_update_prompt_version_tags(
13
    version_ids=[version_id],
14
    tags=["production", "v2"]
15
)
16
17
# Merge new tags with existing tags
18
prompts_client.batch_update_prompt_version_tags(
19
    version_ids=[version_id],
20
    tags=["hotfix"],
21
    merge=True
22
)
23
24
# Clear all tags by passing an empty list
25
prompts_client.batch_update_prompt_version_tags(
26
    version_ids=[version_id],
27
    tags=[]
28
)
29
30
# Update multiple versions at once
31
version_ids = [v.version_id for v in history[:3]]
32
prompts_client.batch_update_prompt_version_tags(
33
    version_ids=version_ids,
34
    tags=["archived"]
35
)

1
import opik
2
3
client = opik.Opik()
4
5
# Find versions whose template or change description contains "customer"
6
results = client.get_prompt_history(name="summarizer", search="customer")
7
8
# Works the same for chat prompts
9
chat_results = client.get_chat_prompt_history(name="assistant", search="helpful")

1
import opik
2
3
client = opik.Opik()
4
5
# Filter by tag
6
production_versions = client.get_prompt_history(
7
    name="summarizer",
8
    filter_string='tags contains "production"'
9
)
10
11
# Filter by multiple tags (AND logic)
12
stable_production = client.get_prompt_history(
13
    name="summarizer",
14
    filter_string='tags contains "production" AND tags contains "stable"'
15
)
16
17
# Filter by template content
18
customer_versions = client.get_prompt_history(
19
    name="summarizer",
20
    filter_string='template contains "customer"'
21
)
22
23
# Filter by creator
24
my_versions = client.get_prompt_history(
25
    name="summarizer",
26
    filter_string='created_by = "alice@example.com"'
27
)
28
29
# Filter by date
30
recent_versions = client.get_prompt_history(
31
    name="summarizer",
32
    filter_string='created_at >= "2024-01-01T00:00:00Z"'
33
)
34
35
# Filter by metadata field (dot notation)
36
prod_env = client.get_prompt_history(
37
    name="summarizer",
38
    filter_string='metadata.environment = "prod"'
39
)
40
41
# Combine search and filter
42
results = client.get_prompt_history(
43
    name="summarizer",
44
    search="customer",
45
    filter_string='tags contains "production"'
46
)
47
48
# Same API for chat prompts
49
chat_production = client.get_chat_prompt_history(
50
    name="assistant",
51
    filter_string='tags contains "production"'
52
)
53
54
for version in production_versions:
55
    print(f"Commit: {version.commit}, Tags: {version.tags}")

1
import opik
2
3
client = opik.Opik()
4
prompts_client = client.get_prompts_client()
5
6
# Create a new version
7
candidate = opik.Prompt(
8
    name="summarizer",
9
    prompt="Provide a concise summary of: {{text}}"
10
)
11
12
# ... run your evaluation logic here ...
13
# Assume the evaluation passed and we want to promote this version
14
15
# Promote to production (use version_id to target the specific version)
16
prompts_client.batch_update_prompt_version_tags(
17
    version_ids=[candidate.version_id],
18
    tags=["production", "v3"]
19
)
20
21
# Archive previous production versions
22
old_production = client.get_prompt_history(
23
    name="summarizer",
24
    filter_string='tags contains "production"'
25
)
26
older_version_ids = [
27
    v.version_id for v in old_production
28
    if v.version_id != candidate.version_id
29
]
30
if older_version_ids:
31
    prompts_client.batch_update_prompt_version_tags(
32
        version_ids=older_version_ids,
33
        tags=["archived"]
34
    )

1
import opik
2
from opik.evaluation import evaluate
3
from opik.evaluation.metrics import Hallucination
4
from openai import OpenAI
5
6
opik.configure()
7
opik_client = opik.Opik()
8
openai_client = OpenAI()
9
10
# Get a dataset
11
dataset = opik_client.get_or_create_dataset("test_dataset")
12
13
# Create a text prompt
14
prompt = opik.Prompt(name="My prompt", prompt="Summarize: {{text}}")
15
16
# Create an evaluation task
17
def evaluation_task(dataset_item):
18
    # Use the prompt in your task
19
    formatted_prompt = prompt.format(text=dataset_item["input"])
20
    
21
    # Call OpenAI API with formatted prompt
22
    response = openai_client.chat.completions.create(
23
        model="gpt-4",
24
        messages=[{"role": "user", "content": formatted_prompt}]
25
    )
26
    
27
    return {"output": response.choices[0].message.content}
28
29
# Run the evaluation
30
evaluation = evaluate(
31
    experiment_name="My experiment",
32
    dataset=dataset,
33
    task=evaluation_task,
34
    prompts=[prompt],
35
)

1
import opik
2
from opik.evaluation import evaluate
3
4
opik.configure()
5
client = opik.Opik()
6
7
# Get the dataset
8
dataset = client.get_or_create_dataset("test_dataset")
9
10
# Get different versions of the same text prompt
11
prompt_v1 = client.get_prompt(name="prompt-summary", commit="abc123")
12
prompt_v2 = client.get_prompt(name="prompt-summary", commit="def456")
13
14
# Define evaluation task that uses the prompt
15
def evaluation_task_v1(dataset_item):
16
    formatted_prompt = prompt_v1.format(text=dataset_item["input"])
17
    # Call your LLM with the formatted prompt
18
    return {"output": "llm_response"}
19
20
def evaluation_task_v2(dataset_item):
21
    formatted_prompt = prompt_v2.format(text=dataset_item["input"])
22
    # Call your LLM with the formatted prompt
23
    return {"output": "llm_response"}
24
25
# Run experiments with different prompt versions
26
experiment_v1 = evaluate(
27
    experiment_name="My experiment - v1",
28
    dataset=dataset,
29
    task=evaluation_task_v1,
30
    prompts=[prompt_v1],
31
)
32
33
experiment_v2 = evaluate(
34
    experiment_name="My experiment - v2",
35
    dataset=dataset,
36
    task=evaluation_task_v2,
37
    prompts=[prompt_v2],
38
)
39
40
# Compare results in the Opik UI