Advanced Prompting Techniques

few_shot_prompt = """Classify each customer message into a category and extract the key entity.

EXAMPLE 1:
Message: "I haven't received my order #4521 that was supposed to arrive yesterday"
Category: SHIPPING
Entity: order #4521
Urgency: HIGH

EXAMPLE 2:
Message: "Can you tell me if the blue widget comes in size XL?"
Category: PRODUCT_INQUIRY
Entity: blue widget (size XL)
Urgency: LOW

EXAMPLE 3:
Message: "I was charged twice on my credit card for the same item"
Category: BILLING
Entity: duplicate charge
Urgency: HIGH

EXAMPLE 4:
Message: "Your app crashes every time I try to upload a photo on Android"
Category: TECHNICAL
Entity: photo upload (Android)
Urgency: MEDIUM

---
Now classify this message:
Message: "{customer_message}"
Category:
Entity:
Urgency:"""

def classify_message(message: str) -> dict:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": few_shot_prompt.format(customer_message=message)}],
        temperature=0.0
    )
    
    # Parse structured output
    lines = response.choices[0].message.content.strip().split('\n')
    result = {}
    for line in lines:
        if ':' in line:
            key, value = line.split(':', 1)
            result[key.strip().lower()] = value.strip()
    return result

# Zero-shot CoT — no examples needed
zero_shot_cot = """A store has 4 shelves. Each shelf holds 8 boxes. 
Each box contains 6 items. The store receives a shipment that 
doubles the items on the top 2 shelves only.
How many total items are in the store after the shipment?

Let's think step by step."""

# Model output:
# Step 1: Calculate initial items per shelf: 8 boxes × 6 items = 48 items
# Step 2: Calculate total initial items: 4 shelves × 48 = 192 items
# Step 3: Top 2 shelves doubled: 2 × 48 × 2 = 192 items on top shelves
# Step 4: Bottom 2 shelves unchanged: 2 × 48 = 96 items
# Step 5: Total = 192 + 96 = 288 items
# Answer: 288

cot_prompt = """Determine if the conclusion follows from the premises.
Show your reasoning step by step, then give VALID or INVALID.

EXAMPLE:
Premises: 
- All engineers can code
- Sarah is an engineer
Conclusion: Sarah can code

Reasoning:
1. We know all engineers can code (universal statement)
2. Sarah is an engineer (specific instance)
3. Therefore, Sarah falls under "all engineers"
4. So Sarah can code (valid application of universal to specific)
Answer: VALID

EXAMPLE:
Premises:
- Some dogs are friendly
- Rex is a dog
Conclusion: Rex is friendly

Reasoning:
1. We know SOME dogs are friendly (not all)
2. Rex is a dog
3. But we don't know if Rex is in the "friendly" subset
4. The conclusion assumes all dogs are friendly, which isn't stated
Answer: INVALID

---
Premises:
{premises}
Conclusion: {conclusion}

Reasoning:"""

from collections import Counter

def self_consistent_answer(prompt: str, n_samples: int = 5, temperature: float = 0.7) -> dict:
    """Generate multiple CoT responses and return majority answer."""
    
    # Add CoT trigger
    cot_prompt = prompt + "\n\nLet's think step by step. After reasoning, put your final answer on a new line starting with 'ANSWER:'"
    
    responses = []
    for _ in range(n_samples):
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": cot_prompt}],
            temperature=temperature,  # Higher temp for diverse reasoning paths
            max_tokens=1000
        )
        responses.append(response.choices[0].message.content)
    
    # Extract final answers
    answers = []
    for resp in responses:
        lines = resp.strip().split('\n')
        for line in reversed(lines):
            if line.strip().startswith('ANSWER:'):
                answers.append(line.split('ANSWER:')[1].strip())
                break
    
    # Majority vote
    vote_counts = Counter(answers)
    winner, count = vote_counts.most_common(1)[0]
    
    return {
        "answer": winner,
        "confidence": count / len(answers),
        "vote_distribution": dict(vote_counts),
        "n_samples": n_samples,
        "all_reasoning": responses  # Keep for debugging
    }

# Usage
result = self_consistent_answer(
    "If a train travels 120km in 1.5 hours, then stops for 30 minutes, "
    "then travels 80km in 1 hour, what is its average speed for the entire journey?"
)
print(f"Answer: {result['answer']} (confidence: {result['confidence']:.0%})")

# OpenAI JSON mode
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "system",
            "content": "You extract structured data from text. Always respond in JSON."
        },
        {
            "role": "user", 
            "content": f"Extract all people, their roles, and companies from this text:\n\n{text}"
        }
    ],
    response_format={"type": "json_object"}  # Guarantees valid JSON
)

data = json.loads(response.choices[0].message.content)

# Structured Outputs with schema (even stricter)
from pydantic import BaseModel

class Person(BaseModel):
    name: str
    role: str
    company: str
    confidence: float

class ExtractionResult(BaseModel):
    people: list[Person]
    raw_text_length: int

response = client.beta.chat.completions.parse(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Extract people from the text."},
        {"role": "user", "content": text}
    ],
    response_format=ExtractionResult  # Pydantic model as schema!
)

result = response.choices[0].message.parsed  # Already a Pydantic object
for person in result.people:
    print(f"{person.name} — {person.role} at {person.company}")

import json
import re
from typing import Optional

def extract_json_from_response(text: str) -> Optional[dict]:
    """Extract JSON from LLM response, handling common issues."""
    
    # Strategy 1: Try direct parse
    try:
        return json.loads(text)
    except json.JSONDecodeError:
        pass
    
    # Strategy 2: Extract from markdown code block
    json_match = re.search(r'```(?:json)?\s*([\s\S]*?)```', text)
    if json_match:
        try:
            return json.loads(json_match.group(1))
        except json.JSONDecodeError:
            pass
    
    # Strategy 3: Find JSON object/array boundaries
    for start_char, end_char in [('{', '}'), ('[', ']')]:
        start = text.find(start_char)
        if start == -1:
            continue
        
        # Find matching closing bracket
        depth = 0
        for i in range(start, len(text)):
            if text[i] == start_char:
                depth += 1
            elif text[i] == end_char:
                depth -= 1
                if depth == 0:
                    try:
                        return json.loads(text[start:i+1])
                    except json.JSONDecodeError:
                        break
    
    # Strategy 4: Fix common issues and retry
    cleaned = text.strip()
    cleaned = re.sub(r',\s*}', '}', cleaned)  # trailing commas
    cleaned = re.sub(r',\s*]', ']', cleaned)
    cleaned = cleaned.replace("'", '"')  # single quotes
    try:
        return json.loads(cleaned)
    except json.JSONDecodeError:
        return None

def parse_with_retry(prompt: str, max_retries: int = 2) -> dict:
    """Try to get valid JSON, retry with feedback if parsing fails."""
    
    for attempt in range(max_retries + 1):
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.0
        )
        
        text = response.choices[0].message.content
        result = extract_json_from_response(text)
        
        if result is not None:
            return result
        
        # Add correction prompt for retry
        prompt = f"""Your previous response was not valid JSON. 
Please try again. Respond with ONLY a JSON object, no other text.

Original request: {prompt}"""
    
    raise ValueError(f"Failed to get valid JSON after {max_retries + 1} attempts")

receipt_extraction_prompt = """You are an expert at extracting structured data from receipt text.

INSTRUCTIONS:
1. First, reason through the receipt text to identify all items, quantities, and prices
2. Handle edge cases: discounts, tax, tips, multiple quantities
3. Then output the structured data

RECEIPT TEXT:
---
{receipt_text}
---

Think through this step by step:
1. Identify the store/restaurant name
2. List each line item with quantity and unit price  
3. Identify any discounts or promotions applied
4. Find subtotal, tax, and total
5. Note the payment method if visible

After your reasoning, output ONLY this JSON (no markdown):
{{
    "store_name": "string",
    "date": "YYYY-MM-DD or null",
    "items": [
        {{"name": "string", "quantity": int, "unit_price": float, "total_price": float}}
    ],
    "subtotal": float,
    "discount": float or null,
    "tax": float,
    "tip": float or null,
    "total": float,
    "payment_method": "string or null",
    "confidence": float
}}"""

def extract_receipt(receipt_text: str) -> dict:
    """Extract structured data from receipt text using CoT + JSON."""
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": "You are a precise data extraction system. Always complete your JSON output."
            },
            {
                "role": "user",
                "content": receipt_extraction_prompt.format(receipt_text=receipt_text)
            }
        ],
        temperature=0.0,
        max_tokens=2000
    )
    
    text = response.choices[0].message.content
    
    # The reasoning comes first, JSON at the end
    result = extract_json_from_response(text)
    
    if result is None:
        raise ValueError("Failed to extract JSON from response")
    
    # Validate: total should roughly equal sum of items + tax - discount
    items_sum = sum(item["total_price"] for item in result["items"])
    expected_total = items_sum + result["tax"] - (result.get("discount") or 0) + (result.get("tip") or 0)
    
    if abs(expected_total - result["total"]) > 0.02:
        result["_validation_warning"] = f"Math check: items sum to {expected_total:.2f}, stated total is {result['total']:.2f}"
    
    return result

# Test with messy receipt text
sample_receipt = """
TACO PALACE
123 Main St, Austin TX
03/15/2024 7:42 PM

2x Chicken Burrito    $11.99 ea    $23.98
1x Queso Grande                     $6.49
3x Street Tacos       $3.50 ea    $10.50
1x Horchata                         $3.99

    SUBTOTAL                       $44.96
    Loyalty Discount (10%)         -$4.50
    Tax (8.25%)                     $3.34
    
    TOTAL                          $43.80
    
Paid: Visa ***4521
Thank you! See you next time!
"""

result = extract_receipt(sample_receipt)
print(json.dumps(result, indent=2))