Langchain Cheat Sheet
Models
from langchain.chat_models import ChatOpenAI
llm = ChatOpenAI(temperature=0.0)
Prompts
from langchain.prompts import ChatPromptTemplate
template_text = "<> {style} <> text: {text} <>"
prompt_template = ChatPromptTemplate.from_template(template_text)
style_input = "<>"
text_input = "<>"
messages = prompt_template.format_messages (style=style_input, text=text_input)
response = llm(customer_messages)
print(response.content)
Parsers
Output formatting without parser:
from langchain.prompts import ChatPromptTemplate
template_text = "<> field1:<> field2:<> field3:<> <> text: {text}<>"
prompt_template = ChatPromptTemplate.from_template(template_text)
text_input = "<>"
messages = prompt_template.format_messages(text=text_input)
response = llm(messages)
print(response.content)
Corresponding code with output parser:
from langchain.prompts import ChatPromptTemplate
from langchain.output_parsers import ResponseSchema
from langchain.output_parsers import StructuredOutputParser
field1_schema = ResponseSchema(name="field1", description="desc1")
field2_schema = ResponseSchema(name="field2", description="desc2")
field3_schema = ResponseSchema(name="field3", description="desc3")
response_schemas = [field1_schema, field2_schema, field3_schema]
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
format_instructions = output_parser.get_format_instructions()
template_text = "<> field1:<> field2:<> field3:<> <> text: {text}<> {format_instructions} <>"
prompt = ChatPromptTemplate.from_template(template=template_text)
text_input = "<>"
messages = prompt.format_messages(text=text_input format_instructions=format_instructions)
response = llm(messages)
output_dict = output_parser.parse(response.content)
print(output_dict.get('field1'))
print(output_dict.get('field2'))
print(output_dict.get('field3'))
Memory
ConversationBufferMemory
from langchain.chat_models import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
llm = ChatOpenAI(temperature=0.0)
memory = ConversationBufferMemory()
chain = ConversationChain(
llm=llm,
memory = memory,
verbose=True
)
chain.predict(input="prompt 1")
chain.predict(input="prompt 2")
print(memory.buffer)
memory.load_memory_variables({}) # contains prompt1,2 and ai responses
memory.save_context({"input": "prompt3"}, {"output": "ai response3"})
memory.load_memory_variables({}) # contains prompt1,2,3 and ai responses
Memory with constraints
from langchain.memory import ConversationBufferWindowMemory
window_size = 1
memory = ConversationBufferWindowMemory(k=window_size)
memory.save_context({"input": "prompt1"}, {"output": "ai response1"})
memory.save_context({"input": "prompt2"}, {"output": "ai response2"})
memory.load_memory_variables({}) # windows size is 1: keeps just last conversation (prompt2 and response 2)
# token limit
memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=30)
memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=100)
Chains
LLMChain
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import LLMChain
llm = ChatOpenAI(temperature=0.9)
prompt = ChatPromptTemplate.from_template("<>{input}<>")
chain = LLMChain(llm=llm, prompt=prompt)
input_text = "<>"
chain.run(input_text)
SimpleSequentialChain
Each chain has 1 input and 1 output.
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import SimpleSequentialChain
llm = ChatOpenAI(temperature=0.9)
# chain 1
prompt1 = ChatPromptTemplate.from_template("<>{input}<>")
chain1 = LLMChain(llm=llm, prompt=prompt1)
# chain 2
prompt2 = ChatPromptTemplate.from_template("<>{input2}<>")
chain2 = LLMChain(llm=llm, prompt=prompt2)
chain = SimpleSequentialChain(chains=chain1, chain2],verbose=True)
input_text = "<>"
chain.run(input_text)
SequentialChain
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import SequentialChain
llm = ChatOpenAI(temperature=0.9)
prompt1 = ChatPromptTemplate.from_template("<>{intput_text}<>")
chain1 = LLMChain(llm=llm, prompt=prompt1, output_key="output_text1")
prompt2 = ChatPromptTemplate.from_template("<>{output_text1}<>")
chain2 = LLMChain(llm=llm, prompt=prompt2, output_key="output_text2")
prompt3 = ChatPromptTemplate.from_template("<>{intput_text}<>")
chain3 = LLMChain(llm=llm, prompt=prompt3, output_key="output_text3")
prompt4 = ChatPromptTemplate.from_template("<>{output_text2}<>{output_text3}<>")
chain4 = LLMChain(llm=llm, prompt=prompt4, output_key="output_text4")
chain = SequentialChain(
chains=[chain1, chain2, chain3, chain4],
input_variables=["intput_text"],
output_variables=["output_text1", "output_text2","output_text4"],
verbose=True
)
input_text = "<>"
chain(input_text)
Router Chain
from langchain.chains.router import MultiPromptChain
from langchain.chains.router.llm_router import LLMRouterChain,RouterOutputParser
from langchain.prompts import PromptTemplate
llm = ChatOpenAI(temperature=0)
template_text1 = "<>{input}<>"
template_text2 = "<>{input}<>"
template_text3 = "<>{input}<>"
prompt1 = ChatPromptTemplate.from_template(template=template_text1)
chain1 = LLMChain(llm=llm, prompt=prompt1)
chains = {'domain1':chain1, 'domain2':chain2, 'domain3':chain3}
domains_str = "\n".join(['domain1: Good for domain1', 'domain2: Good for domain2', 'domain3: Good for domain3'])
prompt_default = ChatPromptTemplate.from_template("{input}")
chain_default = LLMChain(llm=llm, prompt=prompt_default)s
router_tamplate_text_0 = """
<>
<< FORMATTING >>
Return a markdown code snippet with a JSON object formatted to look like:
```json
}}
REMEMBER: "destination" MUST be one of the candidate prompt \
names specified below OR it can be "DEFAULT" if the input is not\
well suited for any of the candidate prompts.
REMEMBER: "next_inputs" can just be the original input \
if you don't think any modifications are needed.
<< CANDIDATE PROMPTS >>
{domains}
<< INPUT >>
<< OUTPUT (remember to include the ```json)>>
"""
router_tamplate_text = router_tamplate_text_0.format(
domains=domains_str
)
router_prompt = PromptTemplate(
template=router_tamplate_text,
input_variables=["input"],
output_parser=RouterOutputParser(),
)
router_chain = LLMRouterChain.from_llm(llm, router_prompt)
chain = MultiPromptChain(router_chain=router_chain, destination_chains=chains, default_chain=chain_default, verbose=True)
chain.run("<>")
Indexes
One Line Index Creation
from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI
from langchain.vectorstores import DocArrayInMemorySearch# alternative to DocArrayInMemorySearch
# from langchain.vectorstores import Chroma
from langchain.indexes import VectorstoreIndexCreator
loader = ## e.g. CSVLoader(file_path=file)
index = VectorstoreIndexCreator(
vectorstore_cls=DocArrayInMemorySearch
# embedding=embeddings,
# text_splitter=CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
).from_loaders([loader])
query ="<>"
response = index.query(query)
Walkthrough
from langchain.chat_models import ChatOpenAI
from langchain.vectorstores import DocArrayInMemorySearch
# alternative to DocArrayInMemorySearch
# from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
loader = ## e.g. CSVLoader(file_path=file)
docs = loader.load()
embeddings = OpenAIEmbeddings()
db = DocArrayInMemorySearch.from_documents(
docs,
embeddings
)
## or Chroma is alternative
# db = Chroma.from_documents(docs, embeddings)
query = "<>"
llm = ChatOpenAI(temperature = 0.0)
# combine documents
selected_docs = db.similarity_search(query)
combined_docs = "".join([docs[i].page_content for i in range(len(selected_docs))])
response = llm.call_as_llm(f"{combined_docs} Question: <>")
# or use a chain
retriever = db.as_retriever()
qa_stuff = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=retriever,
verbose=True
)
response = qa_stuff.run(query)
Generate Evaluation Datas
from langchain.chat_models import ChatOpenAI
from langchain.evaluation.qa import QAGenerateChain
examples = [
{
"query": "Do the Cozy Comfort Pullover Set\
have side pockets?",
"answer": "Yes"
},
{
"query": "What collection is the Ultra-Lofty \
850 Stretch Down Hooded Jacket from?",
"answer": "The DownTek collection"
}
]
loader = # CSVLoader(file_path=file)
data = loader.load()
example_gen_chain = QAGenerateChain.from_llm(ChatOpenAI())
new_examples = example_gen_chain.apply_and_parse(
[{"doc": t} for t in data[:5]]
)
examples += new_examples
Debug
import langchain
langchain.debug = True
# do sth.
# qa.run(examples[0]["query"])
langchain.debug = False
LM Assisted Evaluation
from langchain.evaluation.qa import QAEvalChain
llm = ChatOpenAI(temperature=0)
eval_chain = QAEvalChain.from_llm(llm)
predictions = qa.apply(examples)
graded_outputs = eval_chain.evaluate(examples, predictions)
for i, eg in enumerate(examples):
print(f"Example {i}:")
print("Question: " + predictions[i]['query'])
print("Real Answer: " + predictions[i]['answer'])
print("Predicted Answer: " + predictions[i]['result'])
print("Predicted Grade: " + graded_outputs[i]['text'])
print()
Agents
Basic Tools
from langchain.agents.agent_toolkits import create_python_agent
from langchain.agents import load_tools, initialize_agent
from langchain.agents import AgentType
from langchain.tools.python.tool import PythonREPLTool
from langchain.python import PythonREPL
from langchain.chat_models import ChatOpenAI
llm = ChatOpenAI(temperature=0)
tools = load_tools(["llm-math","wikipedia"], llm=llm)
agent= initialize_agent(
tools,
llm,
agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,
handle_parsing_errors=True,
verbose = True)
question = "<>"
result = agent(question)
Python REPL Tools
agent = create_python_agent(
llm,
tool=PythonREPLTool(),
verbose=True
)
input_list = []
agent.run(f"""<>: {input_list}""") # e.g. sort list
Custom Tool
from langchain.agents import tool
from datetime import date
@tool
def time(text: str) -> str:
"""Returns todays date, use this for any \
questions related to knowing todays date. \
The input should always be an empty string, \
and this function will always return todays \
date - any date mathmatics should occur \
outside this function."""
return str(date.today())
agent= initialize_agent(
tools + [time],
llm,
agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,
handle_parsing_errors=True,
verbose = True)