LLMs & Prompt Engineering

# Example tokenization (simplified)
text = "Hello, how are you doing today?"

# Might be tokenized as:
tokens = ["Hello", ",", " how", " are", " you", " doing", " today", "?"]
# 8 tokens for 7 words

# Code often uses more tokens:
code = "def calculate_sum(a, b):"
tokens = ["def", " calculate", "_sum", "(", "a", ",", " b", "):", ]
# 8 tokens

# Common word = 1 token, rare/complex words = multiple tokens
"Python"        # 1 token
"tokenization"  # 3 tokens: "token", "ization" (or similar split)

# Rule of thumb:
# ~750 words ≈ 1,000 tokens
# 1 page of text ≈ 500-800 tokens

# Context window sizes (as of 2025)
models = {
    "GPT-4o": "128,000 tokens",                     # ~96,000 words
    "Claude Sonnet 4.5": "200,000 tokens",          # ~150,000 words
    "Claude Opus 4": "200,000 tokens",
    "Gemini 2.0 Pro": "2,000,000 tokens",           # Experimental
}

# Example context usage:
system_prompt = "You are a helpful assistant..."    # ~20 tokens
user_message = "Explain Python decorators..."       # ~50 tokens
conversation_history = [...]                        # ~2,000 tokens
# Total context used: ~2,070 tokens

# Remaining for response: 128,000 - 2,070 = 125,930 tokens

# Temperature settings and their effects

temperature = 0.0  # Deterministic
# Always picks the highest probability token
# Same input = same output every time
# Best for: Code generation, factual Q&A, structured outputs

temperature = 0.3  # Low creativity
# Mostly picks high probability, slight variation
# Best for: Technical writing, summaries, analysis

temperature = 0.7  # Balanced (common default)
# Good mix of coherence and variety
# Best for: General conversation, explanations

temperature = 1.0  # High creativity
# More willing to pick lower probability tokens
# Best for: Creative writing, brainstorming, poetry

temperature = 1.5+  # Very high (often incoherent)
# Picks from wide distribution, can be random
# Usually not recommended

# Typical message structure for LLM APIs
messages = [
    {
        "role": "system",
        "content": """You are an expert Python developer.
        Always write clean, well-documented code.
        Include error handling in all examples."""
    },
    {
        "role": "user",
        "content": "Write a function to read a JSON file."
    },
    {
        "role": "assistant",
        "content": "Here's a function to read JSON files safely..."
    },
    {
        "role": "user",
        "content": "Add support for YAML files too."
    }
]

# Roles:
# - system: Sets behavior, personality, constraints (high influence)
# - user: Your inputs and questions
# - assistant: Model's previous responses (for context)

# Vague prompt
"Write a sorting function"

# Specific prompt
"""Write a Python function that:
- Sorts a list of dictionaries by a specified key
- Handles missing keys gracefully (puts them at the end)
- Supports both ascending and descending order
- Returns a new list (doesn't modify the original)
- Includes type hints and a docstring

Example usage:
data = [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]
result = sort_by_key(data, "age", descending=True)
"""

# Result: Much more useful, targeted response

# No context
"How do I fix this error: Connection refused"

# With context
"""I'm building a Flask API that connects to PostgreSQL using psycopg2.
When I start the server, I get this error:

psycopg2.OperationalError: connection refused
    Is the server running on host "localhost" and accepting
    TCP/IP connections on port 5432?

My connection code:
conn = psycopg2.connect(
    host="localhost",
    port=5432,
    database="myapp",
    user="admin"
)

I'm running this in a Docker container.
PostgreSQL is running in a separate container.

What's causing this and how do I fix it?
"""

# Result: Can now give specific, actionable advice about Docker networking

# Few-shot prompting for consistent formatting
"""Convert these natural language descriptions to SQL queries.

Example 1:
Input: "Get all users who signed up in 2024"
Output: SELECT * FROM users WHERE YEAR(created_at) = 2024;

Example 2:
Input: "Count orders by status"
Output: SELECT status, COUNT(*) as count FROM orders GROUP BY status;

Example 3:
Input: "Find products cheaper than $50 sorted by price"
Output: SELECT * FROM products WHERE price < 50 ORDER BY price ASC;

Now convert this:
Input: "Get the top 5 customers by total order amount"
"""

# Result: Model follows the pattern exactly
# Output: SELECT customer_id, SUM(amount) as total
#         FROM orders
#         GROUP BY customer_id
#         ORDER BY total DESC
#         LIMIT 5;

# Direct question (often wrong on complex problems)
"What's the time complexity of this function?"

# Chain of thought prompting
"""Analyze the time complexity of this function step by step:

def find_duplicates(arr):
    seen = set()
    duplicates = []
    for item in arr:
        if item in seen:
            duplicates.append(item)
        seen.add(item)
    return duplicates

Please:
1. Identify all operations in the function
2. Determine the complexity of each operation
3. Consider how they combine
4. State the final time and space complexity with explanation
"""

# Result: Model walks through analysis systematically
# 1. for loop: iterates n times
# 2. "item in seen": O(1) average for set lookup
# 3. seen.add(item): O(1) average for set insertion
# 4. duplicates.append(item): O(1) amortized
# Final: O(n) time, O(n) space

# Role-based prompting examples

# Security reviewer
"""You are a senior security engineer reviewing code for vulnerabilities.
Analyze this authentication function and identify:
- Security vulnerabilities (OWASP Top 10)
- Potential attack vectors
- Specific recommendations to fix each issue

Code to review:
[paste code here]
"""

# Code reviewer
"""You are a strict code reviewer at a top tech company.
Review this pull request with focus on:
- Code quality and readability
- Potential bugs or edge cases
- Performance implications
- Suggestions for improvement

Be specific and cite line numbers.
"""

# Teacher/Explainer
"""You are an experienced Python instructor teaching beginners.
Explain decorators using:
- Simple, everyday analogies
- A progression from basic to more complex
- Runnable code examples after each concept
- Common mistakes beginners make
"""

# Specifying JSON output
"""Analyze this customer review and extract information.

Review: "Great product but shipping took forever. The quality is amazing
though, totally worth the wait. Would buy again!"

Return a JSON object with this exact structure:
{
    "sentiment": "positive" | "negative" | "mixed",
    "score": <float 0-1>,
    "aspects": {
        "product_quality": "positive" | "negative" | "neutral" | "not_mentioned",
        "shipping": "positive" | "negative" | "neutral" | "not_mentioned",
        "value": "positive" | "negative" | "neutral" | "not_mentioned"
    },
    "would_recommend": true | false,
    "key_phrases": [<list of important phrases>]
}

Return only valid JSON, no additional text.
"""

# Result:
{
    "sentiment": "mixed",
    "score": 0.75,
    "aspects": {
        "product_quality": "positive",
        "shipping": "negative",
        "value": "positive"
    },
    "would_recommend": true,
    "key_phrases": ["great product", "shipping took forever", "quality is amazing", "worth the wait"]
}

import anthropic

def get_consensus_answer(client, prompt, num_attempts=5):
    """Get multiple responses and find the most common answer."""
    answers = []

    for _ in range(num_attempts):
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=100,
            temperature=0.7,  # Some variation
            messages=[{"role": "user", "content": prompt}]
        )
        answers.append(response.content[0].text.strip())

    # Find most common answer
    from collections import Counter
    answer_counts = Counter(answers)
    most_common = answer_counts.most_common(1)[0]

    return {
        "answer": most_common[0],
        "confidence": most_common[1] / num_attempts,
        "all_answers": answers
    }

# Usage
result = get_consensus_answer(
    client,
    "Is this SQL vulnerable to injection? SELECT * FROM users WHERE id = " + user_id,
    num_attempts=5
)
print(f"Answer: {result['answer']}")
print(f"Confidence: {result['confidence']:.0%}")
# Answer: Yes, this is vulnerable to SQL injection
# Confidence: 100%

# Step 1: Generate initial draft
prompt_1 = """Write a Python function to parse log files.
Requirements: Extract timestamp, level, and message from each line.
Log format: [2024-01-15 10:30:45] ERROR: Database connection failed
"""

# Step 2: Review and improve
prompt_2 = """Review this code and add:
1. Error handling for malformed lines
2. Support for multiline log entries
3. Performance optimization for large files
4. Type hints

[paste code from step 1]
"""

# Step 3: Add tests
prompt_3 = """Write comprehensive unit tests for this function:
- Test normal cases
- Test edge cases (empty file, malformed lines, unicode)
- Test performance with large inputs

[paste code from step 2]
"""

# Step 4: Final review
prompt_4 = """Do a final review of this code and tests.
Check for:
- Security issues
- Potential bugs
- Code style (PEP 8)
- Documentation completeness

Provide the final, production-ready version.
"""

# Complex task: Build a REST API endpoint

# Instead of: "Build an API endpoint for user registration"

# Break it down:
tasks = [
    "1. Define the request schema (what data does registration need?)",
    "2. Define the response schema (what should be returned?)",
    "3. List all validation rules for each field",
    "4. Write the database model for users",
    "5. Write the endpoint handler with validation",
    "6. Add error handling for each failure case",
    "7. Write tests for success and failure cases",
]

# Execute each task sequentially, using outputs as inputs
for i, task in enumerate(tasks):
    prompt = f"""
    Context: Building a user registration API endpoint.
    Previous work: {previous_outputs if i > 0 else "Starting fresh"}

    Current task: {task}

    Please complete this task, maintaining consistency with previous work.
    """
    # Execute and store result

"""Review this {language} code for a {context/project type}.

Focus areas:
1. Bugs and potential errors
2. Security vulnerabilities
3. Performance issues
4. Code style and readability
5. Missing error handling

For each issue found:
- State the severity (critical/major/minor)
- Quote the problematic code
- Explain why it's an issue
- Provide a corrected version

Code:
```{language}
{code}
```
"""

"""I have a bug in my {language} code.

**Expected behavior:** {what should happen}
**Actual behavior:** {what actually happens}
**Error message (if any):** {error}

**Relevant code:**
```{language}
{code}
```

**What I've tried:**
- {attempt 1}
- {attempt 2}

**Environment:** {Python version, OS, relevant packages}

Please:
1. Identify the root cause
2. Explain why this bug occurs
3. Provide a working fix
4. Suggest how to prevent similar bugs
"""

"""Explain {concept} for someone who knows {prerequisite knowledge}.

Please include:
1. A simple definition (1-2 sentences)
2. Why it matters / when to use it
3. A simple analogy or mental model
4. A basic code example with comments
5. A more advanced example showing real-world usage
6. Common mistakes to avoid
7. Related concepts to explore next

Use {language} for all code examples.
"""

"""Refactor this code with the following goals:

**Goals:** {e.g., improve readability, reduce complexity, add type hints}
**Constraints:** {e.g., maintain API compatibility, don't add dependencies}

**Current code:**
```{language}
{code}
```

Please:
1. Provide the refactored code
2. Explain each significant change
3. Note any trade-offs in your approach
4. Highlight if any behavior changed
"""