Prompt Engineering for Automation

SYSTEM_PROMPT = """
Role: You are an invoice data extractor for an accounting system.

Input: Raw invoice text (OCR output, possibly noisy).

Output: Valid JSON with these exact fields:
- vendor_name (string)
- invoice_number (string)
- date (string, ISO 8601: YYYY-MM-DD)
- line_items (array of {description, quantity, unit_price, total})
- subtotal (number)
- tax (number)
- total (number)
- currency (string, 3-letter ISO code)

Rules:
1. If a field cannot be determined, use null — never guess.
2. Numbers must be plain floats, no currency symbols.
3. Dates must be ISO 8601 regardless of input format.
4. Reply ONLY with the JSON object. No markdown, no explanation.
"""

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": raw_invoice_text}
    ],
    temperature=0.1  # low for extraction tasks
)

messages = [
    {"role": "system", "content": "Classify customer feedback as: positive, negative, neutral, or feature_request. Reply with one word."},
    # Few-shot examples
    {"role": "user", "content": "Love the new dashboard!"},
    {"role": "assistant", "content": "positive"},
    {"role": "user", "content": "The export is broken again"},
    {"role": "assistant", "content": "negative"},
    {"role": "user", "content": "Can you add dark mode?"},
    {"role": "assistant", "content": "feature_request"},
    # Actual input
    {"role": "user", "content": actual_feedback}
]

response = client.chat.completions.create(
    model="gpt-4o-mini", messages=messages, max_tokens=5
)
label = response.choices[0].message.content.strip().lower()

SYSTEM = """You are a pricing analyst. When given a competitor analysis request:
1. First, identify the product category
2. List the key pricing factors for that category
3. Analyze the competitive position
4. Recommend a pricing strategy

Think step by step. After your analysis, end with a JSON block:
```json
{"category": "...", "recommended_price_range": "...", "strategy": "...", "confidence": 0.0-1.0}
```"""

response = client.chat.completions.create(
    model="gpt-4o",  # use stronger model for reasoning
    messages=[
        {"role": "system", "content": SYSTEM},
        {"role": "user", "content": "Analyze pricing for a new project management SaaS targeting SMBs. Competitors: Asana ($10.99/user), Monday ($9/user), ClickUp ($7/user)."}
    ],
    temperature=0.4
)

# Extract the JSON block from the response
import re, json
text = response.choices[0].message.content
json_match = re.search(r'```json\s*(\{.*?\})\s*```', text, re.DOTALL)
if json_match:
    analysis = json.loads(json_match.group(1))
    print(analysis)

from pydantic import BaseModel, validator
import json

class LeadScore(BaseModel):
    score: int
    reasoning: str
    next_action: str

    @validator('score')
    def score_range(cls, v):
        if not 1 <= v <= 100:
            raise ValueError('Score must be 1-100')
        return v

def score_lead(lead_info: str) -> LeadScore:
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "Score this lead 1-100. Reply with JSON: {score, reasoning, next_action}"},
            {"role": "user", "content": lead_info}
        ],
        response_format={"type": "json_object"},
        temperature=0.2
    )
    data = json.loads(response.choices[0].message.content)
    return LeadScore(**data)  # validates with Pydantic

result = score_lead("Fortune 500 CTO, requested a demo, $500k budget")
print(f"Score: {result.score}, Action: {result.next_action}")

import json

test_cases = [
    {"input": "Great product, very happy!", "expected": "positive"},
    {"input": "Terrible support, waited 3 days", "expected": "negative"},
    {"input": "It works fine I guess", "expected": "neutral"},
    {"input": "Would be nice to have SSO", "expected": "feature_request"},
    {"input": "Absolutely love the API docs", "expected": "positive"},
]

def evaluate_prompt(system_prompt: str, test_cases: list) -> dict:
    correct = 0
    results = []
    for tc in test_cases:
        resp = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": tc["input"]}
            ],
            max_tokens=10
        )
        predicted = resp.choices[0].message.content.strip().lower()
        match = predicted == tc["expected"]
        correct += int(match)
        results.append({"input": tc["input"], "expected": tc["expected"], "predicted": predicted, "match": match})

    return {"accuracy": correct / len(test_cases), "results": results}

report = evaluate_prompt("Classify as: positive, negative, neutral, or feature_request. One word.", test_cases)
print(f"Accuracy: {report['accuracy']:.0%}")