Today we start something new! We start a series of videos on Langchain. I wanted to create more actionable content with more continuity in the long term to make sure people can learn and utilize that learning in their job. My goal is that this content on Langchain will help people apply those concepts to build great Large Language Model applications. This is the first video of many, and we cover some of the LangChain basics. Let me know if you like it!
What is LangChain
When you have a typical large language model, the way to interact with it is to ask a question and you get an answer. But it's pretty isolated from the rest of the world. You cannot really do much more than that.
So, if you want to build applications, you may want to connect your large language model to data. You may want to give it access to tools. You may want to give it memory access. And you may want to automate the process of prompt engineering. LangChain allows you to connect all those different aspects to build software applications.
LangChain basics
So let's demonstrate some capabilities of LangChain. Let's pip install it along the OpenAI python package:
! pip install langchain openai
We set up the OpenAI API key as part of the environment variables
import os
os.environ['OPENAI_API_KEY'] = ...
LLMs
We can import the OpenAI’s GPT-3 model and ask it questions
from langchain.llms import OpenAI
llm = OpenAI()
llm.predict('How are you?')
> "\n\nI'm doing well, thank you. How about you?"
We can also import the underlying model behind ChatGPT
from langchain.chat_models import ChatOpenAI
chat_model = ChatOpenAI()
chat_model.predict('How are you?')
> "As an AI, I don't have feelings, but I'm here to help you with any questions or tasks you have. How can I assist you today?"
The problem with raw LLMs is that they don’t remember the history of the conversations
chat_model.predict('What was my previous question?')
> "I'm sorry, but I am an AI language model and I don't have access to your previous questions."
Chains
We can create a chain that is going to help us augment the LLM
from langchain.chains import ConversationChain
chain = ConversationChain(
llm=chat_model,
verbose=True
)
chain.run('How are you today?')
As part of the prompt, we see now that there is a bit more to my simple prompt. We have a system prompt, the history of the conversation, and the human’s question. The system prompt allows us to give the LLM more context on what needs to be done. Let’s see if it remembers:
chain.run('What was my previous question?')
Prompt templates
With LangChain, we can automate a lot of the prompt engineering and for that, we can use prompt templates. Let’s create a prompt template
from langchain.prompts import PromptTemplate
template = """
Return all the subcategories of the following category
{category}
"""
prompt = PromptTemplate(
input_variables=['category'],
template=template
)
‘Category’ is an input variable that will be used once we run the chain. Let’s input it into a chain. We use LLMChain, which is the simplest chain we can use
from langchain.chains import LLMChain
chain = LLMChain(
llm=chat_model,
prompt=prompt,
verbose=True
)
chain.run('Machine Learning')
We can also break down the prompts into the system and human prompts. This is helpful when we build chatbots
from langchain.prompts import (
SystemMessagePromptTemplate,
HumanMessagePromptTemplate,
ChatPromptTemplate
)
system_template = """
You are a helpful assistant who generate comma separated lists.
A user will only pass a category and you should generate subcategories of that category in a comma separated list.
ONLY return comma separated and nothing more!
"""
human_template = '{category}'
system_message = SystemMessagePromptTemplate.from_template(
system_template
)
human_message = HumanMessagePromptTemplate.from_template(
human_template
)
Ans we can combine the 2 prompts into one:
prompt = ChatPromptTemplate.from_messages([
sytem_message, human_message
])
chain = LLMChain(
llm=chat_model,
prompt=prompt,
verbose=True
)
chain.run('Machine Learning')
This gives us more control of the LLM’s output, but we can go further by using an output parser.
Output parser
Let’s overwrite the base output parser and generate Python lists from the LLM’s response:
from langchain.schema import BaseOutputParser
class CommaSeparatedParser(BaseOutputParser):
def parse(self, text):
output = text.strip().split(',')
output = [o.strip() for o in output]
return output
chain = LLMChain(
llm=chat_model,
prompt=prompt,
output_parser=CommaSeparatedParser(),
verbose=True
)
chain.run('Machine Learning')
We can also feed the chain with multiple inputs:
input_list = [
{'category': 'food'},
{'category': 'country'},
{'category': 'colors'}
]
response = chain.apply(input_list)
response[2]['text']
Simple Sequence
We can also compose chains. Here we are creating a pipeline of chains, where the output of one chain is used as input in the next one. We create 2 chains: a title chain and a synopsis to automate the process of writing a play. First, we have a title chain:
title_template = """
You are a writer. Given a subject,
your job is to return a fun title for a play.
Subject: {subject}
Title:"""
title_chain = LLMChain.from_string(
llm=chat_model,
template=title_template
)
title_chain.run('Machine Learning')
> '"The Algorithmic Adventure: A Machine Learning Marvel"'
And a synopsis chain:
synopsis_template = """
You are a writer.
Given a title, write a synopsis for a play.
Title: {title}
Synopsis:"""
synopsis_chain = LLMChain.from_string(
llm=chat_model,
template=synopsis_template
)
title = "The Algorithmic Adventure: A Machine Learning Marvel"
synopsis_chain.run(title)
Let’s now combine those 2 chains by passing them as a list to the simple sequential chain:
from langchain.chains import SimpleSequentialChain
chain = SimpleSequentialChain(
chains=[title_chain, synopsis_chain],
verbose=True
)
chain.run('Machine Learning')
Potentially an interesting play!
This concludes our introduction to LangChain basics. I hope you had some fun. We will continue our introduction to Langchain in the next video. See you there!
Introduction to LangChain: LangChain Basics