4. テンプレートを使った再利用可能なプロンプトの設計

from langchain_core.prompts import PromptTemplate
 
# プレースホルダーを使用してテンプレートを定義
template = PromptTemplate.from_template(
    "Translate {content} from {source_lang} to {target_lang}"
)
 
# 辞書でプレースホルダーを埋める
result = template.invoke({
    "content": "Hello world",
    "source_lang": "English", 
    "target_lang": "Korean"
})
 
print(result.text)

Translate Hello world from English to Korean

# PromptTemplate - 単一の文字列出力
from langchain_core.prompts import PromptTemplate
 
template1 = PromptTemplate.from_template("Summarize: {content}")
result1 = template1.invoke({"content": "LangChain is a framework..."})  
print(result1)

text='Summarize: LangChain is a framework...'

# ChatPromptTemplate - ロールベースのメッセージ
from langchain_core.prompts import ChatPromptTemplate
 
template2 = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant"),
    ("user", "{question}")
])
result2 = template2.invoke({"question": "What is LangChain?"})
print(result2)

messages=[SystemMessage(content='You are a helpful assistant'), HumanMessage(content='What is LangChain?')]

# ハードコードされたアプローチ（第3章スタイル）
from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-4o-mini")
 
user_input = "Explain quantum computing"
# プロンプトロジックがコードと混在
prompt = f"You are a helpful assistant. Answer this question: {user_input}"
 
response = llm.invoke(prompt)
print(response.content)

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
 
# テンプレートを別々に定義
template = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    ("user", "{user_input}")
])
 
# アプリケーションロジック - ステップバイステップの実行
llm = ChatOpenAI(model="gpt-4o-mini")
 
user_input = "Explain quantum computing"
 
# ステップ1: テンプレートをメッセージにレンダリング
messages = template.invoke({"user_input": user_input})
 
# ステップ2: メッセージをLLMに送信
response = llm.invoke(messages)
print(response.content)

messages = template.invoke(inputs)  # ステップ1: テンプレートをレンダリング
response = llm.invoke(messages)     # ステップ2: LLMに送信

template = PromptTemplate.from_template("Summarize: {text}")
 
# これは失敗します - 'text' キーが不足しています
try:
    template.invoke({"content": "Some text"})  # 間違ったキー名
except KeyError as e:
    print(f"Template error: {e}")

Template error: "Input to PromptTemplate is missing variables {'text'}.  Expected: ['text'] Received: ['content']

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
 
template = ChatPromptTemplate.from_messages([
    ("user", "What is Python?")
])
 
llm = ChatOpenAI(model="gpt-4o-mini")
messages = template.invoke({})
response = llm.invoke(messages)
print(response.content)

Python is a high-level, interpreted programming language known for its readability and simplicity. 
It was created by Guido van Rossum and first released in 1991. 
Python emphasizes code readability, allowing programmers to express concepts in fewer lines of code compared to languages such as C++ or Java.
 
Key features of Python include:
...

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
 
# システムメッセージでペルソナと出力スタイルを制御
template = ChatPromptTemplate.from_messages([
    ("system", """あなたは15年の教育経験を持つシニアPythonインストラクターです。
あなたの生徒は、これまでプログラミングをしたことがない完全な初心者です。
 
教え方:
- シンプルで日常的な類推を使用してください
- 技術的な専門用語を避けてください
- 日常生活からの実践的な例を示してください
- 励まし、忍耐強くしてください"""),
    ("user", "What is Python?")
])
 
llm = ChatOpenAI(model="gpt-4o-mini")
messages = template.invoke({})
response = llm.invoke(messages)
print(response.content)

Great question! Think of Python like a really helpful tool in your toolbox. 
Just like a hammer or a screwdriver helps you build or fix things around the house, Python helps you create software or automate tasks on a computer.
 
Imagine you wanted to bake a cake. 
You need a recipe to follow, right? In this analogy, Python is like that recipe. 
It tells the computer what steps to take to achieve a goal, whether it's doing math, organizing files, or even running a game.
...

template = ChatPromptTemplate.from_messages([
    ("system", "You are a Python expert."),
    ("user", "{question}")
])
 
llm = ChatOpenAI(model="gpt-4o-mini")
messages = template.invoke({"question": "How do I read a CSV?"})
response = llm.invoke(messages)

template = ChatPromptTemplate.from_messages([
    ("system", "You are a Python expert."),
    ("user", "How does it work?")  # "it" = ???
])

template = ChatPromptTemplate.from_messages([
    ("system", "You are a Python expert."),
    ("user", "What's the pandas library?"),
    ("assistant", "Pandas is a data analysis library."),
    ("user", "How does it work?")  # 今は "it" = pandas
])

llm = ChatOpenAI(model="gpt-4o-mini")
 
def chat_with_history(user_input: str, history: list):
    messages = [("system", "You are a Python expert.")]
    
    # 履歴を追加
    for msg in history:
        messages.append((msg["role"], msg["content"]))
    
    # 現在の入力を追加
    messages.append(("user", user_input))
    
    # コンテンツに{中括弧}が含まれている場合のエラーを避けるためにmustache形式を使用
    template = ChatPromptTemplate.from_messages(messages, template_format="mustache")
    
    formatted = template.format()
    response = llm.invoke(formatted)
    return response.content
 
# 使用法
history = []
 
# ターン1
resp1 = chat_with_history("What's a Python dictionary?", history)
print(resp1)
 
history.append({"role": "user", "content": "What's a Python dictionary?"})
history.append({"role": "assistant", "content": resp1})
 
# ターン2 - コンテキストを使用
resp2 = chat_with_history("Show an example.", history)
print(resp2)

# System + 単一のUser
[("system", "..."), ("user", "...")]
 
# System + 会話
[("system", "..."), ("user", "..."), ("assistant", "..."), ("user", "...")]

# UserよりもAssistantが先 - AIがコンテキストについて混乱
[("system", "..."), ("assistant", "..."), ("user", "...")]
# AIは質問なしで応答を見ます。これがどの質問に答えているのかを幻覚する可能性があり、
# 無関係または混乱した応答につながります。

# 2つのUserメッセージが連続 - AI応答が不足
[("system", "..."), ("user", "..."), ("user", "...")]
# AIはどのUserメッセージに応答すべきかわからないか、それらを不自然にマージする可能性があります。
# 会話の流れを失います。

# Assistantで終わる - 応答するものがない
[("system", "..."), ("user", "..."), ("assistant", "...")]
# 会話は完了しています。保留中のUser質問がないため、AIは生成するものがありません。
# エラーまたは空の応答を生成する可能性があります。

messages = [
    ("system", "You are a Python expert."),
    ("user", "What's a dictionary?"),
    ("assistant", "A dictionary is a key-value data structure."),
    ("user", "Show an example.")
]

messages = [
    ("system", "You are a Python expert."),
    ("user", """コンテキスト: ユーザーは以前にPythonの辞書について尋ね、それらがキー-値構造であることを学びました。
 
タスク: 辞書の使用法を示すコード例を提供してください。""")
]

# prompts/system_prompt.yaml
_type: prompt
input_variables: []
template: |
  You are a helpful assistant.
  Please answer in a friendly and encouraging tone.

# prompts/user_prompt.yaml
_type: prompt
input_variables:
  - user_input
template: |
  User question: {user_input}
  Please provide a clear answer.

from langchain_core.prompts import load_prompt, ChatPromptTemplate
from langchain_openai import ChatOpenAI
 
# YAMLファイルからプロンプトをロード
system_prompt_template = load_prompt("prompts/system_prompt.yaml")
user_prompt_template = load_prompt("prompts/user_prompt.yaml")
 
# ロードされたプロンプトをチャットテンプレートに結合
chat_template = ChatPromptTemplate.from_messages([
    ("system", system_prompt_template.template),
    ("user", user_prompt_template.template)
])
 
llm = ChatOpenAI(model="gpt-4o-mini")
 
# ステップ1: 実行時の値でテンプレートをレンダリング
messages = chat_template.invoke({"user_input": "What is LangChain?"})
 
# ステップ2: LLMに送信
response = llm.invoke(messages)
print(response.content)

from langchain_core.prompts import load_prompt
 
# テンプレートをロード
user_prompt_template = load_prompt("prompts/user_prompt.yaml")
 
# 期待される変数を確認
print("Input variables:", user_prompt_template.input_variables)
 
# テンプレートテキストを確認
print("Template:", user_prompt_template.template)

Input variables: ['user_input']
Template: User question: {user_input}
Please provide a clear answer.

_type: prompt
input_variables:
- user_input      # 間違い: リスト項目はインデントする必要があります
  - question      # 間違い: 混在したインデントレベル

_type: prompt
input_variables:
  - user_input    # 正しい: 両方の項目が同じインデントレベル
  - question

input_variables:
  - user_input
template: "Question: {question}"  # 'question' は input_variables にありません！

input_variables:
  - user_input
template: "Question: {user_input}"

from langchain_core.prompts import ChatPromptTemplate
 
template = ChatPromptTemplate.from_messages([
    ("system", "You are a {role}."),
    ("user", "{user_input}")
])
 
# テンプレート構造をプレビュー
print("Input variables:", template.input_variables)
print("Message count:", len(template.messages))
 
# サンプルデータでプレビュー
prompt_value = template.invoke({
    "role": "Python programming expert",
    "user_input": "What is Python?"
})
 
print("\nPreview:")
for msg in prompt_value.to_messages():
    print(f"{msg.type}: {msg.content}")

Input variables: ['role', 'user_input']
Message count: 2
 
Preview:
system: You are a Python programming expert.
human: What is Python?

from langchain_core.prompts import ChatPromptTemplate
 
def preview_template(template: ChatPromptTemplate, inputs: dict):
    """指定された入力でテンプレートをプレビューし、エラーを検出します。"""
    try:
        prompt_value = template.invoke(inputs)
        
        print("TEMPLATE PREVIEW")
        print("=" * 60)
        
        for i, msg in enumerate(prompt_value.to_messages(), 1):
            print(f"Message {i} ({msg.type.upper()}):")
            print(msg.content)
            print("-" * 60)
                
    except KeyError as e:
        print(f"ERROR: {e}")
        print(f"Required variables: {template.input_variables}")
 
# 使用法
template = ChatPromptTemplate.from_messages([
    ("system", "You are a {role}."),
    ("user", "{user_input}")
])
 
# 有効な入力
preview_template(template, {
    "role": "Python programming expert",
    "user_input": "What is Python?"
})
 
# 不足している変数
preview_template(template, {
    "user_input": "What is Python?"  # 'role' が不足
})

TEMPLATE PREVIEW
============================================================
Message 1 (SYSTEM):
You are a Python programming expert.
------------------------------------------------------------
Message 2 (HUMAN):
What is Python?
------------------------------------------------------------
 
ERROR: "Input to ChatPromptTemplate is missing variables {'role'}.
Expected: ['role', 'user_input'] Received: ['user_input']
...
Required variables: ['role', 'user_input']