Prompt Templates &
Output Parsers

from langchain.prompts import PromptTemplate

# Create a simple template
template = """You are a helpful assistant that translates {input_language} to {output_language}.

Text: {text}

Translation:"""

# Create the prompt template
prompt = PromptTemplate(
    input_variables=["input_language", "output_language", "text"],
    template=template
)

# Use the template
formatted_prompt = prompt.format(
    input_language="English",
    output_language="Spanish",
    text="Hello, how are you?"
)

print(formatted_prompt)

# Output will be:
# You are a helpful assistant that translates English to Spanish.
# 
# Text: Hello, how are you?
# 
# Translation:

from langchain.prompts import PromptTemplate
from langchain_google_genai import ChatGoogleGenerativeAI
import os
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Create the template
template = """You are a helpful assistant that translates {input_language} to {output_language}.

Text: {text}

Translation:"""

prompt = PromptTemplate(
    input_variables=["input_language", "output_language", "text"],
    template=template
)

# Initialize the LLM with API key
# Make sure you have GOOGLE_API_KEY in your .env file
model = ChatGoogleGenerativeAI(
    model="gemini-2.0-flash",
    google_api_key=os.getenv("GOOGLE_API_KEY")
)

# Create a chain: template -> LLM
chain = prompt | model

# Run the chain (this will actually translate!)
response = chain.invoke({
    "input_language": "English",
    "output_language": "Spanish",
    "text": "Hello, how are you?"
})

print(response.content)
# Output: "Hola, ¿cómo estás?"

from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_google_genai import ChatGoogleGenerativeAI
import os
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Create a chat template with system and human messages
chat_template = ChatPromptTemplate.from_messages([
    ("system", "You are a {role} that helps with {task}."),
    ("human", "{user_input}"),
])

# Format the template
messages = chat_template.format_messages(
    role="programming tutor",
    task="Python coding",
    user_input="How do I read a CSV file?"
)

# Use with your model
llm = ChatGoogleGenerativeAI(
    model="gemini-2.0-flash",
    google_api_key=os.getenv("GOOGLE_API_KEY")  # Set API key explicitly
)
response = llm.invoke(messages)
print(response.content)

from langchain.prompts import PromptTemplate
from datetime import datetime

# Template with multiple variables
template = """Date: {date}
User: {user_name}
Task: {task}

Please complete the following: {request}"""

# Create a partial template with date pre-filled
prompt = PromptTemplate(
    input_variables=["user_name", "task", "request"],
    template=template,
    partial_variables={"date": datetime.now().strftime("%Y-%m-%d")}
)

# Now you only need to provide the remaining variables
formatted = prompt.format(
    user_name="Alice",
    task="Code Review",
    request="Review this Python function for best practices"
)

print(formatted)

from langchain.prompts import PromptTemplate

# Define reusable template components
persona_template = "You are a {expertise} expert with {years} years of experience."
task_template = "Your task is to {action} the following {content_type}:"
format_template = "Please format your response as {format}."

# Combine templates
full_template = f"""
{persona_template}

{task_template}

{format_template}

Content: {{content}}
"""

# Create the prompt
prompt = PromptTemplate(
    input_variables=["expertise", "years", "action", "content_type", "format", "content"],
    template=full_template
)

# Use the composed template
result = prompt.format(
    expertise="Python",
    years="10",
    action="optimize",
    content_type="code",
    format="a list of improvements with explanations",
    content="def calculate_sum(numbers): total = 0; for n in numbers: total = total + n; return total"
)

print(result)

from langchain.output_parsers import CommaSeparatedListOutputParser
from langchain.prompts import PromptTemplate
from langchain_google_genai import ChatGoogleGenerativeAI
import os
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Initialize parser
list_parser = CommaSeparatedListOutputParser()

# Create prompt with format instructions
prompt = PromptTemplate(
    template="List 5 {category}.\n{format_instructions}",
    input_variables=["category"],
    partial_variables={"format_instructions": list_parser.get_format_instructions()}
)

# Create chain
llm = ChatGoogleGenerativeAI(
    model="gemini-2.0-flash",
    google_api_key=os.getenv("GOOGLE_API_KEY")
)
chain = prompt | llm | list_parser

# Get parsed list
result = chain.invoke({"category": "Python web frameworks"})
print(result)  # ['Django', 'Flask', 'FastAPI', 'Pyramid', 'Tornado']

from langchain.output_parsers import ResponseSchema, StructuredOutputParser
from langchain.prompts import PromptTemplate
from langchain_google_genai import ChatGoogleGenerativeAI
import os
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Define the expected structure
response_schemas = [
    ResponseSchema(
        name="name",
        description="The name of the product"
    ),
    ResponseSchema(
        name="price",
        description="The price in USD as a number"
    ),
    ResponseSchema(
        name="features",
        description="A list of key features"
    ),
    ResponseSchema(
        name="in_stock",
        description="Whether the item is in stock (true/false)"
    )
]

# Create parser
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)

# Create prompt
prompt = PromptTemplate(
    template="""Extract product information from the following text.
    
{format_instructions}

Text: {product_description}""",
    input_variables=["product_description"],
    partial_variables={"format_instructions": output_parser.get_format_instructions()}
)

# Use the chain
llm = ChatGoogleGenerativeAI(
    model="gemini-2.0-flash",
    google_api_key=os.getenv("GOOGLE_API_KEY")
)
chain = prompt | llm | output_parser

# Example usage
result = chain.invoke({
    "product_description": "The new iPhone 15 Pro costs $999 and features a titanium design, A17 Pro chip, and improved camera system. Currently available in stores."
})

print(result)
# {'name': 'iPhone 15 Pro', 'price': 999, 'features': ['titanium design', 'A17 Pro chip', 'improved camera system'], 'in_stock': True}