LCEL（LangChain Expression Language）でLangChain再入門する

!pip install --upgrade --quiet  langchain-core langchain-community langchain-openai

!pip freeze | grep -i langchain

langchain-community==0.0.32
langchain-core==0.1.41
langchain-openai==0.1.2

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-3.5-turbo-0125")

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_template("{topic}についてのジョークを1つ言ってみて。")

from langchain_core.output_parsers import StrOutputParser

output_parser = StrOutputParser()

chain = prompt | model | output_parser

response = chain.invoke({"topic": "アイスクリーム"})
response

prompt_value = prompt.invoke({"topic": "アイスクリーム"})
prompt_value

prompt_value.to_messages()

prompt_value.to_string()

message = model.invoke(prompt_value)
message

from langchain_openai import OpenAI

llm = OpenAI(model="gpt-3.5-turbo-instruct")
message2 = llm.invoke(prompt_value)
message2

output_parser.invoke(message)

output_parser.invoke(message2)

input = {"topic": "アイスクリーム"}

display(prompt.invoke(input))

display((prompt | model).invoke(input))

!pip install docarray tiktoken

texts = []
texts.append("""\
イクイノックス（欧字名:Equinox、2019年3月23日 - ）は、日本の競走馬・種牡馬。
主な勝ち鞍は、2022年・2023年の天皇賞（秋）連覇、2022年の有馬記念、2023年のドバイシーマクラシック、宝塚記念、ジャパンカップ。\
""")
texts.append("""\
オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。
主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。\
""")
texts.append("""\
ドウデュース（欧字名:Do Deuce、2019年5月7日 - ）は、日本の競走馬。
主な勝ち鞍は、2021年の朝日杯フューチュリティステークス、2022年の東京優駿、2023年の有馬記念。\
""")

from langchain_community.vectorstores import DocArrayInMemorySearch
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableParallel, RunnablePassthrough
from langchain_openai import OpenAIEmbeddings
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-3.5-turbo-0125")

embedding = OpenAIEmbeddings(model="text-embedding-3-small")

vectorstore = DocArrayInMemorySearch.from_texts(
    texts,
    embedding=embedding,
)
retriever = vectorstore.as_retriever()

template = """\
以下のコンテキストにもとづいて、質問に答えてください:
{context}

質問: {question}
回答: \
"""
prompt = ChatPromptTemplate.from_template(template)

output_parser = StrOutputParser()

setup_and_retrieval = RunnableParallel(
    {"context": retriever, "question": RunnablePassthrough()}
)

chain = setup_and_retrieval | prompt | model | output_parser

chain.invoke("ドウデュースの勝利したレースは何？")

retriever.invoke("ドウデュースの勝利したレースは何？")

setup_and_retrieval = RunnableParallel(
    {"context": retriever, "question": RunnablePassthrough()}
)

!pip install --upgrade --quiet  langchain-core langchain-openai langchain-anthropic

!pip freeze | grep -i langchain

langchain-anthropic==0.1.7
langchain-core==0.1.41
langchain-openai==0.1.2

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')
os.environ['ANTHROPIC_API_KEY'] = userdata.get('ANTHROPIC_API_KEY')

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

prompt = ChatPromptTemplate.from_template(
    "{topic}についてのジョークを1つおしえて。"
)
output_parser = StrOutputParser()
model = ChatOpenAI(model="gpt-3.5-turbo")
chain = (
    {"topic": RunnablePassthrough()} 
    | prompt
    | model
    | output_parser
)

response = chain.invoke("アイスクリーム")
print(response)

for chunk in chain.stream("アイスクリーム"):
    print(chunk, end="\n", flush=True)

chain.batch(["アイスクリーム", "スパゲッティ", "餃子"])

await chain.ainvoke("アイスクリーム")

await chain.abatch(["アイスクリーム", "スパゲッティ", "餃子"])

from langchain_openai import OpenAI

llm = OpenAI(model="gpt-3.5-turbo-instruct")
llm_chain = (
    {"topic": RunnablePassthrough()} 
    | prompt
    | llm
    | output_parser
)

llm_chain.invoke("アイスクリーム")

from langchain_anthropic import ChatAnthropic

anthropic = ChatAnthropic(model="claude-3-haiku-20240307")

anthropic_chain = (
    {"topic": RunnablePassthrough()} 
    | prompt 
    | anthropic
    | output_parser
)

anthropic_chain.invoke("アイスクリーム")

from langchain_openai import OpenAI, ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough, ConfigurableField
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_template(
    "{topic}についてのジョークを1つおしえて。"
)

chat_openai = ChatOpenAI(model="gpt-3.5-turbo")
openai = OpenAI(model="gpt-3.5-turbo-instruct")
anthropic = ChatAnthropic(model="claude-3-haiku-20240307")
model = (
    chat_openai
    .configurable_alternatives(
        ConfigurableField(id="model"),
        default_key="chat_openai",
        openai=openai,
        anthropic=anthropic,
    )
)

chain = (
    {"topic": RunnablePassthrough()} 
    | prompt 
    | model
    #| StrOutputParser()     # modelの出力をそのまま出す
)

chain.invoke("アイスクリーム")

chain.invoke("アイスクリーム", config={"model": "openai"})

chain.invoke("アイスクリーム",config={"model": "anthropic"})

chain.invoke("アイスクリーム", config=({"model": "hogehoge"}))

chain.with_config(configurable={"model": "openai"}).invoke("アイスクリーム")

chain.with_config(configurable={"model": "anthropic"}).invoke("アイスクリーム")

chain.with_config(configurable={"model": "hogehoge"}).invoke("アイスクリーム")

from langchain_core.runnables import RunnableConfig

chain.invoke("アイスクリーム",config=RunnableConfig(configurable={"model": "anthropic"}))

(snip)

model = (
    chat_openai
    .with_fallbacks([anthropic])     # ここ
    .configurable_alternatives(
        ConfigurableField(id="model"),
        default_key="chat_openai",
        openai=openai,
        anthropic=anthropic,
    )
)

(snip)

!pip install --upgrade --quiet langchain-core langchain-openai langchain-community
!pip freeze | grep -i langchain

langchain-community==0.0.32
langchain-core==0.1.41
langchain-openai==0.1.2

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

model = ChatOpenAI()
prompt = ChatPromptTemplate.from_template("{topic}についてのジョークを1つ考えて。")
chain = prompt

chain.input_schema.schema()

{
    'title': 'PromptInput',
    'type': 'object',
    'properties': {
        'topic': {
            'title': 'Topic',
            'type': 'string'
        }
    }
}

chain.output_schema.schema()

{
    'title': 'ChatOpenAIOutput',
    'anyOf': [
        {
            '$ref': '#/definitions/AIMessage'
        },
        {
            '$ref': '#/definitions/HumanMessage'
        },
        {
            '$ref': '#/definitions/ChatMessage'
        },
        {
            '$ref': '#/definitions/SystemMessage'
        },
        {
            '$ref': '#/definitions/FunctionMessage'
        },
        {
            '$ref': '#/definitions/ToolMessage'
        }
    ],
    'definitions': {
        'AIMessage': {
            'title': 'AIMessage',
            'description': 'Message from an AI.',
            'type': 'object',
            'properties': {
                'content': {
                    'title': 'Content',
                    'anyOf': [
                        {
                            'type': 'string'
                        },
                        {
                            'type': 'array',
                            'items': {
                                'anyOf': [
                                    {
                                        'type': 'string'
                                    },
                                    {
                                        'type': 'object'
                                    }
                                ]
                            }
                        }
                    ]
                },
                'additional_kwargs': {
                    'title': 'Additional Kwargs',
                    'type': 'object'
                },
                'response_metadata': {
                    'title': 'Response Metadata',
                    'type': 'object'
                },
                'type': {
                    'title': 'Type',
                    'default': 'ai',
                    'enum': [
                        'ai'
                    ],
                    'type': 'string'
                },
                'name': {
                    'title': 'Name',
                    'type': 'string'
                },
                'id': {
                    'title': 'Id',
                    'type': 'string'
                },
                'example': {
                    'title': 'Example',
                    'default': False,
                    'type': 'boolean'
                }
            },
            'required': [
                'content'
            ]
        },
        'HumanMessage': {
            'title': 'HumanMessage',
            'description': 'Message from a human.',
            'type': 'object',
            'properties': {
                'content': {
                    'title': 'Content',
                    'anyOf': [
                        {
                            'type': 'string'
                        },
                        {
                            'type': 'array',
                            'items': {
                                'anyOf': [
                                    {
                                        'type': 'string'
                                    },
                                    {
                                        'type': 'object'
                                    }
                                ]
                            }
                        }
                    ]
                },
                'additional_kwargs': {
                    'title': 'Additional Kwargs',
                    'type': 'object'
                },
                'response_metadata': {
                    'title': 'Response Metadata',
                    'type': 'object'
                },
                'type': {
                    'title': 'Type',
                    'default': 'human',
                    'enum': [
                        'human'
                    ],
                    'type': 'string'
                },
                'name': {
                    'title': 'Name',
                    'type': 'string'
                },
                'id': {
                    'title': 'Id',
                    'type': 'string'
                },
                'example': {
                    'title': 'Example',
                    'default': False,
                    'type': 'boolean'
                }
            },
            'required': [
                'content'
            ]
        },
        'ChatMessage': {
            'title': 'ChatMessage',
            'description': 'Message that can be assigned an arbitrary speaker (i.e. role).',
            'type': 'object',
            'properties': {
                'content': {
                    'title': 'Content',
                    'anyOf': [
                        {
                            'type': 'string'
                        },
                        {
                            'type': 'array',
                            'items': {
                                'anyOf': [
                                    {
                                        'type': 'string'
                                    },
                                    {
                                        'type': 'object'
                                    }
                                ]
                            }
                        }
                    ]
                },
                'additional_kwargs': {
                    'title': 'Additional Kwargs',
                    'type': 'object'
                },
                'response_metadata': {
                    'title': 'Response Metadata',
                    'type': 'object'
                },
                'type': {
                    'title': 'Type',
                    'default': 'chat',
                    'enum': [
                        'chat'
                    ],
                    'type': 'string'
                },
                'name': {
                    'title': 'Name',
                    'type': 'string'
                },
                'id': {
                    'title': 'Id',
                    'type': 'string'
                },
                'role': {
                    'title': 'Role',
                    'type': 'string'
                }
            },
            'required': [
                'content',
                'role'
            ]
        },
        'SystemMessage': {
            'title': 'SystemMessage',
            'description': 'Message for priming AI behavior, usually passed in as the first of a sequence\nof input messages.',
            'type': 'object',
            'properties': {
                'content': {
                    'title': 'Content',
                    'anyOf': [
                        {
                            'type': 'string'
                        },
                        {
                            'type': 'array',
                            'items': {
                                'anyOf': [
                                    {
                                        'type': 'string'
                                    },
                                    {
                                        'type': 'object'
                                    }
                                ]
                            }
                        }
                    ]
                },
                'additional_kwargs': {
                    'title': 'Additional Kwargs',
                    'type': 'object'
                },
                'response_metadata': {
                    'title': 'Response Metadata',
                    'type': 'object'
                },
                'type': {
                    'title': 'Type',
                    'default': 'system',
                    'enum': [
                        'system'
                    ],
                    'type': 'string'
                },
                'name': {
                    'title': 'Name',
                    'type': 'string'
                },
                'id': {
                    'title': 'Id',
                    'type': 'string'
                }
            },
            'required': [
                'content'
            ]
        },
        'FunctionMessage': {
            'title': 'FunctionMessage',
            'description': 'Message for passing the result of executing a function back to a model.',
            'type': 'object',
            'properties': {
                'content': {
                    'title': 'Content',
                    'anyOf': [
                        {
                            'type': 'string'
                        },
                        {
                            'type': 'array',
                            'items': {
                                'anyOf': [
                                    {
                                        'type': 'string'
                                    },
                                    {
                                        'type': 'object'
                                    }
                                ]
                            }
                        }
                    ]
                },
                'additional_kwargs': {
                    'title': 'Additional Kwargs',
                    'type': 'object'
                },
                'response_metadata': {
                    'title': 'Response Metadata',
                    'type': 'object'
                },
                'type': {
                    'title': 'Type',
                    'default': 'function',
                    'enum': [
                        'function'
                    ],
                    'type': 'string'
                },
                'name': {
                    'title': 'Name',
                    'type': 'string'
                },
                'id': {
                    'title': 'Id',
                    'type': 'string'
                }
            },
            'required': [
                'content',
                'name'
            ]
        },
        'ToolMessage': {
            'title': 'ToolMessage',
            'description': 'Message for passing the result of executing a tool back to a model.',
            'type': 'object',
            'properties': {
                'content': {
                    'title': 'Content',
                    'anyOf': [
                        {
                            'type': 'string'
                        },
                        {
                            'type': 'array',
                            'items': {
                                'anyOf': [
                                    {
                                        'type': 'string'
                                    },
                                    {
                                        'type': 'object'
                                    }
                                ]
                            }
                        }
                    ]
                },
                'additional_kwargs': {
                    'title': 'Additional Kwargs',
                    'type': 'object'
                },
                'response_metadata': {
                    'title': 'Response Metadata',
                    'type': 'object'
                },
                'type': {
                    'title': 'Type',
                    'default': 'tool',
                    'enum': [
                        'tool'
                    ],
                    'type': 'string'
                },
                'name': {
                    'title': 'Name',
                    'type': 'string'
                },
                'id': {
                    'title': 'Id',
                    'type': 'string'
                },
                'tool_call_id': {
                    'title': 'Tool Call Id',
                    'type': 'string'
                }
            },
            'required': [
                'content',
                'tool_call_id'
            ]
        }
    }
}

prompt.input_schema.schema()

{
    'title': 'PromptInput',
    'type': 'object',
    'properties': {
        'topic': {
            'title': 'Topic',
            'type': 'string'
        }
    }
}

!pip install -q faiss-cpu

from langchain_community.vectorstores import FAISS
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_openai import OpenAIEmbeddings


template = """\
以下の文脈のみに基づいて質問に回答して下さい:
{context}

質問: {question}
回答: \
"""
prompt = ChatPromptTemplate.from_template(template)

doc = """\
オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。
主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。\
"""

vectorstore = FAISS.from_texts(
    [doc], embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever()

model = ChatOpenAI()

retrieval_chain = (
    {
        "context": retriever.with_config(run_name="Docs"),
        "question": RunnablePassthrough(),
    }
    | prompt
    | model.with_config(run_name="my_llm")
    | StrOutputParser()
)

async for event in retrieval_chain.astream_events(
    "オグリキャップの主な勝ち鞍は？", version="v1", include_names=["Docs", "my_llm"]
):
    kind = event["event"]
    print(f"----- {kind} ----")
    if kind == "on_chat_model_stream":
        print(event["data"]["chunk"].content, end="\n")
    elif kind in {"on_chat_model_start"}:
        print("Start Streaming LLM:")
    elif kind in {"on_chat_model_end"}:
        print("Done streaming LLM.")
    elif kind == "on_retriever_end":
        print("--")
        print("Retrieved the following documents:")
        print(event["data"]["output"]["documents"])
    elif kind == "on_tool_end":
        print(f"Ended tool: {event['name']}")
    else:
        pass

----- on_retriever_start ----
----- on_retriever_end ----
--
Retrieved the following documents:
[Document(page_content='オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。\n主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。')]
----- on_chat_model_start ----
Start Streaming LLM:
----- on_chat_model_stream ----

----- on_chat_model_stream ----
198
----- on_chat_model_stream ----
8
----- on_chat_model_stream ----
年
----- on_chat_model_stream ----
・
----- on_chat_model_stream ----
199
----- on_chat_model_stream ----
0
----- on_chat_model_stream ----
年
----- on_chat_model_stream ----
の
----- on_chat_model_stream ----
有
----- on_chat_model_stream ----
馬
----- on_chat_model_stream ----
記
----- on_chat_model_stream ----
念
----- on_chat_model_stream ----
、
----- on_chat_model_stream ----
198
----- on_chat_model_stream ----
9
----- on_chat_model_stream ----
年
----- on_chat_model_stream ----
の
----- on_chat_model_stream ----
マ
----- on_chat_model_stream ----
イ
----- on_chat_model_stream ----
ル
----- on_chat_model_stream ----
チ
----- on_chat_model_stream ----
ャ
----- on_chat_model_stream ----
ン
----- on_chat_model_stream ----
ピ
----- on_chat_model_stream ----
オ
----- on_chat_model_stream ----
ン
----- on_chat_model_stream ----
シ
----- on_chat_model_stream ----
ッ
----- on_chat_model_stream ----
プ
----- on_chat_model_stream ----
、
----- on_chat_model_stream ----
199
----- on_chat_model_stream ----
0
----- on_chat_model_stream ----
年
----- on_chat_model_stream ----
の
----- on_chat_model_stream ----
安
----- on_chat_model_stream ----
田
----- on_chat_model_stream ----
記
----- on_chat_model_stream ----
念
----- on_chat_model_stream ----

----- on_chat_model_end ----
Done streaming LLM.

async for chunk in retrieval_chain.astream_log(
    "オグリキャップの主な勝ち鞍は？", include_names=["Docs"]
):
    print("-" * 40)
    print(chunk)

----------------------------------------
RunLogPatch({'op': 'replace',
  'path': '',
  'value': {'final_output': None,
            'id': '298f2298-70ea-4993-a5a1-f059c4f8eca8',
            'logs': {},
            'name': 'RunnableSequence',
            'streamed_output': [],
            'type': 'chain'}})
----------------------------------------
RunLogPatch({'op': 'add',
  'path': '/logs/Docs',
  'value': {'end_time': None,
            'final_output': None,
            'id': '3184e2a9-2381-471e-a2e3-b12cb8b9ab1d',
            'metadata': {},
            'name': 'Docs',
            'start_time': '2024-04-11T18:55:03.668+00:00',
            'streamed_output': [],
            'streamed_output_str': [],
            'tags': ['map:key:context', 'FAISS', 'OpenAIEmbeddings'],
            'type': 'retriever'}})
----------------------------------------
RunLogPatch({'op': 'add',
  'path': '/logs/Docs/final_output',
  'value': {'documents': [Document(page_content='オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。\n主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。')]}},
 {'op': 'add',
  'path': '/logs/Docs/end_time',
  'value': '2024-04-11T18:55:03.991+00:00'})
----------------------------------------
RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ''},
 {'op': 'replace', 'path': '/final_output', 'value': ''})
----------------------------------------
RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '198'},
 {'op': 'replace', 'path': '/final_output', 'value': '198'})
----------------------------------------
RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '8'},
 {'op': 'replace', 'path': '/final_output', 'value': '1988'})
----------------------------------------
RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '年'},
 {'op': 'replace', 'path': '/final_output', 'value': '1988年'})
----------------------------------------
RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '・'},
 {'op': 'replace', 'path': '/final_output', 'value': '1988年・'})
----------------------------------------
RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '199'},
 {'op': 'replace', 'path': '/final_output', 'value': '1988年・199'})
----------------------------------------
RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '0'},
 {'op': 'replace', 'path': '/final_output', 'value': '1988年・1990'})
----------------------------------------
RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '年'},
 {'op': 'replace', 'path': '/final_output', 'value': '1988年・1990年'})
----------------------------------------
RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'の'},
 {'op': 'replace', 'path': '/final_output', 'value': '1988年・1990年の'})
----------------------------------------
RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '有'},
 {'op': 'replace', 'path': '/final_output', 'value': '1988年・1990年の有'})
----------------------------------------
RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '馬'},
 {'op': 'replace', 'path': '/final_output', 'value': '1988年・1990年の有馬'})
----------------------------------------
RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '記'},
 {'op': 'replace', 'path': '/final_output', 'value': '1988年・1990年の有馬記'})
----------------------------------------
RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '念'},
 {'op': 'replace', 'path': '/final_output', 'value': '1988年・1990年の有馬記念'})
(snip)

async for chunk in retrieval_chain.astream_log(
    "オグリキャップの主な勝ち鞍は？", include_names=["Docs"], diff=False
):
    print("-" * 70)
    print(chunk)

----------------------------------------------------------------------
RunLog({'final_output': None,
 'id': '0f08bd20-8065-4038-81dc-75d42fb2f039',
 'logs': {},
 'name': 'RunnableSequence',
 'streamed_output': [],
 'type': 'chain'})
----------------------------------------------------------------------
RunLog({'final_output': None,
 'id': '0f08bd20-8065-4038-81dc-75d42fb2f039',
 'logs': {'Docs': {'end_time': None,
                   'final_output': None,
                   'id': '7f66132d-e3da-43c5-a8c6-e4dbb29d0305',
                   'metadata': {},
                   'name': 'Docs',
                   'start_time': '2024-04-11T18:58:33.186+00:00',
                   'streamed_output': [],
                   'streamed_output_str': [],
                   'tags': ['map:key:context', 'FAISS', 'OpenAIEmbeddings'],
                   'type': 'retriever'}},
 'name': 'RunnableSequence',
 'streamed_output': [],
 'type': 'chain'})
----------------------------------------------------------------------
RunLog({'final_output': None,
 'id': '0f08bd20-8065-4038-81dc-75d42fb2f039',
 'logs': {'Docs': {'end_time': '2024-04-11T18:58:33.401+00:00',
                   'final_output': {'documents': [Document(page_content='オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。\n主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。')]},
                   'id': '7f66132d-e3da-43c5-a8c6-e4dbb29d0305',
                   'metadata': {},
                   'name': 'Docs',
                   'start_time': '2024-04-11T18:58:33.186+00:00',
                   'streamed_output': [],
                   'streamed_output_str': [],
                   'tags': ['map:key:context', 'FAISS', 'OpenAIEmbeddings'],
                   'type': 'retriever'}},
 'name': 'RunnableSequence',
 'streamed_output': [],
 'type': 'chain'})
----------------------------------------------------------------------
RunLog({'final_output': '',
 'id': '0f08bd20-8065-4038-81dc-75d42fb2f039',
 'logs': {'Docs': {'end_time': '2024-04-11T18:58:33.401+00:00',
                   'final_output': {'documents': [Document(page_content='オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。\n主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。')]},
                   'id': '7f66132d-e3da-43c5-a8c6-e4dbb29d0305',
                   'metadata': {},
                   'name': 'Docs',
                   'start_time': '2024-04-11T18:58:33.186+00:00',
                   'streamed_output': [],
                   'streamed_output_str': [],
                   'tags': ['map:key:context', 'FAISS', 'OpenAIEmbeddings'],
                   'type': 'retriever'}},
 'name': 'RunnableSequence',
 'streamed_output': [''],
 'type': 'chain'})
----------------------------------------------------------------------
RunLog({'final_output': '198',
 'id': '0f08bd20-8065-4038-81dc-75d42fb2f039',
 'logs': {'Docs': {'end_time': '2024-04-11T18:58:33.401+00:00',
                   'final_output': {'documents': [Document(page_content='オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。\n主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。')]},
                   'id': '7f66132d-e3da-43c5-a8c6-e4dbb29d0305',
                   'metadata': {},
                   'name': 'Docs',
                   'start_time': '2024-04-11T18:58:33.186+00:00',
                   'streamed_output': [],
                   'streamed_output_str': [],
                   'tags': ['map:key:context', 'FAISS', 'OpenAIEmbeddings'],
                   'type': 'retriever'}},
 'name': 'RunnableSequence',
 'streamed_output': ['', '198'],
 'type': 'chain'})
----------------------------------------------------------------------
RunLog({'final_output': '1988',
 'id': '0f08bd20-8065-4038-81dc-75d42fb2f039',
 'logs': {'Docs': {'end_time': '2024-04-11T18:58:33.401+00:00',
                   'final_output': {'documents': [Document(page_content='オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。\n主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。')]},
                   'id': '7f66132d-e3da-43c5-a8c6-e4dbb29d0305',
                   'metadata': {},
                   'name': 'Docs',
                   'start_time': '2024-04-11T18:58:33.186+00:00',
                   'streamed_output': [],
                   'streamed_output_str': [],
                   'tags': ['map:key:context', 'FAISS', 'OpenAIEmbeddings'],
                   'type': 'retriever'}},
 'name': 'RunnableSequence',
 'streamed_output': ['', '198', '8'],
 'type': 'chain'})
----------------------------------------------------------------------
RunLog({'final_output': '1988年',
 'id': '0f08bd20-8065-4038-81dc-75d42fb2f039',
 'logs': {'Docs': {'end_time': '2024-04-11T18:58:33.401+00:00',
                   'final_output': {'documents': [Document(page_content='オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。\n主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。')]},
                   'id': '7f66132d-e3da-43c5-a8c6-e4dbb29d0305',
                   'metadata': {},
                   'name': 'Docs',
                   'start_time': '2024-04-11T18:58:33.186+00:00',
                   'streamed_output': [],
                   'streamed_output_str': [],
                   'tags': ['map:key:context', 'FAISS', 'OpenAIEmbeddings'],
                   'type': 'retriever'}},
 'name': 'RunnableSequence',
 'streamed_output': ['', '198', '8', '年'],
 'type': 'chain'})
----------------------------------------------------------------------
RunLog({'final_output': '1988年・',
 'id': '0f08bd20-8065-4038-81dc-75d42fb2f039',
 'logs': {'Docs': {'end_time': '2024-04-11T18:58:33.401+00:00',
                   'final_output': {'documents': [Document(page_content='オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。\n主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。')]},
                   'id': '7f66132d-e3da-43c5-a8c6-e4dbb29d0305',
                   'metadata': {},
                   'name': 'Docs',
                   'start_time': '2024-04-11T18:58:33.186+00:00',
                   'streamed_output': [],
                   'streamed_output_str': [],
                   'tags': ['map:key:context', 'FAISS', 'OpenAIEmbeddings'],
                   'type': 'retriever'}},
 'name': 'RunnableSequence',
 'streamed_output': ['', '198', '8', '年', '・'],
 'type': 'chain'})
----------------------------------------------------------------------
RunLog({'final_output': '1988年・199',
 'id': '0f08bd20-8065-4038-81dc-75d42fb2f039',
 'logs': {'Docs': {'end_time': '2024-04-11T18:58:33.401+00:00',
                   'final_output': {'documents': [Document(page_content='オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。\n主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。')]},
                   'id': '7f66132d-e3da-43c5-a8c6-e4dbb29d0305',
                   'metadata': {},
                   'name': 'Docs',
                   'start_time': '2024-04-11T18:58:33.186+00:00',
                   'streamed_output': [],
                   'streamed_output_str': [],
                   'tags': ['map:key:context', 'FAISS', 'OpenAIEmbeddings'],
                   'type': 'retriever'}},
 'name': 'RunnableSequence',
 'streamed_output': ['', '198', '8', '年', '・', '199'],
 'type': 'chain'})
(snip)

from langchain_core.runnables import RunnableParallel
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

model = ChatOpenAI()

chain1 = ChatPromptTemplate.from_template("{topic}に付いてのジョークを1つ考えて") | model
chain2 = (
    ChatPromptTemplate.from_template("{topic}についての短い（2行）の詩を書いて") | model
)
combined = RunnableParallel(joke=chain1, poem=chain2)

%%time
chain1.invoke({"topic": "アイスクリーム"})

CPU times: user 41.4 ms, sys: 813 µs, total: 42.3 ms
Wall time: 852 ms
AIMessage(content='アイスクリームは、冷たくても心は温かい！', response_metadata={'token_usage': {'completion_tokens': 22, 'prompt_tokens': 29, 'total_tokens': 51}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-f5f4f8e1-ce7a-4f01-9848-12a028050613-0')

%%time
chain2.invoke({"topic": "アイスクリーム"})

CPU times: user 23.7 ms, sys: 1.21 ms, total: 24.9 ms
Wall time: 789 ms
AIMessage(content='夏の日に\n冷たい甘味\u3000幸せ溶ける', response_metadata={'token_usage': {'completion_tokens': 22, 'prompt_tokens': 35, 'total_tokens': 57}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-663fac17-393d-4c5d-afec-7eb952cba783-0')

%%time
combined.invoke({"topic": "アイスクリーム"})

CPU times: user 42.1 ms, sys: 7.17 ms, total: 49.3 ms
Wall time: 886 ms
{'joke': AIMessage(content='アイスクリームが嫌いな人は、クールな人とは言えないよ！', response_metadata={'token_usage': {'completion_tokens': 28, 'prompt_tokens': 29, 'total_tokens': 57}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-3b73e12b-0abb-4698-86d0-df1737eb5711-0'),
 'poem': AIMessage(content='冷たい舌で溶ける\n甘い夢を追いかける', response_metadata={'token_usage': {'completion_tokens': 24, 'prompt_tokens': 35, 'total_tokens': 59}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-49d5c600-d60b-4322-8426-f67ea7cda82b-0')}

%%time
chain1.batch([{"topic": "アイスクリーム"}, {"topic": "チョコレート"}])

CPU times: user 62.5 ms, sys: 11.7 ms, total: 74.2 ms
Wall time: 1.32 s
[AIMessage(content='なぜアイスクリームはいつも冷たいままなのか？なぜなら、溶けるとクリームのようになってしまうからだ！', response_metadata={'token_usage': {'completion_tokens': 51, 'prompt_tokens': 29, 'total_tokens': 80}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-088aec9b-c2a0-4071-ae1c-6e63a327894d-0'),
 AIMessage(content='Why did the chocolate go to the doctor?\n\nBecause it was feeling fudged up!', response_metadata={'token_usage': {'completion_tokens': 18, 'prompt_tokens': 27, 'total_tokens': 45}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-e00fd48a-a6e7-459c-9382-aedc4def7e1b-0')]

%%time
chain2.batch([{"topic": "アイスクリーム"}, {"topic": "チョコレート"}])

CPU times: user 42 ms, sys: 5.1 ms, total: 47.1 ms
Wall time: 945 ms
[AIMessage(content='甘い氷、口の中で溶ける\n夏の日を彩る至福のひととき', response_metadata={'token_usage': {'completion_tokens': 32, 'prompt_tokens': 35, 'total_tokens': 67}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-b36a1746-4a19-4fe6-9b40-b04fb2a844f9-0'),
 AIMessage(content='甘く溶ける\n口の中で幸せ満ちる', response_metadata={'token_usage': {'completion_tokens': 19, 'prompt_tokens': 33, 'total_tokens': 52}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-24975d44-0bc9-437f-8968-08e74fc28d54-0')]

%%time
combined.batch([{"topic": "アイスクリーム"}, {"topic": "チョコレート"}])

CPU times: user 79.6 ms, sys: 5.77 ms, total: 85.3 ms
Wall time: 1.13 s
[{'joke': AIMessage(content='アイスクリームがビジネスマンになったら、毎日が忙しくてバニランドに行く時間もないかもしれない！', response_metadata={'token_usage': {'completion_tokens': 49, 'prompt_tokens': 29, 'total_tokens': 78}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-7502d217-583d-49d7-ac60-968e54b5edc0-0'),
  'poem': AIMessage(content='甘い冷たさ\n夏の日を涼む', response_metadata={'token_usage': {'completion_tokens': 17, 'prompt_tokens': 35, 'total_tokens': 52}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-426e420c-4d29-438f-9365-36304d85c016-0')},
 {'joke': AIMessage(content="Why did the chocolate go to the therapist?\n\nBecause it just couldn't seem to break out of its shell!", response_metadata={'token_usage': {'completion_tokens': 22, 'prompt_tokens': 27, 'total_tokens': 49}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-36569f97-42e2-47fb-9c40-37fae271b29c-0'),
  'poem': AIMessage(content='甘い誘惑\n口溶けの魔法', response_metadata={'token_usage': {'completion_tokens': 17, 'prompt_tokens': 33, 'total_tokens': 50}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-44b12f98-72c2-4202-8d91-c98789deb238-0')}]

!pip install --upgrade --quiet langchain-core langchain-openai
!pip freeze | grep -i langchain

langchain-core==0.1.42
langchain-openai==0.1.3

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

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

model = ChatOpenAI()
prompt = ChatPromptTemplate.from_template("{topic}についてのジョークを1つ考えて。")
chain = prompt | model | StrOutputParser()

chain.invoke({"topic": "アイスクリーム"})

print(type(chain))

<class 'langchain_core.runnables.base.RunnableSequence'>

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

model = ChatOpenAI()
prompt = ChatPromptTemplate.from_template("{topic}についてのジョークを1つ考えて。")

chain = (
    prompt
    | model
    | StrOutputParser()
)

analysis_prompt = ChatPromptTemplate.from_template("このジョークは笑えるどうかを説明して: {joke}")

composed_chain = (
    {"joke": chain}
    | analysis_prompt
    | model
    | StrOutputParser()
)

async for event in composed_chain.astream_events(
    {"topic": "アイスクリーム"}, version="v1"
):
    kind = event["event"]
    if kind == "on_chat_model_stream":
        print(event["data"]["chunk"].content, end="")
    elif kind in {"on_chat_model_start"}:
        print()
        print("Start LLM:")
    elif kind in {"on_chat_model_end"}:
        print()
        print("End LLM")
        print()
    elif kind in {"on_prompt_start"}:
        print("Start Prompt:")
        print(event["data"])
        print()
    elif kind in {"on_prompt_end"}:
        print("End prompt")
        print(event["data"]["output"].to_messages())
    else:
        pass

Start Prompt:
{'input': {'topic': 'アイスクリーム'}}

End prompt
[HumanMessage(content='アイスクリームについてのジョークを1つ考えて。')]

Start LLM:
なぜアイスクリームはいつも冷たいのか？　なぜなら、熱いと「アイス、アイス、走れ！」から始まるからだ！
End LLM

Start Prompt:
{'input': {'joke': 'なぜアイスクリームはいつも冷たいのか？\u3000なぜなら、熱いと「アイス、アイス、走れ！」から始まるからだ！'}}

End prompt
[HumanMessage(content='このジョークは笑えるどうかを説明して: なぜアイスクリームはいつも冷たいのか？\u3000なぜなら、熱いと「アイス、アイス、走れ！」から始まるからだ！')]

Start LLM:
このジョークは、アイスクリームがいつも冷たい理由を、アイスクリーム自体に対して人間の感情や行動を重ねて面白おかしく表現している点が笑いを誘う要素です。通常、アイスクリームが冷たいのはその性質によるものですが、ここではそれを熱いという感情や行動に例えて、意外性とユーモアを持って表現しています。そのため、聞いた人が予想外の展開に笑いがこみ上げるでしょう。
End LLM

composed_chain_with_lambda = (
    chain
    | (lambda input: {"joke": input})
    | analysis_prompt
    | model
    | StrOutputParser()
)

composed_chain_with_lambda.invoke({"topic": "アイスクリーム"})

composed_chain_with_pipe = (
    chain
    .pipe((lambda input: {"joke": input}))
    .pipe(analysis_prompt)
    .pipe(model)
    .pipe(StrOutputParser())
)

composed_chain_with_pipe.invoke({"topic": "アイスクリーム"})

!pip install --upgrade --quiet langchain-core langchain-openai langchain_community faiss-cpu
!pip freeze | grep -i langchain

langchain-community==0.0.32
langchain-core==0.1.42
langchain-openai==0.1.3

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

texts = []
texts.append("""\
イクイノックス（欧字名:Equinox、2019年3月23日 - ）は、日本の競走馬・種牡馬。
主な勝ち鞍は、2022年・2023年の天皇賞（秋）連覇、2022年の有馬記念、2023年のドバイシーマクラシック、宝塚記念、ジャパンカップ。\
""")
texts.append("""\
オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。
主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。\
""")
texts.append("""\
ドウデュース（欧字名:Do Deuce、2019年5月7日 - ）は、日本の競走馬。
主な勝ち鞍は、2021年の朝日杯フューチュリティステークス、2022年の東京優駿、2023年の有馬記念。\
""")

from langchain_community.vectorstores import FAISS
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI, OpenAIEmbeddings

vectorstore = FAISS.from_texts(
    texts, embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever()
template = """\
以下のコンテキストにもとづいて、質問に答えてください:
{context}

質問: {question}
回答: \
"""
prompt = ChatPromptTemplate.from_template(template)

model = ChatOpenAI()

retrieval_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | model
    | StrOutputParser()
)

retrieval_chain.invoke("イクイノックスの生年月日は？")

retrieval_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | model
    | StrOutputParser()
)

retrieval_chain = (
    RunnableParallel({"context": retriever, "question": RunnablePassthrough()})
    | prompt
    | model
    | StrOutputParser()
)

retrieval_chain = (
    RunnableParallel(context=retriever, question=RunnablePassthrough())
    | prompt
    | model
    | StrOutputParser()
)

from operator import itemgetter

from langchain_community.vectorstores import FAISS
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI, OpenAIEmbeddings

vectorstore = FAISS.from_texts(
    texts, embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever()

template = """\
以下のコンテキストにもとづいて、質問に答えてください:
{context}

質問: {question}
回答に使用する言語: {language}
回答: \
"""
prompt = ChatPromptTemplate.from_template(template)

chain = (
    {
        "context": itemgetter("question") | retriever,
        "question": itemgetter("question"),
        "language": itemgetter("language"),
    }
    | prompt
    | model
    | StrOutputParser()
)

chain.invoke({"question": "イクイノックスの主な勝ち鞍は？", "language":"スペイン語"})

!pip install --upgrade --quiet langchain-core langchain-openai
!pip freeze | grep -i langchain

langchain-core==0.1.42
langchain-openai==0.1.3

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "代数記号を使って次の方程式を書き出しそれを解きなさい。書式は以下を使用しなさい。\n\nEQUATION:...\n\nSOLUTION:...\n\n"
        ),
        (
            "human",
            "{equation_statement}"
        ),
    ]
)
model = ChatOpenAI(temperature=0)
runnable = (
    {"equation_statement": RunnablePassthrough()}
    | prompt
    | model
    | StrOutputParser()
)

print(runnable.invoke("xの3乗＋7＝12"))

runnable = (
    {"equation_statement": RunnablePassthrough()}
    | prompt
    | model.bind(stop="SOLUTION")
    | StrOutputParser()
)
print(runnable.invoke("xの3乗＋7＝12"))

function = {
    "name": "solver",
    "description": "方程式を立てて解く",
    "parameters": {
        "type": "object",
        "properties": {
            "equation": {
                "type": "string",
                "description": "方程式の代数的表現",
            },
            "solution": {
                "type": "string",
                "description": "方程式の解",
            },
        },
        "required": ["equation", "solution"],
    },
}

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "代数記号を使って次の方程式を書き出し、それを解きなさい。",
        ),
        ("human", "{equation_statement}"),
    ]
)

model = ChatOpenAI(model="gpt-4-turbo-2024-04-09", temperature=0).bind(
    function_call={"name": "solver"}, functions=[function]
)

runnable = (
    {"equation_statement": RunnablePassthrough()}
    | prompt
    | model
)
print(runnable.invoke("xの3乗＋7＝12"))

model = ChatOpenAI(model="gpt-4-turbo-2024-04-09", temperature=0)

runnable = (
    {"equation_statement": RunnablePassthrough()}
    | prompt
    | model.bind(function_call={"name": "solver"}, functions=[function])
)
print(runnable.invoke("xの3乗＋7＝12"))

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_temperature",
            "description": "指定された都市の現在の気温を取得する",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "都市名を英語で指定。例） San Francisco, Tokyo.",
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["fahrenheit", "celsius"],
                        "description": "気温の単位。ユーザの言語や位置情報から判断する。",
                    },
                },
                "required": ["location", "unit"],
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "指定された都市の現在の天気を取得する",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "都市名を英語で指定。例） San Francisco, Tokyo.",
                    },
                },
                "required": ["location"]
            }
        }
    }
]

model = ChatOpenAI(model="gpt-3.5-turbo-0125").bind(tools=tools)
response = model.invoke("サンフランシスコの天気と気温を教えて")
response.additional_kwargs["tool_calls"]

[{'id': 'call_aOjTvxAyFQgDthpqmZwkKumy',
  'function': {'arguments': '{}', 'name': 'get_current_weather'},
  'type': 'function'},
 {'id': 'call_3jNSjN9WWeAKgtJcHRBbNRKW',
  'function': {'arguments': '{"location": "San Francisco", "unit": "celsius"}',
   'name': 'get_current_temperature'},
  'type': 'function'}]

!pip install --upgrade --quiet langchain-core langchain-openai langchain-community
!pip freeze | grep -i langchain

langchain-community==0.0.32
langchain-core==0.1.42
langchain-openai==0.1.3

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

from operator import itemgetter
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableLambda
from langchain_openai import ChatOpenAI


def length_function(text):
    """ 単一の文字列の長さを返す """
    return len(text)


def _multiple_length_function(text1, text2):
    """ 2つの文字列の長さの乗を返す """
    return len(text1) * len(text2)


def multiple_length_function(_dict):
    """ _multiple_length_functionに渡すためのラッパー """
    return _multiple_length_function(_dict["text1"], _dict["text2"])


prompt = ChatPromptTemplate.from_template("{a} + {b} は？")
model = ChatOpenAI()

chain1 = prompt | model

chain = (
    {
        "a": itemgetter("foo") | RunnableLambda(length_function),
        "b": {"text1": itemgetter("foo"), "text2": itemgetter("bar")}
        | RunnableLambda(multiple_length_function),
    }
    | prompt
    | model
)

chain.invoke({"foo": "りんご", "bar": "パイナップル"})

import json
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableLambda, RunnableConfig
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser
from langchain_community.callbacks import get_openai_callback

def parse_or_fix(text: str, config: RunnableConfig):
    fixing_chain = (
        ChatPromptTemplate.from_template(
            "以下の文章を修正して下さい:\n\n```text\n{input}\n```\nError: {error}"
            "説明を入れずに、修正したデータだけを応答して下さい。"
        )
        | ChatOpenAI()
        | StrOutputParser()
    )
    for _ in range(3):
        try:
            return json.loads(text)
        except Exception as e:
            text = fixing_chain.invoke({"input": text, "error": e}, config)
    return "Failed to parse"

with get_openai_callback() as cb:
    output = RunnableLambda(parse_or_fix).invoke(
        "{foo: bar}", {"tags": ["my-tag"], "callbacks": [cb]}
    )
    print(output)   
    print(cb)

{'foo': 'bar'}
Tokens Used: 85
	Prompt Tokens: 76
	Completion Tokens: 9
Successful Requests: 1
Total Cost (USD): $0.000132

with get_openai_callback() as cb:
    output = RunnableLambda(parse_or_fix).invoke(
        "{foo: bar}"
    )
    print(output)   
    print(cb)

{'foo': 'bar'}
Tokens Used: 85
	Prompt Tokens: 76
	Completion Tokens: 9
Successful Requests: 1
Total Cost (USD): $0.000132

def parse_or_fix(text: str, config: RunnableConfig):
    fixing_chain = (
        ChatPromptTemplate.from_template(
            "以下の文章を修正して下さい:\n\n```text\n{input}\n```\nError: {error}"
            "説明を入れずに、修正したデータだけを応答して下さい。"
        )
        | ChatOpenAI()
        | StrOutputParser()
    )
    for _ in range(3):
        try:
            return json.loads(text)
        except Exception as e:
            print("DEBUG: ", config)     # ここ
            text = fixing_chain.invoke({"input": text, "error": e}, config)
    return "Failed to parse"

DEBUG:  {'tags': ['my-tag'], 'metadata': {}, 'callbacks': <langchain_core.callbacks.manager.CallbackManager object at 0x7e353636a650>, 'recursion_limit': 25}

from typing import Iterator, List
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_template(
    "Write a comma-separated list of 5 animals similar to: {animal}. Do not include numbers"
    "{animal} に似た動物を5つ、カンマ区切りで書いてください。数字は含めないでください。"
)

model = ChatOpenAI(temperature=0.0)

str_chain = prompt | model | StrOutputParser()

for chunk in str_chain.stream({"animal": "クマ"}):
    print(chunk, end="|", flush=True)

str_chain.invoke({"animal": "クマ"})

# LLMトークンのイテレータをカンマで区切られた文字列のリストに
# 分割するカスタムパーサ
def split_into_list(input: Iterator[str]) -> Iterator[List[str]]:
    # コンマが入るまで保持
    buffer = ""
    for chunk in input:
        # 現在のチャンクをバッファに追加
        buffer += chunk
        # バッファにカンマがある間
        while "," in buffer:
            # コンマでバッファを分割
            comma_index = buffer.index(",")
            # コンマより前はすべてyieldで返す
            yield [buffer[:comma_index].strip()]
            # 次回のイテレーションのための残りを保持
            buffer = buffer[comma_index + 1 :]
    # 最後のチャンクをyieldで返す
    yield [buffer.strip()]

list_chain = str_chain | split_into_list

for chunk in list_chain.stream({"animal": "クマ"}):
    print(chunk, end="|", flush=True)

list_chain.invoke({"animal": "クマ"})

async for chunk in list_chain.astream({"animal": "クマ"}):
    print(chunk, end="|", flush=True)

await list_chain.ainvoke({"animal": "クマ"})

!pip install --upgrade --quiet langchain-core langchain-openai langchain-community
!pip freeze | grep -i langchain

langchain-community==0.0.32
langchain-core==0.1.42
langchain-openai==0.1.3

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

from langchain_core.runnables import RunnableParallel, RunnablePassthrough

runnable = RunnableParallel(
    passed=RunnablePassthrough(),
    modified=lambda x: x["num"] + 1,
)

runnable.invoke({"num": 1})

!pip install --upgrade --quiet langchain-core langchain-openai langchain-community faiss-cpu
!pip freeze | grep -i langchain

langchain-community==0.0.32
langchain-core==0.1.42
langchain-openai==0.1.3

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

from langchain_core.runnables import RunnableParallel, RunnablePassthrough

runnable = RunnableParallel(
    extra=RunnablePassthrough().assign(multi=lambda x: x["num"] * 3),
    modified=lambda x: x["num"] + 1,
)

runnable.invoke({"num": 1})

from langchain_community.vectorstores import FAISS
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI, OpenAIEmbeddings

texts = []
texts.append("""\
イクイノックス（欧字名:Equinox、2019年3月23日 - ）は、日本の競走馬・種牡馬。
主な勝ち鞍は、2022年・2023年の天皇賞（秋）連覇、2022年の有馬記念、2023年のドバイシーマクラシック、宝塚記念、ジャパンカップ。\
""")
texts.append("""\
オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。
主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。\
""")
texts.append("""\
ドウデュース（欧字名:Do Deuce、2019年5月7日 - ）は、日本の競走馬。
主な勝ち鞍は、2021年の朝日杯フューチュリティステークス、2022年の東京優駿、2023年の有馬記念。\
""")

vectorstore = FAISS.from_texts(
    texts, embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever()

template = """\
以下のコンテキストにもとづいて、質問に答えてください:
{context}

質問: {question}
回答: \
"""
prompt = ChatPromptTemplate.from_template(template)

model = ChatOpenAI()

generation_chain = prompt | model | StrOutputParser()

retrieval_chain = {
    "context": retriever,
    "question": RunnablePassthrough(),
} | RunnablePassthrough.assign(output=generation_chain)

stream = retrieval_chain.stream("オグリキャップの主な勝ち鞍は？")

for chunk in stream:
    print(chunk)

{'question': 'オグリキャップの主な勝ち鞍は？'}
{'context': [Document(page_content='オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。\n主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。'), Document(page_content='イクイノックス（欧字名:Equinox、2019年3月23日 - ）は、日本の競走馬・種牡馬。\n主な勝ち鞍は、2022年・2023年の天皇賞（秋）連覇、2022年の有馬記念、2023年のドバイシーマクラシック、宝塚記念、ジャパンカップ。'), Document(page_content='ドウデュース（欧字名:Do Deuce、2019年5月7日 - ）は、日本の競走馬。\n主な勝ち鞍は、2021年の朝日杯フューチュリティステークス、2022年の東京優駿、2023年の有馬記念。')]}
{'output': ''}
{'output': '198'}
{'output': '8'}
{'output': '年'}
{'output': '・'}
{'output': '199'}
{'output': '0'}
{'output': '年'}
{'output': 'の'}
{'output': '有'}
{'output': '馬'}
{'output': '記'}
{'output': '念'}
{'output': '、'}
{'output': '198'}
{'output': '9'}
{'output': '年'}
{'output': 'の'}
{'output': 'マ'}
{'output': 'イ'}
{'output': 'ル'}
{'output': 'チ'}
{'output': 'ャ'}
{'output': 'ン'}
{'output': 'ピ'}
{'output': 'オ'}
{'output': 'ン'}
{'output': 'シ'}
{'output': 'ッ'}
{'output': 'プ'}
{'output': '、'}
{'output': '199'}
{'output': '0'}
{'output': '年'}
{'output': 'の'}
{'output': '安'}
{'output': '田'}
{'output': '記'}
{'output': '念'}
{'output': ''}

!pip install --upgrade --quiet langchain-core langchain-openai langchain-anthropic
!pip freeze | grep -i langchain

langchain-anthropic==0.1.8
langchain-core==0.1.42
langchain-openai==0.1.3

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')
os.environ['ANTHROPIC_API_KEY'] = userdata.get('ANTHROPIC_API_KEY')

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import ConfigurableField
from langchain_openai import ChatOpenAI

model = ChatOpenAI(temperature=0).configurable_fields(
    temperature=ConfigurableField(
        id="llm_temperature",
        name="LLM Temperature",
        description="The temperature of the LLM",
    )
)

model.invoke("ランダムな数字を1つ選んで。")

model.with_config(configurable={"llm_temperature": 0.9}).invoke("ランダムな数字を1つ選んで。")

prompt = ChatPromptTemplate.from_template("{x}以上のランダムな数字を1つ選んで。")
chain = prompt | model

chain.with_config(configurable={"llm_temperature": 0.9}).invoke({"x": 10})

!pip install --upgrade --quiet langchain langchainhub

from langchain.runnables.hub import HubRunnable
from langchain_core.runnables import ConfigurableField

prompt = HubRunnable("rlm/rag-prompt").configurable_fields(
    owner_repo_commit=ConfigurableField(
        id="hub_commit",
        name="Hub Commit",
        description="The Hub commit to pull from",
    )
)

prompt.invoke({"question": "foo", "context": "bar"})

prompt.with_config(configurable={"hub_commit": "rlm/rag-prompt-llama"}).invoke(
    {"question": "foo", "context": "bar"}
)

from langchain_core.prompts import ChatPromptTemplate
from langchain_anthropic import ChatAnthropic
from langchain_core.runnables import ConfigurableField
from langchain_openai import ChatOpenAI

llm = ChatAnthropic(model="claude-3-haiku-20240307", temperature=0).configurable_alternatives(
    # これはこのフィールドにidを与える。
    # 一番最後のRunnableを設定するとき、このidを使ってこのフィールドを設定することができる
    ConfigurableField(id="llm"),
    # これはデフォルトキーをセットする
    # このキーを指定すると、デフォルトのLLM（上で初期化されたChatAnthropic）が使われる
    default_key="anthropic",
    # これは新しいオプションを追加する。`openai`という名前で`ChatOpenAI()`になる
    openai=ChatOpenAI(),
    # これは新しいオプションを追加する。`gpt`という名前で`ChatOpenAI(model="gpt-4")`になる
    gpt4=ChatOpenAI(model="gpt-4"),
    # 更にオプションを追加できる
)
prompt = ChatPromptTemplate.from_template("{topic}についてのジョークを1つ考えて。")
chain = prompt | llm

chain.invoke({"topic": "クマ"})

chain.with_config(configurable={"llm": "openai"}).invoke({"topic": "クマ"})

chain.with_config(configurable={"llm": "gpt4"}).invoke({"topic": "クマ"})

llm = ChatAnthropic(model="claude-3-haiku-20240307", temperature=0)

prompt = ChatPromptTemplate.from_template(
    "{topic}についてのジョークを1つ考えて。"
).configurable_alternatives(
    ConfigurableField(id="prompt"),
    default_key="joke",
    poem=ChatPromptTemplate.from_template("{topic}についての短い詩を1つ考えて。"),
)

chain = prompt | llm

chain.invoke({"topic": "クマ"})

chain.with_config(configurable={"prompt": "poem"}).invoke({"topic": "クマ"})

from langchain_core.prompts import ChatPromptTemplate
from langchain_anthropic import ChatAnthropic
from langchain_core.runnables import ConfigurableField
from langchain_openai import ChatOpenAI

llm = ChatAnthropic(model="claude-3-haiku-20240307", temperature=0).configurable_alternatives(
    ConfigurableField(id="llm"),
    default_key="anthropic",
    openai=ChatOpenAI(),
    gpt4=ChatOpenAI(model="gpt-4"),
)

prompt = ChatPromptTemplate.from_template(
    "{topic}についてのジョークを1つ考えて。"
).configurable_alternatives(
    ConfigurableField(id="prompt"),
    default_key="joke",
    poem=ChatPromptTemplate.from_template("{topic}についての短い詩を1つ考えて。"),
)

chain = prompt | llm

chain.invoke({"topic": "クマ"})

chain.with_config(configurable={"llm": "openai", "prompt": "poem"}).invoke({"topic": "クマ"})

openai_poem = chain.with_config(configurable={"llm": "openai", "prompt": "poem"})

openai_poem.invoke({"topic": "クマ"})

!pip install --upgrade --quiet langchain langchain-core langchain-openai
!pip freeze | grep -i langchain

langchain==0.1.16
langchain-community==0.0.32
langchain-core==0.1.42
langchain-openai==0.1.3
langchain-text-splitters==0.0.1

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
memory.chat_memory.add_user_message("こんにちは！")
memory.chat_memory.add_ai_message("やあ、元気かい？")

memory.load_memory_variables({})

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory(memory_key="chat_history")
memory.chat_memory.add_user_message("こんにちは！")
memory.chat_memory.add_ai_message("やあ、元気かい？")

memory.load_memory_variables({})

memory = ConversationBufferMemory(return_messages=True)
memory.chat_memory.add_user_message("こんにちは！")
memory.chat_memory.add_ai_message("やあ、元気かい？")

memory.load_memory_variables({})

from langchain_openai import OpenAI
from langchain_core.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory

llm = OpenAI(temperature=0)  # gpt-3.5-turbo-instrct

template = """\
あなたは人間と会話をするチャットボットです。

これまでの会話:
{chat_history}
新しい人間の入力: {human_input}
回答: \
"""
prompt = PromptTemplate.from_template(template)

memory = ConversationBufferMemory(memory_key="chat_history")

conversation = LLMChain(
    llm=llm,
    prompt=prompt,
    verbose=True,
    memory=memory
)

print(conversation.predict(human_input="こんにちは。私の趣味は競馬です。"))

> Entering new LLMChain chain...
Prompt after formatting:
あなたは人間と会話をするチャットボットです。

これまでの会話:

新しい人間の入力: こんにちは。私の趣味は競馬です。
回答: 

> Finished chain.

print(conversation.predict(human_input="あれ、私の趣味ってなんでしたっけ？"))

> Entering new LLMChain chain...
Prompt after formatting:
あなたは人間と会話をするチャットボットです。

これまでの会話:
Human: こんにちは。私の趣味は競馬です。
AI: それは面白そうですね。競馬に詳しいですか？
新しい人間の入力: あれ、私の趣味ってなんでしたっけ？
回答: 

> Finished chain.

print(memory.load_memory_variables({}))

from langchain_openai import ChatOpenAI
from langchain.prompts import (
    ChatPromptTemplate,
    MessagesPlaceholder,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate,
)
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory

llm = ChatOpenAI()  # gpt-3.5-turbo

prompt = ChatPromptTemplate(
    messages=[
        SystemMessagePromptTemplate.from_template(
            "あなたは人間と会話をするチャットボットです。"
        ),
        MessagesPlaceholder(variable_name="chat_history"),
        HumanMessagePromptTemplate.from_template("{question}")
    ]
)

memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

conversation = LLMChain(
    llm=llm,
    prompt=prompt,
    verbose=True,
    memory=memory
)

conversation({"question":"こんにちは。私の趣味は競馬です。"})

> Entering new LLMChain chain...
Prompt after formatting:
System: あなたは人間と会話をするチャットボットです。
Human: こんにちは。私の趣味は競馬です。

> Finished chain.

conversation({"question":"あれ、私の趣味って何でしたっけ？"})

> Entering new LLMChain chain...
Prompt after formatting:
System: あなたは人間と会話をするチャットボットです。
Human: こんにちは。私の趣味は競馬です。
AI: こんにちは！競馬は面白い趣味ですね。競馬で好きな競走馬やレースはありますか？
Human: あれ、私の趣味って何でしたっけ？

> Finished chain.

from langchain.memory import ChatMessageHistory

history = ChatMessageHistory()

history.add_user_message("こんにちはー")
history.add_ai_message("やあ、元気かい？")
history.add_user_message("また競馬で負けちゃったよ・・・")
history.add_ai_message("あー、それは残念だね。そういう日もあるさ。")

history.messages

from pathlib import Path
import requests
import re

def replace_heading(match):
    level = len(match.group(1))
    return '#' * level + ' ' + match.group(2).strip()

wiki_titles = ["オグリキャップ"]
for title in wiki_titles:
    response = requests.get(
        "https://ja.wikipedia.org/w/api.php",
        params={
            "action": "query",
            "format": "json",
            "titles": title,
            "prop": "extracts",
            # 'exintro': True,
            "explaintext": True,
        },
    ).json()
    page = next(iter(response["query"]["pages"].values()))
    #wiki_text = f"# {title}\n\n## 概要\n\n"
    wiki_text = ""
    wiki_text += page["extract"]

    wiki_text = re.sub(r"(=+)([^=]+)\1", replace_heading, wiki_text)
    wiki_text = re.sub(r"\t+", "", wiki_text)
    wiki_text = re.sub(r"\n{3,}", "\n\n", wiki_text)
    data_path = Path("data")
    if not data_path.exists():
        Path.mkdir(data_path)

    with open(data_path / f"{title}.txt", "w") as fp:
        fp.write(wiki_text)

!pip install --upgrade --quiet langchain langchain-core langchain-openai langchain-chroma chromadb
!pip freeze | grep -i langchain

langchain==0.1.16
langchain-chroma==0.1.0
langchain-community==0.0.32
langchain-core==0.1.42
langchain-openai==0.1.3
langchain-text-splitters==0.0.1

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import CharacterTextSplitter

with open("data/オグリキャップ.txt") as f:
    state_of_the_union = f.read()
text_splitter = CharacterTextSplitter(chunk_size=400, chunk_overlap=100)
texts = text_splitter.split_text(state_of_the_union)

embeddings = OpenAIEmbeddings()

docsearch = Chroma.from_texts(
    texts, embeddings, metadatas=[{"source": i} for i in range(len(texts))]
)

query = "オグリキャップの血統について教えて。"
docs = docsearch.similarity_search(query)
docs[0]

from langchain.chains.question_answering import load_qa_chain
from langchain.memory import ConversationBufferMemory
from langchain_core.prompts import PromptTemplate
from langchain_openai import OpenAI

template = """
あなたは人間と会話するチャットボットです。

与えられた長い文書の一部抜粋と質問だけを踏まえて、最終的な回答を作成してください。
与えられた文書に根拠が記載されてない場合、架空の回答を作成せずに、わからないと答えて下さい。

{context}

{chat_history}
Human: {human_input}
Chatbot:"""

prompt = PromptTemplate(
    input_variables=["chat_history", "human_input", "context"], template=template
)

memory = ConversationBufferMemory(memory_key="chat_history", input_key="human_input")

chain = load_qa_chain(
    OpenAI(temperature=0), chain_type="stuff", memory=memory, prompt=prompt
)

query = "オグリキャップの血統について教えて。"
chain({"input_documents": docs, "human_input": query}, return_only_outputs=True)

print(memory.load_memory_variables({}))

!pip install --upgrade --quiet langchain langchain-core langchain-openai
!pip freeze | grep -i langchain

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
from langchain_openai import OpenAI

llm = OpenAI(temperature=0)

conversation = ConversationChain(
    llm=llm, verbose=True, memory=ConversationBufferMemory()
)

conversation.predict(input="こんにちは！")

> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.

Current conversation:

Human: こんにちは！
AI:

> Finished chain.

from langchain.prompts.prompt import PromptTemplate
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
from langchain_openai import OpenAI

llm = OpenAI(temperature=0)

template = """\
以下は人間とAIのフレンドリーな会話です。AIは、饒舌で、文脈から具体的な詳細をたくさん話します。
AIは、質問の答えを知らない場合、正直に「知らない」と答えます。
人間からの入力に対して回答を生成して下さい。

現在の会話:
{history}
人間: {input}
AIアシスタント: """
PROMPT = PromptTemplate(input_variables=["history", "input"], template=template)

memory = ConversationBufferMemory(ai_prefix="AIアシスタント", human_prefix="人間")

conversation = ConversationChain(
    prompt=PROMPT,
    llm=llm,
    verbose=True,
    memory=memory,
)

conversation.predict(input="こんにちは！")

> Entering new ConversationChain chain...
Prompt after formatting:
以下は人間とAIのフレンドリーな会話です。AIは、饒舌で、文脈から具体的な詳細をたくさん話します。
AIは、質問の答えを知らない場合、正直に「知らない」と答えます。
人間からの入力に対して回答を生成して下さい。

現在の会話:

人間: こんにちは！
AIアシスタント: 

> Finished chain.

print(memory.load_memory_variables({}))

memory

!pip install --upgrade --quiet langchain langchain-core langchain-openai
!pip freeze | grep -i langchain

langchain==0.1.16
langchain-community==0.0.32
langchain-core==0.1.42
langchain-openai==0.1.3
langchain-text-splitters==0.0.1

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

from langchain.chains import ConversationChain
from langchain.memory import (
    CombinedMemory,
    ConversationBufferMemory,
    ConversationSummaryMemory,
)
from langchain_core.prompts import PromptTemplate
from langchain_openai import OpenAI

conversation_memory = ConversationBufferMemory(
    memory_key="chat_history_lines", input_key="input"
)

summary_memory = ConversationSummaryMemory(llm=OpenAI(), input_key="input")

# conversation_memoryとsummary_memoryを結合
memory = CombinedMemory(memories=[conversation_memory, summary_memory])

_DEFAULT_TEMPLATE = """\
以下は人間とAIのフレンドリーな会話です。AIは、饒舌で、文脈から具体的な詳細をたくさん話します。
AIは、質問の答えを知らない場合、正直に「知らない」と答えます。
人間からの入力に対して回答を生成して下さい。

会話の要約:
{history}
原罪の会話:
{chat_history_lines}
Human: {input}
AI:"""
PROMPT = PromptTemplate(
    input_variables=["history", "input", "chat_history_lines"],
    template=_DEFAULT_TEMPLATE,
)

llm = OpenAI(temperature=0)

conversation = ConversationChain(llm=llm, verbose=True, memory=memory, prompt=PROMPT)

conversation.run("こんにちは！")

> Entering new ConversationChain chain...
Prompt after formatting:
以下は人間とAIのフレンドリーな会話です。AIは、饒舌で、文脈から具体的な詳細をたくさん話します。
AIは、質問の答えを知らない場合、正直に「知らない」と答えます。
人間からの入力に対して回答を生成して下さい。

会話の要約:

原罪の会話:

Human: こんにちは！
AI:

> Finished chain.

conversation.run("そういえば昨日は、競馬で皐月賞が行われたんですよ。")

> Entering new ConversationChain chain...
Prompt after formatting:
以下は人間とAIのフレンドリーな会話です。AIは、饒舌で、文脈から具体的な詳細をたくさん話します。
AIは、質問の答えを知らない場合、正直に「知らない」と答えます。
人間からの入力に対して回答を生成して下さい。

会話の要約:

The human greets the AI in Japanese and the AI responds with a greeting in Japanese. The AI introduces itself as an AI and asks what the human would like to talk about.
原罪の会話:
Human: こんにちは！
AI:  こんにちは！元気ですか？私はAIです。どんなお話がしたいですか？
Human: そういえば昨日は、競馬で皐月賞が行われたんですよ。
AI:

> Finished chain.

conversation.run("皐月賞は3歳牡馬のクラシックレースの第1冠ですね。")

> Entering new ConversationChain chain...
Prompt after formatting:
以下は人間とAIのフレンドリーな会話です。AIは、饒舌で、文脈から具体的な詳細をたくさん話します。
AIは、質問の答えを知らない場合、正直に「知らない」と答えます。
人間からの入力に対して回答を生成して下さい。

会話の要約:

The human greets the AI in Japanese and the AI responds with a greeting in Japanese. The AI introduces itself as an AI and asks what the human would like to talk about. The human mentions the recent horse race, "Satsuki Sho", and the AI expresses interest in learning more about it.
原罪の会話:
Human: こんにちは！
AI:  こんにちは！元気ですか？私はAIです。どんなお話がしたいですか？
Human: そういえば昨日は、競馬で皐月賞が行われたんですよ。
AI:  本当ですか？私は競馬については詳しくありませんが、皐月賞というのはどのようなレースなのでしょうか？
Human: 皐月賞は3歳牡馬のクラシックレースの第1冠ですね。
AI:

> Finished chain.

from langchain.memory import ConversationBufferWindowMemory

memory = ConversationBufferWindowMemory(k=2)
memory.save_context(
    {"input": "こんにちは！"},
    {"output": "こんにちは！元気ですか？私はAIです。どんなお話がしたいですか？"}
)
memory.save_context(
    {"input": "そういえば昨日は、競馬で皐月賞が行われたんですよ。"},
    {"output": "本当ですか？私は競馬については詳しくありませんが、皐月賞というのはどのようなレースなのでしょうか？"}
)
memory.save_context(
    {"input": "皐月賞は3歳牡馬のクラシックレースの第1冠ですね。"},
     {"output": "なるほど、興味深いですね。3歳牡馬のレースということですね。どのような馬が優勝したのでしょうか？"}
)
memory.save_context(
    {"input": "優勝したのはジャスティンミラノですね。ハイペース追走経験がないので危険な人気馬かと思ってましたが、強かったです。"},
    {"output": "ジャスティンミラノですね。興味深いです。ハイペース追走経験がないのに勝ったということですね。どのような特徴を持っているのでしょうか？"}
)

memory.load_memory_variables({})

from langchain_openai import OpenAI
from langchain.memory import ConversationEntityMemory

llm = OpenAI(temperature=0)

memory = ConversationEntityMemory(llm=llm)

_input = {"input": "先日の皐月賞はジャスティンミラノが1着でした。2着はコスモキュランダでした。"}
memory.load_memory_variables(_input)

memory.save_context(
    _input,
    {"output": "素晴らしいレースでしたね！ジャスティンミラノはどんな勝ち方でしたか？"}
)

memory.load_memory_variables({"input": 'ジャスティンミラノとは？'})

{'history': 'Human: 先日の皐月賞はジャスティンミラノが1着でした。2着はコスモキュランダでした。\nAI: 素晴らしいレースでしたね！ジャスティンミラノはどんな勝ち方でしたか？',
 'entities': {'ジャスティンミラノ': 'ジャスティンミラノは先日の皐月賞で1着になりました。'}}

from langchain.memory import ConversationKGMemory
from langchain_openai import OpenAI

llm = OpenAI(temperature=0)

memory = ConversationKGMemory(llm=llm)

memory.save_context({"input": "昨日は、競馬で皐月賞が行われたんですよ。"}, {"output": "私は競馬については詳しくありませんが、皐月賞というのはどのようなレースなのでしょうか？"})
memory.save_context({"input": "皐月賞は3歳牡馬のクラシックレースの第1冠ですね。"}, {"output": "興味深いですね。3歳牡馬のレースということですね。どのような馬が優勝したのでしょうか？"})
memory.save_context({"input": "優勝したのはジャスティンミラノですね。"}, {"output": "ジャスティンミラノですね。興味深いです。2着はどの馬だったのでしょうか？"})
memory.save_context({"input": "コスモキュランダは2着ですね。惜しかったです。"}, {"output": "そうなんですね。コスモキュランダは残念でしたね。"})

memory.load_memory_variables({"input": "皐月賞とは？"})

memory.load_memory_variables({"input": "ジャスティンミラノの着順は？"})

memory.get_current_entities("ジャスティンミラノの着順は？")

memory.get_knowledge_triplets("ジャスティンミラノの皐月賞の結果は？")

from langchain.memory import ConversationSummaryMemory, ChatMessageHistory
from langchain_openai import OpenAI

llm = OpenAI(temperature=0)

memory = ConversationSummaryMemory(llm=llm)

memory.save_context(
    {"input": "こんにちは！"},
    {"output": "こんにちは！元気ですか？私はAIです。どんなお話がしたいですか？"}
)

memory.load_memory_variables({})

from langchain.memory import ConversationSummaryMemory, ChatMessageHistory
from langchain_openai import OpenAI

llm = OpenAI(temperature=0)

memory = ConversationSummaryMemory(llm=llm)

memory.save_context(
    {"input": "こんにちは！"},
    {"output": "こんにちは！元気ですか？私はAIです。どんなお話がしたいですか？"}
)
memory.save_context(
    {"input": "そういえば昨日は、競馬で皐月賞が行われたんですよ。"},
    {"output": "本当ですか？私は競馬については詳しくありませんが、皐月賞というのはどのようなレースなのでしょうか？"}
)
memory.save_context(
    {"input": "皐月賞は3歳牡馬のクラシックレースの第1冠ですね。"},
     {"output": "なるほど、興味深いですね。3歳牡馬のレースということですね。どのような馬が優勝したのでしょうか？"}
)
memory.save_context(
    {"input": "優勝したのはジャスティンミラノですね。ハイペース追走経験がないので危険な人気馬かと思ってましたが、強かったです。"},
    {"output": "ジャスティンミラノですね。興味深いです。ハイペース追走経験がないのに勝ったということですね。どのような特徴を持っているのでしょうか？"}
)

memory.load_memory_variables({})

from langchain.memory import ConversationSummaryBufferMemory
from langchain_openai import OpenAI

llm = OpenAI()

memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=200)
memory.save_context(
    {"input": "こんにちは！"},
    {"output": "こんにちは！元気ですか？私はAIです。どんなお話がしたいですか？"}
)
memory.save_context(
    {"input": "そういえば昨日は、競馬で皐月賞が行われたんですよ。"},
    {"output": "本当ですか？私は競馬については詳しくありませんが、皐月賞というのはどのようなレースなのでしょうか？"}
)
memory.save_context(
    {"input": "皐月賞は3歳牡馬のクラシックレースの第1冠ですね。"},
     {"output": "なるほど、興味深いですね。3歳牡馬のレースということですね。どのような馬が優勝したのでしょうか？"}
)
memory.save_context(
    {"input": "優勝したのはジャスティンミラノですね。ハイペース追走経験がないので危険な人気馬かと思ってましたが、強かったです。"},
    {"output": "ジャスティンミラノですね。興味深いです。ハイペース追走経験がないのに勝ったということですね。どのような特徴を持っているのでしょうか？"}
)

memory.load_memory_variables({})

print(memory.chat_memory.messages)
print()
print(memory.moving_summary_buffer)

messages = memory.chat_memory.messages
previous_summary = memory.moving_summary_buffer
memory.predict_new_summary(messages, previous_summary)

from langchain.memory import ConversationTokenBufferMemory
from langchain_openai import OpenAI

llm = OpenAI()

memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=200)

memory.save_context(
    {"input": "こんにちは！"},
    {"output": "こんにちは！元気ですか？私はAIです。どんなお話がしたいですか？"}
)
memory.save_context(
    {"input": "そういえば昨日は、競馬で皐月賞が行われたんですよ。"},
    {"output": "本当ですか？私は競馬については詳しくありませんが、皐月賞というのはどのようなレースなのでしょうか？"}
)
memory.save_context(
    {"input": "皐月賞は3歳牡馬のクラシックレースの第1冠ですね。"},
     {"output": "なるほど、興味深いですね。3歳牡馬のレースということですね。どのような馬が優勝したのでしょうか？"}
)
memory.save_context(
    {"input": "優勝したのはジャスティンミラノですね。ハイペース追走経験がないので危険な人気馬かと思ってましたが、強かったです。"},
    {"output": "ジャスティンミラノですね。興味深いです。ハイペース追走経験がないのに勝ったということですね。どのような特徴を持っているのでしょうか？"}
)

memory.load_memory_variables({})

!pip install --upgrade --quiet langchain-core langchain-openai langchain_community
!pip freeze | grep -i langchain

langchain-community==0.0.32
langchain-core==0.1.42
langchain-openai==0.1.3

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai.chat_models import ChatOpenAI

model = ChatOpenAI(model="gpt-3.5-turbo")

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "あなたは{ability}が得意な大阪のおばちゃんです。20字以内で簡潔、かつ大阪弁で元気に明るく回答します。",
        ),
        MessagesPlaceholder(variable_name="history"),
        ("human", "{input}"),
    ]
)

runnable = prompt | model

from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

store = {}

def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

with_message_history = RunnableWithMessageHistory(
    runnable,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history",
)

with_message_history.invoke(
    {"ability": "数学", "input": "コサインってどういう意味？"},
    config={"configurable": {"session_id": "abc123"}},
)

with_message_history.invoke(
    {"ability": "数学", "input": "なんて？？？"},
    config={"configurable": {"session_id": "abc123"}},
)

with_message_history.invoke(
    {"ability": "数学", "input": "なんて？？？"},
    config={"configurable": {"session_id": "def234"}},
)

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai.chat_models import ChatOpenAI
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.runnables import ConfigurableFieldSpec


model = ChatOpenAI(model="gpt-3.5-turbo")

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "あなたは{ability}が得意な大阪のおばちゃんです。20字以内で簡潔、かつ大阪弁で元気に明るく回答します。",
        ),
        MessagesPlaceholder(variable_name="history"),
        ("human", "{input}"),
    ]
)

runnable = prompt | model

store = {}


def get_session_history(user_id: str, conversation_id: str) -> BaseChatMessageHistory:
    if (user_id, conversation_id) not in store:
        store[(user_id, conversation_id)] = ChatMessageHistory()
    return store[(user_id, conversation_id)]


with_message_history = RunnableWithMessageHistory(
    runnable,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history",
    history_factory_config=[
        ConfigurableFieldSpec(
            id="user_id",
            annotation=str,
            name="User ID",
            description="Unique identifier for the user.",
            default="",
            is_shared=True,
        ),
        ConfigurableFieldSpec(
            id="conversation_id",
            annotation=str,
            name="Conversation ID",
            description="Unique identifier for the conversation.",
            default="",
            is_shared=True,
        ),
    ],
)

with_message_history.invoke(
    {"ability": "数学", "input": "こんにちは！三角関数がわからへんねん。"},
    config={"configurable": {"user_id": "123", "conversation_id": "1"}},
)

with_message_history.invoke(
    {"ability": "数学", "input": "なんて？"},
    config={"configurable": {"user_id": "123", "conversation_id": "1"}},
)

with_message_history.invoke(
    {"ability": "数学", "input": "なんて？"},
    config={"configurable": {"user_id": "123", "conversation_id": "2"}},
)

from langchain_core.messages import HumanMessage
from langchain_core.runnables import RunnableParallel
from langchain_openai.chat_models import ChatOpenAI
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory


chain = RunnableParallel({"output_message": ChatOpenAI()})


def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

store = {}

with_message_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    output_messages_key="output_message",
)

with_message_history.invoke(
    [HumanMessage(content="こんにちは！三角関数がわからへんねん。")],
    config={"configurable": {"session_id": "baz"}},
)

with_message_history.invoke(
    [HumanMessage(content="基本的な概念から教えて欲しい。")],
    config={"configurable": {"session_id": "baz"}},
)

store["baz"].messages

!sudo yes | add-apt-repository ppa:redislabs/redis
!sudo apt-get update
!sudo apt-get install redis
!pip install redis

!service redis-server start

REDIS_URL = "redis://localhost:6379/0"

from langchain_community.chat_message_histories import RedisChatMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai.chat_models import ChatOpenAI
from langchain_core.runnables.history import RunnableWithMessageHistory

model = ChatOpenAI(model="gpt-3.5-turbo")

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "あなたは{ability}が得意な大阪のおばちゃんです。20字以内で簡潔、かつ大阪弁で元気に明るく回答します。",
        ),
        MessagesPlaceholder(variable_name="history"),
        ("human", "{input}"),
    ]
)

runnable = prompt | model

def get_message_history(session_id: str) -> RedisChatMessageHistory:
    return RedisChatMessageHistory(session_id, url=REDIS_URL)

with_message_history = RunnableWithMessageHistory(
    runnable,
    get_message_history,
    input_messages_key="input",
    history_messages_key="history",
)

with_message_history.invoke(
    {"ability": "数学", "input": "コサインってどういう意味？"},
    config={"configurable": {"session_id": "abc123"}},
)

$ redis-cli

127.0.0.1:6379> keys *
message_store:abc123
127.0.0.1:6379> type message_store:abc123
list
127.0.0.1:6379> lrange message_store:abc123 0 -1
{"type": "ai", "data": {"content": "\u30b3\u30b5\u30a4\u30f3\u3063\u3066\u306e\u306f\u3001\u4e09\u89d2\u95a2\u6570\u306e\u4e00\u3064\u3067\u3001\u96a3\u8fba\u3068\u659c\u8fba\u306e\u6bd4\u3092\u8868\u3059\u3067\u3002\u304a\u304a\u304b\u305f\u305d\u3093\u306a\u611f\u3058\u3084\u306d\u3093\u3002", "additional_kwargs": {}, "response_metadata": {"token_usage": {"completion_tokens": 46, "prompt_tokens": 74, "total_tokens": 120}, "model_name": "gpt-3.5-turbo", "system_fingerprint": "fp_c2295e73ad", "finish_reason": "stop", "logprobs": null}, "type": "ai", "name": null, "id": "run-40a5ae0c-d6d2-4752-a3a3-845e97d45b65-0", "example": false, "tool_calls": [], "invalid_tool_calls": []}}
{"type": "human", "data": {"content": "\u30b3\u30b5\u30a4\u30f3\u3063\u3066\u3069\u3046\u3044\u3046\u610f\u5473\uff1f", "additional_kwargs": {}, "response_metadata": {}, "type": "human", "name": null, "id": null, "example": false}}

AIMessage(content='隣と斜めの長さの比率を表す関数やで。わかりやすいかな？', response_metadata={'token_usage': {'completion_tokens': 30, 'prompt_tokens': 131, 'total_tokens': 161}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_c2295e73ad', 'finish_reason': 'stop', 'logprobs': None}, id='run-1584d52b-6341-4fe5-9790-7dcc7aaa84fb-0')

prompt_tmpl = PromptTemplate(prompt_str)

llm = OpenAI(model="gpt-3.5-turbo")
retriever = index.as_retriever(similarity_top_k=5)

p = QueryPipeline(
    chain=[prompt_tmpl1, llm, prompt_tmpl2, llm, retriever], verbose=True
)

p = QueryPipeline(verbose=True)
p.add_modules(
    {
        "llm": llm,
        "prompt_tmpl": prompt_tmpl,
        "retriever": retriever,
        "summarizer": summarizer,
        "reranker": reranker,
    }
)

p.add_link("prompt_tmpl", "llm")
p.add_link("llm", "retriever")
p.add_link("retriever", "reranker", dest_key="nodes")
p.add_link("llm", "reranker", dest_key="query_str")
p.add_link("reranker", "summarizer", dest_key="nodes")
p.add_link("llm", "summarizer", dest_key="query_str")

!pip install grandalf

chain.get_graph().print_ascii()

           +---------------------------------+         
           | Parallel<context,question>Input |         
           +---------------------------------+         
                    **               **                
                 ***                   ***             
               **                         **           
+----------------------+              +-------------+  
| VectorStoreRetriever |              | Passthrough |  
+----------------------+              +-------------+  
                    **               **                
                      ***         ***                  
                         **     **                     
           +----------------------------------+        
           | Parallel<context,question>Output |        
           +----------------------------------+        
                             *                         
                             *                         
                             *                         
                  +--------------------+               
                  | ChatPromptTemplate |               
                  +--------------------+               
                             *                         
                             *                         
                             *                         
                      +------------+                   
                      | ChatOpenAI |                   
                      +------------+                   
                             *                         
                             *                         
                             *                         
                   +-----------------+                 
                   | StrOutputParser |                 
                   +-----------------+                 
                             *                         
                             *                         
                             *                         
                +-----------------------+              
                | StrOutputParserOutput |              
                +-----------------------+              

!apt install libgraphviz-dev
!pip install pygraphviz

from IPython.display import Image

Image(chain.get_graph().draw_png())

!pip install --upgrade --quiet langchain langchain-core langchain-openai langchain-anthropic

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')
os.environ['ANTHROPIC_API_KEY'] = userdata.get('ANTHROPIC_API_KEY')

from langchain_anthropic import ChatAnthropic
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import PromptTemplate

classify_prompt = """\
以下のユーザーからの質問に対して、`LangChain`、`Anthropic`、`Other`のいずれかに分類してください。

複数の単語で回答しないでください。

<question>
{question}
</question>

Classification: \
"""

llm = ChatAnthropic(model_name="claude-3-haiku-20240307")

chain = (
    PromptTemplate.from_template(classify_prompt)
    | llm
    | StrOutputParser()
)

chain.invoke({"question": "LangChainのLCELの使い方を教えて?"})

chain.invoke({"question": "AnthropicのAPIの使い方を教えて?"})

chain.invoke({"question": "OpenAIのAPIの使い方を教えて?"})

langchain_prompt = """
あなたはLangChainの専門家です。
質問に答える場合は、常に「ハリソン・チェイスは私にこう言いました：」で始めなさい。
次の質問に答えてください：

質問： {question}
回答: \
"""

anthropic_prompt = """\
あなたはLangChainの専門家です。
質問に答える場合は、常に「ダリオ・アモデイは私にこう言いました：」で始めなさい。
次の質問に答えてください：

質問： {question}
回答: \
"""

general_prompt = """\
次の質問に答えてください：

質問： {question}
回答: \
"""

langchain_chain = PromptTemplate.from_template(langchain_prompt) | llm
anthropic_chain = PromptTemplate.from_template(anthropic_prompt) | llm
general_chain = PromptTemplate.from_template(general_prompt) | llm

langchain_chain.invoke("明日の天気を教えて").content[:50]

anthropic_chain.invoke("明日の天気を教えて").content[:50]

general_chain.invoke("明日の天気を教えて").content[:50]

from langchain_core.runnables import RunnableLambda

def route(info):
    if "anthropic" in info["topic"].lower():
        return anthropic_chain
    elif "langchain" in info["topic"].lower():
        return langchain_chain
    else:
        return general_chain

full_chain = (
    {"topic": chain, "question": lambda x: x["question"]}
    | RunnableLambda(route)
)

full_chain.invoke({"question": "LangChainのLCELの使い方を教えて?"}).content[:50]

full_chain.invoke({"question": "AnthropicのAPIの使い方を教えて?"}).content[:50]

full_chain.invoke({"question": "OpenAIのAPIの使い方を教えて?"}).content[:50]

from langchain_core.runnables import RunnableBranch

branch = RunnableBranch(
    (lambda x: "anthropic" in x["topic"].lower(), anthropic_chain),
    (lambda x: "langchain" in x["topic"].lower(), langchain_chain),
    general_chain,
)

full_chain_with_branch = (
    {"topic": chain, "question": lambda x: x["question"]}
    | branch
)

full_chain_with_branch.invoke({"question": "LangChainのLCELの使い方を教えて?"}).content[:50]

full_chain_with_branch.invoke({"question": "AnthropicのAPIの使い方を教えて?"}).content[:50]

full_chain_with_branch.invoke({"question": "OpenAIのAPIの使い方を教えて?"}).content[:50]

from langchain.utils.math import cosine_similarity
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_core.runnables import RunnableLambda, RunnablePassthrough
from langchain_openai import OpenAIEmbeddings

physics_template = """\
あなたはとても賢い物理学の教授です。出身は大阪で、常に大阪弁で話します。
あなたは物理学に関する質問に簡潔にわかりやすく回答するのが得意です。
質問の答えがわからないときは、わからないと認めます。

質問はこれです:
{query}
"""

math_template = """\
あなたはとても優秀な数学者でギャルです。常にギャル語で話します。
あなたは数学の質問に回答するのが得意です。
あなたが優秀なのは、難しい問題を構成要素に分解、構成要素ごとに回答、そしてそれらを組み合わせてより幅広い問題に答えることができるからです

質問はこれです:
{query}
"""

embeddings = OpenAIEmbeddings()

prompt_templates = [physics_template, math_template]

prompt_embeddings = embeddings.embed_documents(prompt_templates)

def prompt_router(input):
    query_embedding = embeddings.embed_query(input["query"])
    similarity = cosine_similarity([query_embedding], prompt_embeddings)[0]
    most_similar = prompt_templates[similarity.argmax()]
    print("Using MATH" if most_similar == math_template else "Using PHYSICS")
    return PromptTemplate.from_template(most_similar)


chain = (
    {"query": RunnablePassthrough()}
    | RunnableLambda(prompt_router)
    | ChatAnthropic(model_name="claude-3-haiku-20240307")
    | StrOutputParser()
)

print(chain.invoke("ブラックホールとはなんですか？"))

chain.invoke("線積分とはなんですか？")

!pip install --upgrade --quiet langchain langchain-openai faiss-cpu tiktoken grandalf

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

from langchain.prompts import ChatPromptTemplate
from langchain_community.vectorstores import FAISS
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI, OpenAIEmbeddings

texts = []
texts.append("""\
イクイノックス（欧字名:Equinox、2019年3月23日 - ）は、日本の競走馬・種牡馬。
主な勝ち鞍は、2022年・2023年の天皇賞（秋）連覇、2022年の有馬記念、2023年のドバイシーマクラシック、宝塚記念、ジャパンカップ。\
""")
texts.append("""\
オグリキャップ（欧字名:Oguri Cap、1985年3月27日 - 2010年7月3日）は、日本の競走馬、種牡馬。
主な勝ち鞍は、1988年・1990年の有馬記念、1989年のマイルチャンピオンシップ、1990年の安田記念。\
""")
texts.append("""\
ドウデュース（欧字名:Do Deuce、2019年5月7日 - ）は、日本の競走馬。
主な勝ち鞍は、2021年の朝日杯フューチュリティステークス、2022年の東京優駿、2023年の有馬記念。\
""")

vectorstore = FAISS.from_texts(
    texts, embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever()

template = """\
以下のコンテキストにもとづいて、質問に答えてください:
{context}

質問: {question}
回答: \
"""
prompt = ChatPromptTemplate.from_template(template)

model = ChatOpenAI(model="gpt-3.5-turbo-0125")

chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | model
    | StrOutputParser()
)

chain.invoke("オグリキャップの主な勝ち鞍は？")

chain.get_graph()

chain.get_graph().print_ascii()

           +---------------------------------+         
           | Parallel<context,question>Input |         
           +---------------------------------+         
                    **               **                
                 ***                   ***             
               **                         **           
+----------------------+              +-------------+  
| VectorStoreRetriever |              | Passthrough |  
+----------------------+              +-------------+  
                    **               **                
                      ***         ***                  
                         **     **                     
           +----------------------------------+        
           | Parallel<context,question>Output |        
           +----------------------------------+        
                             *                         
                             *                         
                             *                         
                  +--------------------+               
                  | ChatPromptTemplate |               
                  +--------------------+               
                             *                         
                             *                         
                             *                         
                      +------------+                   
                      | ChatOpenAI |                   
                      +------------+                   
                             *                         
                             *                         
                             *                         
                   +-----------------+                 
                   | StrOutputParser |                 
                   +-----------------+                 
                             *                         
                             *                         
                             *                         
                +-----------------------+              
                | StrOutputParserOutput |              
                +-----------------------+              

chain.get_prompts()

!apt install libgraphviz-dev
!pip install pygraphviz

from IPython.display import Image

chain.get_graph().draw_png("graph.png")
Image("graph.png")

/usr/local/lib/python3.10/dist-packages/pygraphviz/agraph.py:1407: RuntimeWarning: Error: not well-formed (invalid token) in line 1 
... Parallel<context,question> ...
in label of node 3c4302d679a44a769fd4999d1836dc41
Error: not well-formed (invalid token) in line 1 
... Parallel<context,question> ...
in label of node e9165e4ba266408ea3f1a5bd4f00da07

  warnings.warn(b"".join(errors).decode(self.encoding), RuntimeWarning)

from IPython.display import Image

Image(chain.get_graph().draw_mermaid_png())

print(chain.get_graph().draw_mermaid())

%%{init: {'flowchart': {'curve': 'linear'}}}%%
graph TD;
	Parallel_context_question_Input[Parallel_context_question_Input]:::startclass;
	Parallel_context_question_Output([Parallel_context_question_Output]):::otherclass;
	VectorStoreRetriever([VectorStoreRetriever]):::otherclass;
	Passthrough([Passthrough]):::otherclass;
	ChatPromptTemplate([ChatPromptTemplate]):::otherclass;
	ChatOpenAI([ChatOpenAI]):::otherclass;
	StrOutputParser([StrOutputParser]):::otherclass;
	StrOutputParserOutput[StrOutputParserOutput]:::endclass;
	Parallel_context_question_Input --> VectorStoreRetriever;
	VectorStoreRetriever --> Parallel_context_question_Output;
	Parallel_context_question_Input --> Passthrough;
	Passthrough --> Parallel_context_question_Output;
	Parallel_context_question_Output --> ChatPromptTemplate;
	ChatPromptTemplate --> ChatOpenAI;
	StrOutputParser --> StrOutputParserOutput;
	ChatOpenAI --> StrOutputParser;
	classDef startclass fill:#ffdfba;
	classDef endclass fill:#baffc9;
	classDef otherclass fill:#fad7de;

!pip install --upgrade --quiet langchain langchain-openai

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

# LangSmithでトレーシング有効化
os.environ['LANGCHAIN_TRACING_V2'] = "true"
os.environ['LANGCHAIN_API_KEY'] = userdata.get('LANGCHAIN_API_KEY')

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import chain
from langchain_openai import ChatOpenAI

prompt1 = ChatPromptTemplate.from_template("{topic}に関するジョークを教えてください")
prompt2 = ChatPromptTemplate.from_template("このジョークの主題は何ですか：{joke}")

@chain
def custom_chain(text):
    prompt_val1 = prompt1.invoke({"topic": text})
    output1 = ChatOpenAI().invoke(prompt_val1)

    parsed_output1 = StrOutputParser().invoke(output1)
    chain2 = prompt2 | ChatOpenAI() | StrOutputParser()

    return chain2.invoke({"joke": parsed_output1})

custom_chain.invoke({"topic": "クマ"})

!pip install --upgrade --quiet  langchain langchain-openai wikipedia

import os
from google.colab import userdata

os.environ['OPENAI_API_KEY'] = userdata.get('OPENAI_API_KEY')

from operator import itemgetter

from langchain.agents import AgentExecutor, load_tools
from langchain.agents.format_scratchpad import format_to_openai_function_messages
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
from langchain_community.tools import WikipediaQueryRun
from langchain_community.utilities import WikipediaAPIWrapper
from langchain_core.prompt_values import ChatPromptValue
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai import ChatOpenAI

wiki = WikipediaQueryRun(
    api_wrapper=WikipediaAPIWrapper(top_k_results=5, doc_content_chars_max=10_000)
)
tools = [wiki]

prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "あなたは親切なアシスタントです。"),
        ("user", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ]
)

llm = ChatOpenAI(model="gpt-3.5-turbo-0613")    # 最大4096トークン

agent = (
    {
        "input": itemgetter("input"),
        "agent_scratchpad": lambda x: format_to_openai_function_messages(
            x["intermediate_steps"]
        ),
    }
    | prompt
    | llm.bind_functions(tools)
    | OpenAIFunctionsAgentOutputParser()
)

agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
agent_executor.invoke(
    {
        "input": "現在のアメリカ大統領は？彼の出身州は？その出身州の州鳥は？その鳥の学名は？"
    }
)