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

# 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"]
}

# 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
"""