from langchain_core.runnables import RunnableLambda
from langchain_core.runnables import chain  # ← @chain デコレータ用

# 方法1: lambda（最も一般的）★よく使う
my_chain = (
    (lambda x: x.upper())
    | (lambda x: f"結果: {x}")
)
my_chain.invoke("hello")  # → "結果: HELLO"

# 方法2: RunnableLambda（明示的に書く場合）
RunnableLambda(lambda x: x.upper())

# 方法3: @chain デコレータ（複雑な処理の場合）
# → 下の「@chainの実践例」を参照

# よくあるパターン: 文字列入力を辞書に変換して次に渡す
my_chain = (
    (lambda x: {"dish": x})  # 文字列 → 辞書
    | prompt
    | llm
    | StrOutputParser()
)

my_chain.invoke("オムライス")  # 文字列で直接呼べる

from langchain_core.runnables import chain

@chain
def validate_and_format(input_text: str) -> dict:
    """入力を検証してフォーマットする"""
    # 複数行の処理が書ける
    text = input_text.strip()

    if len(text) < 2:
        return {"error": "入力が短すぎます", "dish": None}

    # 先頭を大文字に
    formatted = text.capitalize()

    return {"dish": formatted, "original": text}

# パイプラインで使える
my_chain = validate_and_format | prompt | llm | StrOutputParser()

my_chain.invoke("カレー")
# → {"dish": "カレー", "original": "カレー"} がpromptに渡る

# lambda: 1行で書ける簡単な処理
(lambda x: {"dish": x})

# @chain: 複数行や条件分岐がある処理
@chain
def process(x):
    if not x:
        return {"error": "empty"}
    return {"dish": x.strip()}

from langchain_core.runnables import RunnableParallel

chain = RunnableParallel(
    key1=チェーン1,
    key2=チェーン2,
)
result = chain.invoke(入力)
# → {"key1": 結果1, "key2": 結果2}

from langchain_core.runnables import RunnableParallel

prompt_ingredients = ChatPromptTemplate.from_template("{dish}の材料を3つだけ")
prompt_calories = ChatPromptTemplate.from_template("{dish}のカロリーを数値だけ")

chain = (
    (lambda x: {"dish": x})
    | RunnableParallel(
        ingredients=prompt_ingredients | llm | StrOutputParser(),
        calories=prompt_calories | llm | StrOutputParser(),
    )
)

result = chain.invoke("カレー")
# → {"ingredients": "・玉ねぎ\n・肉\n・ルー", "calories": "約600kcal"}

from langchain_core.runnables import RunnableBranch

branch = RunnableBranch(
    (条件関数1, Trueの時のチェーン),
    (条件関数2, Trueの時のチェーン),
    デフォルトのチェーン,  # ← タプルじゃない = どれにも当てはまらない時
)

def is_food_question(x):
    dish = x["dish"]  # ← 前のステップの出力がdictなら取り出す
    return "カレー" in dish or "作り方" in dish or "レシピ" in dish

prompt_recipe = ChatPromptTemplate.from_template("料理に関する情報：{dish}")

chain = (
    (lambda x: {"dish": x})
    | RunnableBranch(
        (is_food_question, prompt_recipe | llm | StrOutputParser()),
        lambda x: "料理に関する質問をしてください"
    )
)

chain.invoke("カレーの作り方")  # → レシピが返る
chain.invoke("天気を教えて")    # → "料理に関する質問をしてください"

# 分岐の中で並列を使う
RunnableBranch(
    (is_food, RunnableParallel(recipe=..., calories=...)),
    "対応外です",
)

from operator import itemgetter

# 同じ意味
lambda x: x["dish"]
itemgetter("dish")

# 複数キー取得はitemgetterが便利
itemgetter("name", "age")  # → (name値, age値) をタプルで返す

from langchain_core.runnables import RunnablePassthrough

# 何もしない。ただ通すだけ。
RunnablePassthrough().invoke("こんにちは")
# → "こんにちは"（そのまま！）

# この2つは同じ動作
RunnablePassthrough()
lambda x: x

from langchain_core.runnables import RunnablePassthrough

chain = (
    (lambda x: {"question": x})  # まず dict を作る
    | RunnablePassthrough.assign(context=retriever)  # context を追加
)

chain.invoke("LangChainとは？")

chain = (
    {
        "question": RunnablePassthrough(),  # 入力をそのまま（= lambda x: x）
        "context": retriever                # 入力で検索
    }
    | prompt
    | llm
)

chain.invoke("LangChainとは？")

# パターンA: dict（シンプル・RAGでよく使う）
{
    "question": RunnablePassthrough(),
    "context": retriever
}

# パターンB: assign（途中でキーを追加したい時）
(lambda x: {"question": x})
| RunnablePassthrough.assign(context=retriever)

# ダメな例: 全部渡す
llm.invoke(f"以下の100ファイルを元に回答して: {全データ}")

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# サンプルデータ（本番ではVector Storeに保存）
documents = {
    "りんご": "りんごは青森県が生産量日本一です。",
    "みかん": "みかんは和歌山県や愛媛県が有名です。",
}

def simple_retriever(query: str) -> str:
    """簡易検索: キーワードが含まれるドキュメントを返す"""
    results = []
    for key, value in documents.items():
        if key in query:
            results.append(value)
    return "\n".join(results) if results else "関連情報が見つかりませんでした"

# プロンプト
prompt = ChatPromptTemplate.from_messages([
    ("system", "以下の情報を元に回答してください:\n{context}"),
    ("human", "{question}")
])

# チェーン
chain = (
    {
        "context": lambda x: simple_retriever(x),  # 検索実行
        "question": lambda x: x                     # 質問はそのまま
    }
    | prompt
    | llm
    | StrOutputParser()
)

# 実行
result = chain.invoke("りんごの産地は？")
print(result)  # → 青森県が生産量日本一です

from langchain_google_community import VertexAISearchRetriever
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Vertex AI Search の Retriever を作成
retriever = VertexAISearchRetriever(
    project_id="your-project-id",
    location="global",
    data_store_id="your-data-store-id",
    max_documents=3  # 取得するドキュメント数
)

# プロンプト
prompt = ChatPromptTemplate.from_messages([
    ("system", "以下の検索結果を元に回答してください:\n{context}"),
    ("human", "{question}")
])

# チェーン
chain = (
    {
        "context": retriever,       # Vertex AI Search で検索
        "question": lambda x: x     # 質問はそのまま
    }
    | prompt
    | llm
    | StrOutputParser()
)

# 実行
result = chain.invoke("就業規則について教えて")
print(result)

pip install langchain-google-community

from pydantic import BaseModel, Field
from langchain_core.runnables import RunnablePassthrough

# 複数クエリを生成するための型定義
class QueryGenerationOutput(BaseModel):
    queries: list[str] = Field(..., description="検索クエリのリスト")

# クエリ生成用プロンプト
query_generation_prompt = ChatPromptTemplate.from_messages([
    ("human", """質問に対してベクターデータベースで検索するための
適切な検索クエリを3つ生成してください。
多様な観点からアプローチするクエリを作成します。

質問: {question}""")
])

# クエリ生成チェーン
query_generation_chain = (
    query_generation_prompt
    | llm.with_structured_output(QueryGenerationOutput)
    | (lambda x: x.queries)  # オブジェクトからリストを取り出す
)

# Multi-Query RAG チェーン
multi_query_rag_chain = (
    {
        "question": RunnablePassthrough(),
        "context": query_generation_chain | retriever.map(),
    }
    | prompt
    | llm
    | StrOutputParser()
)

スコア = 1/(k + 順位)   # k=60 が一般的

from langchain_core.documents import Document

def reciprocal_rank_fusion(
    results: list[list[Document]],  # 入力: [[Doc1,Doc2,...], [Doc3,Doc4,...], ...]
    k: int = 60
) -> list[Document]:                 # 出力: [Doc3, Doc1, ...]（スコア順）
    """
    RRF（Reciprocal Rank Fusion）スコアリング

    - 上位に出てくるほど高スコア
    - 複数クエリで出てくるほど高スコア
    """
    fused_scores: dict[str, float] = {}  # {"ドキュメント内容": スコア}
    doc_map: dict[str, Document] = {}    # {"ドキュメント内容": Documentオブジェクト}

    for docs in results:  # 外側: 各クエリの結果（クエリ1→クエリ2→クエリ3）
        for rank, doc in enumerate(docs):  # 内側: 各ドキュメントと順位（0,1,2,3...）
            doc_id = doc.page_content  # ドキュメントの中身をキーに

            if doc_id not in fused_scores:  # 初めて見たドキュメントなら
                fused_scores[doc_id] = 0.0  # スコア初期化
                doc_map[doc_id] = doc       # オブジェクト保存

            # RRFスコアを加算（同じドキュメントが複数回出てきたら加算される）
            fused_scores[doc_id] += 1 / (k + rank + 1)

    # スコアが高い順にソート
    sorted_docs = sorted(
        fused_scores.items(),   # [("Doc内容", 0.048), ("Doc内容", 0.032), ...]
        key=lambda x: x[1],     # タプルの2番目（スコア）でソート
        reverse=True            # 降順（高い順）
    )

    # Documentオブジェクトのリストで返す
    return [doc_map[doc_id] for doc_id, _ in sorted_docs]

# RAG-Fusionチェーン
rag_fusion_chain = (
    {
        "question": RunnablePassthrough(),
        "context": query_generation_chain | retriever.map() | reciprocal_rank_fusion,
    }
    | prompt
    | llm
    | StrOutputParser()
)

# Multi-Query RAG（単純に結合）
"context": query_generation_chain | retriever.map()
# → [[Doc1, Doc2], [Doc3, Doc4]] をそのまま渡す

# RAG-Fusion（スコアリング）
"context": query_generation_chain | retriever.map() | reciprocal_rank_fusion
# → [Doc3, Doc1, Doc4, ...] スコア順にソート

from pydantic import BaseModel, Field

# 型定義
class Recipe(BaseModel):
    ingredients: list[str] = Field(description="料理の材料のリスト")
    steps: list[str] = Field(description="料理の手順のリスト")

# これだけでOK！
structured_llm = llm.with_structured_output(Recipe)
result = structured_llm.invoke("オムライスのレシピを教えて")

print(result.ingredients)  # → ['卵 3個', '鶏もも肉 100g', ...]
print(result.steps)        # → ['鶏もも肉を切る', '炒める', ...]

# あなたが書いたコード
structured_llm.invoke("オムライスのレシピを教えて")

# 内部でLLMが受け取るメッセージ（イメージ）
[system] 以下のJSON形式で出力してください:
         {
           "ingredients": ["材料1", "材料2"],
           "steps": ["手順1", "手順2"]
         }
[human] オムライスのレシピを教えて

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from pydantic import BaseModel, Field

# 型定義
class Recipe(BaseModel):
    menu: str = Field(description="料理名")
    ingredients: list[str] = Field(description="材料リスト")
    steps: list[str] = Field(description="手順リスト")

# 1つ目のチェーン: 食材から料理名を考える
prompt1 = ChatPromptTemplate.from_template(
    "{ingredient}を使った料理名を1つだけ答えて"
)

# 2つ目のチェーン: 料理名からレシピを構造化して取得
prompt2 = ChatPromptTemplate.from_template(
    "{dish}のレシピを教えて"
)

structured_llm = llm.with_structured_output(Recipe)

# チェーンをつなげる
chain = (
    prompt1
    | llm
    | StrOutputParser()                    # → "オムライス"
    | (lambda x: {"dish": x})              # → {"dish": "オムライス"}
    | prompt2
    | structured_llm                       # → Recipe オブジェクト
)

# 実行
result = chain.invoke({"ingredient": "卵"})
print(result.menu)         # → "オムライス"
print(result.ingredients)  # → ['卵 3個', '鶏もも肉 100g', ...]
print(result.steps)        # → ['鶏もも肉を切る', '炒める', ...]

from langchain_core.tools import tool
from langchain_google_genai import ChatGoogleGenerativeAI

# ステップ1: ツールを定義（docstringは必須！）
@tool
def get_weather(city: str) -> str:
    """指定した都市の天気を取得する"""  # ← これがないとエラー
    return f"{city}の天気は晴れです"

# ステップ2: LLMにツールをバインド
llm = ChatGoogleGenerativeAI(...)
llm_with_tools = llm.bind_tools([get_weather])

# ステップ3: 質問 → AIの判断を取得 → 実行
response = llm_with_tools.invoke("東京の天気は？")

if response.tool_calls:
    tool_call = response.tool_calls[0]
    print(tool_call["name"])  # → "get_weather"
    print(tool_call["args"])  # → {"city": "東京"}

    # 実際に実行
    result = get_weather.invoke(tool_call["args"])
    print(result)  # → "東京の天気は晴れです"

@tool
def get_weather(city: str) -> str:
    """指定した都市の天気を取得する"""  # ← AIはこれを見て判断する
    return f"{city}の天気は晴れです"

@tool
def get_weather(city: str) -> str:
    """指定した都市の天気を取得する"""
    return f"{city}の天気は晴れです"

@tool
def calculate(expression: str) -> str:
    """数式を計算する"""
    return str(eval(expression))

# 複数のツールをバインド
llm_with_tools = llm.bind_tools([get_weather, calculate])

# AIが適切なツールを選ぶ
response = llm_with_tools.invoke("100 + 200 は？")
# → tool_call["name"] = "calculate"
# → tool_call["args"] = {"expression": "100 + 200"}

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

prompt = ChatPromptTemplate.from_messages([
    ("system", "あなたはアシスタントです"),
    MessagesPlaceholder(variable_name="history", optional=True),
    ("human", "{question}")
])

# 履歴を渡す
result = prompt.invoke({
    "question": "私の名前は？",
    "history": [
        ("human", "私は田中です"),
        ("ai", "こんにちは、田中さん！")
    ]
})

for chunk in llm.stream("長い話をして"):
    print(chunk.content, end="", flush=True)

from enum import Enum

class Route(str, Enum):
    TECH = "tech"        # 技術系の質問
    GENERAL = "general"  # 一般的な質問

# 使用例
print(Route.TECH.value)      # → "tech"
print(Route.TECH == "tech")  # → True（strを継承しているので比較可能）

# int型にしたい場合
class Priority(int, Enum):
    HIGH = 1
    LOW = 2

from pydantic import BaseModel, Field

class RouteOutput(BaseModel):
    route: Route = Field(description="質問の分類")

from enum import Enum
from pydantic import BaseModel, Field
from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableLambda

# ========== 1. Enum定義 ==========
class Route(str, Enum):
    TECH = "tech"
    GENERAL = "general"

class RouteOutput(BaseModel):
    route: Route = Field(description="質問の分類")

# ========== 2. ダミーretriever（本番はVertex AI等） ==========
tech_docs = {
    "Python": "Pythonは動的型付け言語です。",
    "LangChain": "LangChainはLLMアプリ開発フレームワークです。",
}

general_docs = {
    "天気": "東京の天気は晴れです。",
    "挨拶": "こんにちは！",
}

def tech_retriever(query: str) -> str:
    for keyword, content in tech_docs.items():
        if keyword.lower() in query.lower():
            return content
    return "技術情報が見つかりません。"

def general_retriever(query: str) -> str:
    for keyword, content in general_docs.items():
        if keyword in query:
            return content
    return "一般情報が見つかりません。"

# ========== 3. LLMとプロンプト ==========
llm = ChatGoogleGenerativeAI(
    model="gemini-2.0-flash-001",
    project="your-project-id",
    location="us-central1"
)

route_prompt = ChatPromptTemplate.from_messages([
    ("system", """質問を以下のどちらかに分類してください:
- tech: プログラミング、技術、IT関連
- general: 天気、ニュース、日常会話など"""),
    ("human", "{question}")
])

answer_prompt = ChatPromptTemplate.from_messages([
    ("system", "以下の情報を元に回答してください。"),
    ("human", "情報: {context}\n\n質問: {question}")
])

# ========== 4. ルート判定チェーン ==========
route_chain = (
    route_prompt
    | llm.with_structured_output(RouteOutput)
    | (lambda x: x.route)  # Route.TECH or Route.GENERAL
)

# ========== 5. 分岐処理 ==========
def route_and_retrieve(input_dict):
    question = input_dict["question"]
    route = route_chain.invoke({"question": question})

    print(f"📍 ルート判定: {route.value}")

    if route == Route.TECH:
        context = tech_retriever(question)
    else:
        context = general_retriever(question)

    return {"question": question, "context": context}

# ========== 6. 最終チェーン ==========
full_chain = (
    RunnableLambda(lambda x: {"question": x})
    | RunnableLambda(route_and_retrieve)
    | answer_prompt
    | llm
    | StrOutputParser()
)

# ========== 実行 ==========
print(full_chain.invoke("Pythonについて教えて"))
# → 📍 ルート判定: tech
# → Pythonは動的型付け言語です...

# ❌ 文字列だとタイポしても気づかない
route = "teck"  # タイポ！でもエラーにならない

# ✅ Enumだとエラーになる
route = Route.TECK  # AttributeError!

# ❌ 両方とも普通の関数だとエラー
(lambda x: ...) | route_and_retrieve  # TypeError!

# ✅ RunnableLambdaでラップ
RunnableLambda(lambda x: ...) | RunnableLambda(func)

from langchain_core.runnables import RunnablePassthrough

# クエリ生成（16章と同じ）
class QueryGenerationOutput(BaseModel):
    queries: list[str] = Field(description="検索クエリ3つ")

query_prompt = ChatPromptTemplate.from_messages([
    ("human", "質問に対して検索クエリを3つ生成:\n{question}")
])

query_chain = (
    query_prompt
    | llm.with_structured_output(QueryGenerationOutput)
    | (lambda x: x.queries)
)

# retrieverを辞書で管理
retrievers = {
    Route.TECH: tech_vector_store.as_retriever(),
    Route.GENERAL: general_vector_store.as_retriever(),
}

def route_and_fusion(input_dict):
    """ルーティング → Multi-Query → RRF"""
    question = input_dict["question"]

    # 1. ルート判定
    route = route_chain.invoke({"question": question})
    print(f"📍 ルート: {route.value}")

    # 2. Multi-Query生成
    queries = query_chain.invoke({"question": question})
    print(f"📝 生成クエリ: {queries}")

    # 3. 選ばれたretrieverで検索
    retriever = retrievers[route]
    results = [retriever.invoke(q) for q in queries]

    # 4. RRFでスコアリング
    fused_docs = reciprocal_rank_fusion(results)

    return {
        "question": question,
        "context": fused_docs[:5]  # 上位5件
    }

# 最終チェーン
fusion_chain = (
    RunnableLambda(lambda x: {"question": x})
    | RunnableLambda(route_and_fusion)
    | answer_prompt
    | llm
    | StrOutputParser()
)

# Vertex AI Searchの場合
from langchain_google_community import VertexAISearchRetriever

retrievers = {
    Route.TECH: VertexAISearchRetriever(
        project_id="...",
        data_store_id="tech-docs",  # 技術文書用
    ),
    Route.GENERAL: VertexAISearchRetriever(
        project_id="...",
        data_store_id="general-docs",  # 一般文書用
    ),
}

# クラス = 設計図
class Dog:
    def __init__(self, name):   # 初期化（自動で呼ばれる）
        self.name = name        # self = このインスタンス自体

    def bark(self):             # メソッド（手動で呼ぶ）
        return f"{self.name}がワン！"

# インスタンス = 設計図から作った実体
dog1 = Dog("ポチ")   # → __init__(self=dog1, name="ポチ") が自動実行
dog2 = Dog("タロウ")

dog1.bark()  # → "ポチがワン！"（self = dog1）
dog2.bark()  # → "タロウがワン！"（self = dog2）

# selfは「ポチ」ではなく「dog1」
dog1 = Dog("ポチ")

# dog1.bark() が呼ばれると
#   → bark(self=dog1) として実行される
#   → self.name は dog1.name = "ポチ"

# イメージ
# dog1 = 箱（インスタンス）
# "ポチ" = 箱の中身（値）
# self = 箱自体を指す

# __init__ = 定義は書くが、呼び出しは書かない
class Dog:
    def __init__(self, name):  # ← 定義は書く
        self.name = name

dog1 = Dog("ポチ")  # ← 呼び出しは書かない（Pythonが自動で呼ぶ）

# データを持たない場合は __init__ 不要
class Calculator:
    def add(self, a, b):
        return a + b

calc = Calculator()  # 何も渡さなくてOK
calc.add(1, 2)  # → 3

# 関数を「ラップ」して追加機能を付ける構文

# LangChainでよく使うデコレータ
@tool   # 関数をLLMのツールにする（よく使う）
@chain  # 関数をパイプライン部品にする（あまり使わない）

# 例
from langchain_core.tools import tool

@tool
def get_weather(city: str) -> str:
    """指定した都市の天気を取得する"""
    return f"{city}の天気は晴れです"

# @tool を付けると .invoke() で呼べるようになる
get_weather.invoke({"city": "東京"})  # → "東京の天気は晴れです"

# ========== dict 型 ==========
# 定義不要、自由に作れる
d = {"queries": ["a", "b", "c"], "count": 3}

# 取り出し方: ブラケット ["キー名"]
d["queries"]  # → ["a", "b", "c"]
d["count"]    # → 3


# ========== オブジェクト型 ==========
# クラス定義が必要（設計図を先に作る）
from pydantic import BaseModel

class QueryOutput(BaseModel):
    queries: list[str]
    count: int

obj = QueryOutput(queries=["a", "b", "c"], count=3)

# 取り出し方: ドット .属性名
obj.queries   # → ["a", "b", "c"]
obj.count     # → 3

# dict を使う場面: チェーン内のデータ受け渡し
chain = (
    {"question": RunnablePassthrough(), "context": retriever}
    | prompt
    | llm
)
# → {"question": "...", "context": [...]} が prompt に渡る
#   prompt 内で {question} や {context} を使う


# オブジェクトを使う場面: LLM の構造化出力
class Recipe(BaseModel):
    ingredients: list[str]
    steps: list[str]

structured_llm = llm.with_structured_output(Recipe)
result = structured_llm.invoke("カレーのレシピ")

result.ingredients  # → ["じゃがいも", "玉ねぎ", ...]
result.steps        # → ["野菜を切る", "炒める", ...]

# ❌ dict なのにドットでアクセス
d = {"queries": ["a", "b"]}
d.queries  # AttributeError!

# ✅ dict はブラケット
d["queries"]  # → ["a", "b"]


# ❌ オブジェクトなのにブラケットでアクセス
obj = QueryOutput(queries=["a", "b"])
obj["queries"]  # TypeError!

# ✅ オブジェクトはドット
obj.queries  # → ["a", "b"]

# 前のステップの出力が dict の場合
| (lambda x: x["question"])

# 前のステップの出力がオブジェクトの場合
| (lambda x: x.queries)

# 普通のクラス（__init__ を自分で書く）
class MyClass:
    def __init__(self, queries: list[str]):
        self.queries = queries

# Pydantic BaseModel（__init__ 不要！）
class QueryOutput(BaseModel):
    queries: list[str]  # これだけで OK

# どちらも同じように使える
obj1 = MyClass(queries=["a", "b"])
obj2 = QueryOutput(queries=["a", "b"])

obj1.queries  # → ["a", "b"]
obj2.queries  # → ["a", "b"]

# キーワード検索の問題
query = "果物の産地"
if "りんご" in query:  # ← マッチしない！
    return りんごの情報

# イメージ
"りんご" → [0.1, 0.8, 0.3, ...]  # 果物っぽい数値
"みかん" → [0.2, 0.7, 0.4, ...]  # 果物っぽい数値（似てる！）
"車"     → [0.9, 0.1, 0.2, ...]  # 全然違う数値

# 普通のクラス（型チェックなし）
class Recipe:
    def __init__(self, name, calories):
        self.name = name
        self.calories = calories

recipe = Recipe("カレー", "たくさん")  # ← エラーにならない

# Pydantic（型チェックあり）
from pydantic import BaseModel

class Recipe(BaseModel):
    name: str
    calories: int

recipe = Recipe(name="カレー", calories="たくさん")  # ← エラー！

# 普通のクラス（自分で書く）
class Recipe:
    def __init__(self, name: str, calories: int):
        self.name = name
        self.calories = calories

# Pydantic（自動生成される）
class Recipe(BaseModel):
    name: str
    calories: int
    # __init__ は自動で作られる！

class Recipe(BaseModel):
    name: str = Field(description="料理名")
    calories: int = Field(description="カロリー（kcal）")

# タプル（LangChainで使う）
("system", "こんにちは")

# 辞書（これもOK）
{"role": "system", "content": "こんにちは"}

# セット（間違い！使わない）
{"system", "こんにちは"}

# シングルクォート（1行）
'こんにちは'

# ダブルクォート（1行）
"こんにちは"

# 三重クォート（複数行OK）
'''
これは
複数行の
文字列です
'''

"""
ダブルでも
同じように
複数行OK
"""

# \n = 改行
print("1行目\n2行目")
# 出力:
# 1行目
# 2行目

# \t = タブ
print("名前\t年齢")
# 出力: 名前    年齢

# \' や \" = クォート自体を表示
print("He said \"Hello\"")
# 出力: He said "Hello"

# \\ = バックスラッシュ自体
print("C:\\Users\\name")
# 出力: C:\Users\name

name = "田中"
age = 30

# f-string（推奨）
f"私は{name}です。{age}歳です。"

# 三重クォート + f-string（複数行で変数埋め込み）
f"""
名前: {name}
年齢: {age}
"""

# 普通の for（4行）
results = []
for word in ["果物", "フルーツ", "産地"]:
    results.append(word in query)

# リスト内包表記（1行）
results = [word in query for word in ["果物", "フルーツ", "産地"]]

documents = {
    "りんご": "りんごは青森県が...",
    "みかん": "みかんは和歌山県が...",
}

# .items() で「キーと値のペア」を取り出せる
for key, value in documents.items():
    print(f"キー: {key}, 値: {value}")

# 変数名は自由（A, B でもOK）
for A, B in documents.items():
    print(A, B)

query = "りんごの産地は？"

"りんご" in query  # → True（含まれてる）
"みかん" in query  # → False（含まれてない）