forked from Archives/langchain
325 lines
9.5 KiB
Plaintext
325 lines
9.5 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"# Getting Started\n",
|
|
"\n",
|
|
"In this tutorial, we will learn about creating simple chains in LangChain. We will learn how to create a chain, add components to it, and run it.\n",
|
|
"\n",
|
|
"In this tutorial, we will cover:\n",
|
|
"- Using a simple LLM chain\n",
|
|
"- Creating sequential chains\n",
|
|
"- Creating a custom chain\n",
|
|
"\n",
|
|
"## Why do we need chains?\n",
|
|
"\n",
|
|
"Chains allow us to combine multiple components together to create a single, coherent application. For example, we can create a chain that takes user input, formats it with a PromptTemplate, and then passes the formatted response to an LLM. We can build more complex chains by combining multiple chains together, or by combining chains with other components.\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Query an LLM with the `LLMChain`\n",
|
|
"\n",
|
|
"The `LLMChain` is a simple chain that takes in a prompt template, formats it with the user input and returns the response from an LLM.\n",
|
|
"\n",
|
|
"To use the `LLMChain`, first create a prompt template."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 1,
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"from langchain.prompts import PromptTemplate\n",
|
|
"from langchain.llms import OpenAI\n",
|
|
"\n",
|
|
"llm = OpenAI(temperature=0.9)\n",
|
|
"prompt = PromptTemplate(\n",
|
|
" input_variables=[\"product\"],\n",
|
|
" template=\"What is a good name for a company that makes {product}?\",\n",
|
|
")"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"We can now create a very simple chain that will take user input, format the prompt with it, and then send it to the LLM."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 2,
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"\n",
|
|
"\n",
|
|
"Rainbow Socks Co.\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"from langchain.chains import LLMChain\n",
|
|
"chain = LLMChain(llm=llm, prompt=prompt)\n",
|
|
"\n",
|
|
"# Run the chain only specifying the input variable.\n",
|
|
"print(chain.run(\"colorful socks\"))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"You can use a chat model in an `LLMChain` as well:"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 5,
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"\n",
|
|
"\n",
|
|
"Rainbow Threads\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"from langchain.chat_models import ChatOpenAI\n",
|
|
"from langchain.prompts.chat import (\n",
|
|
" ChatPromptTemplate,\n",
|
|
" HumanMessagePromptTemplate,\n",
|
|
")\n",
|
|
"human_message_prompt = HumanMessagePromptTemplate(\n",
|
|
" prompt=PromptTemplate(\n",
|
|
" template=\"What is a good name for a company that makes {product}?\",\n",
|
|
" input_variables=[\"product\"],\n",
|
|
" )\n",
|
|
" )\n",
|
|
"chat_prompt_template = ChatPromptTemplate.from_messages([human_message_prompt])\n",
|
|
"chat = ChatOpenAI(temperature=0.9)\n",
|
|
"chain = LLMChain(llm=chat, prompt=chat_prompt_template)\n",
|
|
"print(chain.run(\"colorful socks\"))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"This is one of the simpler types of chains, but understanding how it works will set you up well for working with more complex chains."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Combine chains with the `SequentialChain`\n",
|
|
"\n",
|
|
"The next step after calling a language model is to make a series of calls to a language model. We can do this using sequential chains, which are chains that execute their links in a predefined order. Specifically, we will use the `SimpleSequentialChain`. This is the simplest type of a sequential chain, where each step has a single input/output, and the output of one step is the input to the next.\n",
|
|
"\n",
|
|
"In this tutorial, our sequential chain will:\n",
|
|
"1. First, create a company name for a product. We will reuse the `LLMChain` we'd previously initialized to create this company name.\n",
|
|
"2. Then, create a catchphrase for the product. We will initialize a new `LLMChain` to create this catchphrase, as shown below."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 3,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"second_prompt = PromptTemplate(\n",
|
|
" input_variables=[\"company_name\"],\n",
|
|
" template=\"Write a catchphrase for the following company: {company_name}\",\n",
|
|
")\n",
|
|
"chain_two = LLMChain(llm=llm, prompt=second_prompt)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"Now we can combine the two LLMChains, so that we can create a company name and a catchphrase in a single step."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 4,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"\n",
|
|
"\n",
|
|
"\u001b[1m> Entering new SimpleSequentialChain chain...\u001b[0m\n",
|
|
"\u001b[36;1m\u001b[1;3m\n",
|
|
"\n",
|
|
"Cheerful Toes.\u001b[0m\n",
|
|
"\u001b[33;1m\u001b[1;3m\n",
|
|
"\n",
|
|
"\"Spread smiles from your toes!\"\u001b[0m\n",
|
|
"\n",
|
|
"\u001b[1m> Finished SimpleSequentialChain chain.\u001b[0m\n",
|
|
"\n",
|
|
"\n",
|
|
"\"Spread smiles from your toes!\"\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"from langchain.chains import SimpleSequentialChain\n",
|
|
"overall_chain = SimpleSequentialChain(chains=[chain, chain_two], verbose=True)\n",
|
|
"\n",
|
|
"# Run the chain specifying only the input variable for the first chain.\n",
|
|
"catchphrase = overall_chain.run(\"colorful socks\")\n",
|
|
"print(catchphrase)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Create a custom chain with the `Chain` class\n",
|
|
"\n",
|
|
"LangChain provides many chains out of the box, but sometimes you may want to create a custom chain for your specific use case. For this example, we will create a custom chain that concatenates the outputs of 2 `LLMChain`s.\n",
|
|
"\n",
|
|
"In order to create a custom chain:\n",
|
|
"1. Start by subclassing the `Chain` class,\n",
|
|
"2. Fill out the `input_keys` and `output_keys` properties,\n",
|
|
"3. Add the `_call` method that shows how to execute the chain.\n",
|
|
"\n",
|
|
"These steps are demonstrated in the example below:"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 5,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"from langchain.chains import LLMChain\n",
|
|
"from langchain.chains.base import Chain\n",
|
|
"\n",
|
|
"from typing import Dict, List\n",
|
|
"\n",
|
|
"\n",
|
|
"class ConcatenateChain(Chain):\n",
|
|
" chain_1: LLMChain\n",
|
|
" chain_2: LLMChain\n",
|
|
"\n",
|
|
" @property\n",
|
|
" def input_keys(self) -> List[str]:\n",
|
|
" # Union of the input keys of the two chains.\n",
|
|
" all_input_vars = set(self.chain_1.input_keys).union(set(self.chain_2.input_keys))\n",
|
|
" return list(all_input_vars)\n",
|
|
"\n",
|
|
" @property\n",
|
|
" def output_keys(self) -> List[str]:\n",
|
|
" return ['concat_output']\n",
|
|
"\n",
|
|
" def _call(self, inputs: Dict[str, str]) -> Dict[str, str]:\n",
|
|
" output_1 = self.chain_1.run(inputs)\n",
|
|
" output_2 = self.chain_2.run(inputs)\n",
|
|
" return {'concat_output': output_1 + output_2}"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"Now, we can try running the chain that we called."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 6,
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Concatenated output:\n",
|
|
"\n",
|
|
"\n",
|
|
"Rainbow Socks Co.\n",
|
|
"\n",
|
|
"\"Step Into Colorful Comfort!\"\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"prompt_1 = PromptTemplate(\n",
|
|
" input_variables=[\"product\"],\n",
|
|
" template=\"What is a good name for a company that makes {product}?\",\n",
|
|
")\n",
|
|
"chain_1 = LLMChain(llm=llm, prompt=prompt_1)\n",
|
|
"\n",
|
|
"prompt_2 = PromptTemplate(\n",
|
|
" input_variables=[\"product\"],\n",
|
|
" template=\"What is a good slogan for a company that makes {product}?\",\n",
|
|
")\n",
|
|
"chain_2 = LLMChain(llm=llm, prompt=prompt_2)\n",
|
|
"\n",
|
|
"concat_chain = ConcatenateChain(chain_1=chain_1, chain_2=chain_2)\n",
|
|
"concat_output = concat_chain.run(\"colorful socks\")\n",
|
|
"print(f\"Concatenated output:\\n{concat_output}\")"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"That's it! For more details about how to do cool things with Chains, check out the [how-to guide](how_to_guides.rst) for chains."
|
|
]
|
|
}
|
|
],
|
|
"metadata": {
|
|
"kernelspec": {
|
|
"display_name": "Python 3 (ipykernel)",
|
|
"language": "python",
|
|
"name": "python3"
|
|
},
|
|
"language_info": {
|
|
"codemirror_mode": {
|
|
"name": "ipython",
|
|
"version": 3
|
|
},
|
|
"file_extension": ".py",
|
|
"mimetype": "text/x-python",
|
|
"name": "python",
|
|
"nbconvert_exporter": "python",
|
|
"pygments_lexer": "ipython3",
|
|
"version": "3.10.9"
|
|
},
|
|
"vscode": {
|
|
"interpreter": {
|
|
"hash": "b1677b440931f40d89ef8be7bf03acb108ce003de0ac9b18e8d43753ea2e7103"
|
|
}
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 4
|
|
}
|