Prompt Engineering

from openai import OpenAI

client = OpenAI()

system_prompt = """You are a sentiment classifier.
Classify each review as POSITIVE, NEGATIVE, or NEUTRAL.
Return only the label — nothing else."""

# Few-shot examples establish the exact format and pattern
few_shot_examples = [
    {"role": "user",      "content": "The food was absolutely delicious!"},
    {"role": "assistant", "content": "POSITIVE"},
    {"role": "user",      "content": "Service was slow and staff were rude."},
    {"role": "assistant", "content": "NEGATIVE"},
    {"role": "user",      "content": "It was fine, nothing special."},
    {"role": "assistant", "content": "NEUTRAL"},
]

def classify_sentiment(review: str) -> str:
    messages = [{"role": "system", "content": system_prompt}]
    messages.extend(few_shot_examples)
    messages.append({"role": "user", "content": review})

    resp = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
        max_tokens=10,
        temperature=0,   # deterministic for classification
    )
    return resp.choices[0].message.content.strip()

print(classify_sentiment("Worst meal I've had in years."))    # → NEGATIVE
print(classify_sentiment("Pretty good, would visit again."))  # → POSITIVE

# ReAct: Reason + Act. The model interleaves thinking and tool calls.
# This exact pattern underpins virtually all LLM agent frameworks.

REACT_SYSTEM = """You have access to these tools:
- search("query")     → returns top web results
- calculate("expr")   → evaluates a math expression  
- lookup("entity")    → returns a Wikipedia summary

For each step, output EXACTLY:
Thought: <your reasoning about what to do next>
Action: <tool_name("argument")>

After receiving Observation: <result>, continue reasoning.
When done: Final Answer: <your answer>"""

def react_agent(question: str, tools: dict, max_steps: int = 8) -> str:
    messages = [
        {"role": "system", "content": REACT_SYSTEM},
        {"role": "user",   "content": question},
    ]

    for _ in range(max_steps):
        response = call_llm(messages)          # your LLM call
        messages.append({"role": "assistant", "content": response})

        if "Final Answer:" in response:
            return response.split("Final Answer:")[-1].strip()

        # Parse the Action line and dispatch to the right tool
        for line in response.split("\n"):
            if line.startswith("Action:"):
                tool_call = line.replace("Action:", "").strip()
                tool_name = tool_call.split("(")[0]
                tool_arg  = tool_call.split('"')[1]
                result    = tools[tool_name](tool_arg)
                messages.append({"role": "user", "content": f"Observation: {result}"})
                break

    return "Max steps reached"

# Example run:
# react_agent("What is the population of the country that won Euro 2024?",
#             tools={"search": web_search, "lookup": wiki_lookup, "calculate": eval_expr})

import dspy

# Step 1: Configure the LLM
dspy.configure(lm=dspy.LM("openai/gpt-4o-mini"))

# Step 2: Declare tasks as typed Python signatures — NO prompt writing
class SentimentClassifier(dspy.Signature):
    """Classify the sentiment of a product review."""
    review: str   = dspy.InputField()
    sentiment: str = dspy.OutputField(desc="POSITIVE, NEGATIVE, or NEUTRAL")

class AnswerWithReasoning(dspy.Signature):
    """Answer the question using only the provided context."""
    context: str  = dspy.InputField(desc="Retrieved document chunks")
    question: str = dspy.InputField()
    answer: str   = dspy.OutputField(desc="Concise factual answer from context only")

# Step 3: Build modules — DSPy handles prompt generation
classifier = dspy.Predict(SentimentClassifier)
rag        = dspy.ChainOfThought(AnswerWithReasoning)

# Step 4: Optimize — given labeled examples, find the best prompt + demos
from dspy.teleprompt import BootstrapFewShot

def exact_match(pred, gold): return pred.sentiment == gold.sentiment

optimizer          = BootstrapFewShot(metric=exact_match, max_bootstrapped_demos=4)
optimized_clf      = optimizer.compile(classifier, trainset=training_examples)

# Step 5: Use the optimized module
result = optimized_clf(review="Battery died after 2 hours. Total disappointment.")
print(result.sentiment)  # → NEGATIVE

# DSPy inspects what prompt it generated:
dspy.inspect_history(n=1)